projects/ddmd: dmd/codegen/Util.d comparison

comparison dmd/codegen/Util.d @ 174:af724d3510d7

lot os toCBuffer methods implemented moved shared Type.* stuff into Global

author	korDen
date	Sun, 10 Oct 2010 03:47:23 +0400
parents	31c086f76669
children	1475fd394c9e

comparison

equal deleted inserted replaced

-:d237b38b5858
+:af724d3510d7
 /************************************
 * Call a function.
 */
 elem* callfunc(Loc loc,
 	IRState* irs,
 	int directcall,		// 1: don't do virtual call
 	Type tret,		// return type
 	elem *ec,		// evaluates to function address
 	Type ectype,		// original type of ec
 		ethis = el_una(OPER.OP64_32, TYM.TYnptr, ethis);	// get this
 		ec = array_toPtr(t, ec);		// get funcptr
 		ec = el_una(OPER.OPind, tf.totym(), ec);
 }
 else
 {
 		assert(t.ty == TY.Tfunction);
 		tf = cast(TypeFunction)t;
 }
 retmethod = tf.retStyle();
 {
 		// j=1 if _arguments[] is first argument
 		int j = (tf.linkage == LINK.LINKd && tf.varargs == 1);
 		foreach (size_t i, Expression arg; arguments)
 		{
 			elem* ea;
 			//writef("\targ[%d]: %s\n", i, arg.toChars());
 			size_t nparams = Parameter.dim(tf.parameters);
 }
 if (retmethod == RET.RETstack)
 {
 		if (!ehidden)
 		{
 			// Don't have one, so create one
 			type* tt;
 			Type tret2 = tf.next; // in dmd tret is shadowed here, so -> tret2
 			if (tret2.toBasetype().ty == Tstruct ||
 /**************************************
 * Fake a struct symbol.
 */
 Classsym* fake_classsym(Identifier id)
 {
 	TYPE* t;
 Classsym* scc;
 scc = cast(Classsym*)symbol_calloc(toStringz(id.toChars()));
 scc.Sclass = SC.SCstruct;
 		/* These two are compiler generated functions for the in and out contracts,
 		 * and are called from an overriding function, not just the one they're
 		 * nested inside, so this hack is so they'll pass
 		 */
 		fd.ident == Id.require || fd.ident == Id.ensure)
 {
 		/* Going down one nesting level, i.e. we're calling
 		 * a nested function from its enclosing function.
 		 */
 ///version (DMDV2) {
 		if (irs.sclosure)
 			ethis = el_var(irs.sclosure);
 		else
 ///}
 		if (irs.sthis)
 		{
 			// We have a 'this' pointer for the current function
 			ethis = el_var(irs.sthis);
 			/* If no variables in the current function's frame are
 			 * referenced by nested functions, then we can 'skip'
 			bool cond = (thisfd.closureVars.dim != 0);
 } else {
 			bool cond = thisfd.nestedFrameRef;
 }
 			if (cond)
 			{
 				/* Local variables are referenced, can't skip.
 				 * Address of 'this' gives the 'this' for the nested
 				 * function
 				 */
 				ethis = el_una(OPER.OPaddr, TYM.TYnptr, ethis);
 			}
 		}
 		else
 		{
 			/* No 'this' pointer for current function,
 			 * use null if no references to the current function's frame
 			 */
 			ethis = el_long(TYM.TYnptr, 0);
 version (DMDV2) {
 			bool cond = (thisfd.closureVars.dim != 0);
 } else {
 			bool cond = thisfd.nestedFrameRef;
 }
 			if (cond)
 			{
 				/* OPframeptr is an operator that gets the frame pointer
 				 * for the current function, i.e. for the x86 it gets
 				 * the value of EBP
 				 */
 				ethis.Eoper = OPER.OPframeptr;
 			}
 		}
 		//if (fdparent != thisfd) ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYint, 0x18));
 }
 else
 {
 		if (!irs.sthis)		// if no frame pointer for this function
 		else
 		{
 			ethis = el_var(irs.sthis);
 			Dsymbol s = thisfd;
 			while (fd != s)
 			{
 				/* Go up a nesting level, i.e. we need to find the 'this'
 				 * of an enclosing function.
 				 * Our 'enclosing function' may also be an inner class.
 				 */
 				//printf("\ts = '%s'\n", s.toChars());
 				thisfd = s.isFuncDeclaration();
 				if (thisfd)
 				{
 					/* Enclosing function is a function.
 					 */
 					if (fdparent == s.toParent2())
 						break;
 						// Error should have been caught by front end
 						assert(0);
 					}
 				}
 				else
 				{
 					/* Enclosed by an aggregate. That means the current
 					 * function must be a member function of that aggregate.
 					 */
 					ClassDeclaration cd;
 					StructDeclaration sd;
 						 * of frames.
 						 */
 version (DMDV2) {
 						bool cond = (fdd.closureVars.dim != 0);
 } else {
 						bool cond = fdd.nestedFrameRef;
 }
 						if (cond) {
 							ethis = el_una(OPER.OPind, TYM.TYnptr, ethis);
 						}
 						break;
 //extern (C++) extern int intrinsic_op(char* name);
 OPER intrinsic_oper(const(char)* name)
 {
 	version(DMDV1)
-	static const(char) *namearray[] =
+	enum const(char) *namearray[] =
 	[
 		"4math3cosFeZe",
 		"4math3sinFeZe",
 		"4math4fabsFeZe",
 		"4math4rintFeZe",
 		"9intrinsic5bswapFkZk",
 		"9intrinsic5outplFkkZk",
 		"9intrinsic5outpwFktZt",
 	];
 else
-	static const(char) *namearray[] =
+	enum const(char) *namearray[] =
 	[
 		/* The names are mangled differently because of the pure and
 		 * nothrow attributes.
 		 */
 		"4math3cosFNaNbNfeZe",
 		"9intrinsic5bswapFNaNbkZk",
 		"9intrinsic5outplFNbkkZk",
 		"9intrinsic5outpwFNbktZt",
 	];
-	static const OPER ioptab[] =
+	enum OPER ioptab[] =
 	[
 		OPcos,
 		OPsin,
 		OPabs,
 		OPrint,
 		OPbswap,
 		OPoutp,
 		OPoutp,
 	];
 	debug
 	{
 		assert(namearray.length == ioptab.length);
 		// assume sorted namearray
 		for (int i = 0; i < namearray.length - 1; i++)
 		{
 		}
 }
 else if ((td = s.isTupleDeclaration()) !is null)
 {
 		for (size_t i = 0; i < td.objects.dim; i++)
 		{
 			auto o = td.objects[i];
 			///if (o.dyncast() == DYNCAST_EXPRESSION)
 			if (auto eo = cast(Expression)o)
 			{
 				if (eo.op == TOK.TOKdsymbol)
 				{
 					auto se = cast(DsymbolExp)eo;
 					e = el_combine(e, Dsymbol_toElem(se.s, irs));
 				}
 			}
 		}
 {
 //printf("resolveLengthVar()\n");
 elem* einit = null;
 if (lengthVar && !(lengthVar.storage_class & STC.STCconst))
 {
 		elem* elength;
 		Symbol* slength;
 		if (t1.ty == TY.Tsarray)
 		{
 			TypeSArray tsa = cast(TypeSArray)t1;
 			long length = tsa.dim.toInteger();
 			elength = el_long(TYM.TYuint, length);
 			goto L3;
 *	evalue	value to write
 *	edim	number of times to write evalue to eptr[]
 *	tb	type of evalue
 */
 elem* setArray(elem* eptr, elem* edim, Type tb, elem* evalue, IRState* irs, int op)
 {
 	int r;
 elem* e;
 int sz = cast(int)tb.size();
 if (tb.ty == TY.Tfloat80 || tb.ty == TY.Timaginary80)
 		 */
 		if (op != TOK.TOKblit)
 		{
 			StructDeclaration sd = needsPostblit(tb);
 			if (sd)
 			{
 				/* Need to do postblit.
 				 *   void *_d_arraysetassign(void *p, void *value, int dim, TypeInfo ti);
 				 */
 				r = (op == TOK.TOKconstruct) ? RTLSYM.RTLSYM_ARRAYSETCTOR : RTLSYM.RTLSYM_ARRAYSETASSIGN;
 				evalue = el_una(OPER.OPaddr, TYM.TYnptr, evalue);
 		Dsymbol cdp = ad.toParent2();	// class/func we're nested in
 		//printf("setEthis(ad = %s, cdp = %s, thisfd = %s)\n", ad.toChars(), cdp.toChars(), thisfd.toChars());
 		if (cdp is thisfd)
 		{
 			/* Class we're new'ing is a local class in this function:
 			 *	void thisfd() { class ad { } }
 			 */
 			if (irs.sclosure)
 				ethis = el_var(irs.sclosure);
 					cdp == thisfd.toParent2() || (
 								cdp.isClassDeclaration() && cdp.isClassDeclaration().isBaseOf(thisfd.toParent2().isClassDeclaration(), &offset)
 							)
 						)
 				)
 		{
 			/* Class we're new'ing is at the same level as thisfd
 			 */
 			assert(offset == 0);	// BUG: should handle this case
 			ethis = el_var(irs.sthis);
 		}
 while (t.ty == TY.Tsarray)
 		t = t.nextOf().toBasetype();
 if (t.ty == TY.Tstruct)
 {
 		StructDeclaration sd = (cast(TypeStruct)t).sym;
 		if (sd.postblit)
 			return sd;
 }
 					size_t len = tysize[tybasic(e.Ety)];
 					elem* es = el_calloc();
 					es.Eoper = OPER.OPstring;
 					// Match MEM_PH_FREE for OPstring in ztc\el.c
-					es.EV.ss.Vstring = cast(char*)malloc(len);	/// !
+					es.EV.ss.Vstring = cast(char*)GC.malloc(len);	/// !
 					memcpy(es.EV.ss.Vstring, &e.EV, len);
 					es.EV.ss.Vstrlen = len;
 					es.Ety = TYM.TYnptr;
 					e = es;
 		return null;
 }
 s = label.statement;
 if (!s.lblock)
 {
 		s.lblock = block_calloc(blx);
 		if (s.isReturnLabel)
 			s.lblock.Btry = null;
 }
 return s.lblock;
 * tries to use aligned int stores whereever possible.
 * Update *poffset to end of initialized hole; *poffset will be >= offset2.
 */
 elem* fillHole(Symbol* stmp, size_t* poffset, size_t offset2, size_t maxoff)
 {
 	elem* e = null;
 int basealign = 1;
 while (*poffset < offset2)
 {
 		tym_t ty;
 		elem* e1;
 		if (tybasic(stmp.Stype.Tty) == TYnptr)
 			e1 = el_var(stmp);
 		else
 			e1 = el_ptr(stmp);
 		if (basealign)
 			*poffset &= ~3;
 		basealign = 1;
 		size_t sz = maxoff - *poffset;
 		switch (sz)
 		{
 			case 1: ty = TYchar;	break;
 			case 2: ty = TYshort;	break;
 			case 3:
 				ty = TYshort;
 				basealign = 0;

Mercurial > projects > ddmd

comparison dmd/codegen/Util.d @ 174:af724d3510d7