projects/ldc: gen/functions.cpp comparison

comparison gen/functions.cpp @ 930:7985bb036db4

Follow the D ABI and pass the last arg in a register if it is a struct that fits.

author	Christian Kamm <kamm incasoftware de>
date	Tue, 03 Feb 2009 21:46:46 +0100
parents	545f54041d91
children	d3a6f1a96731 a904cc9bc064

comparison

equal deleted inserted replaced

-:0749c0757a43
+:7985bb036db4
 if (dVararg) {
 paramvec.push_back(DtoType(Type::typeinfo->type->arrayOf())); // _arguments
 paramvec.push_back(getVoidPtrType()); // _argptr
 }
+// now that all implicit args are done, store the start of the real args
+f->firstRealArg = paramvec.size();
 // number of formal params
 size_t n = Argument::dim(f->parameters);
 #if X86_REVERSE_PARAMS
 // on x86 we need to reverse the formal params in some cases to match the ABI
 // extern(D) linkage
 // not a D-style vararg
 if (n > 1 && f->linkage == LINKd && !dVararg)
 {
 f->reverseParams = true;
-f->reverseIndex = paramvec.size();
 }
 }
 #endif // X86_REVERSE_PARAMS
 }
 // reverse params?
 if (f->reverseParams)
 {
-std::reverse(paramvec.begin() + f->reverseIndex, paramvec.end());
+std::reverse(paramvec.begin() + f->firstRealArg, paramvec.end());
 }
-// construct function type
-bool isvararg = !(dVararg || arrayVararg) && f->varargs;
-llvm::FunctionType* functype = llvm::FunctionType::get(actualRettype, paramvec, isvararg);
 #if X86_PASS_IN_EAX
-// tell first param to be passed in a register if we can
+// pass first param in EAX if it fits, is not floating point and is not a 3 byte struct.
 // ONLY extern(D) functions !
 if ((n > 0 || usesthis || usesnest) && f->linkage == LINKd)
 {
 // FIXME: Only x86 right now ...
 if (global.params.cpu == ARCHx86)
 {
-// pass first param in EAX if it fits, is not floating point and is not a 3 byte struct.
-// FIXME: struct are not passed in EAX yet
 int n_inreg = f->reverseParams ? n - 1 : 0;
 Argument* arg = Argument::getNth(f->parameters, n_inreg);
 // if there is a implicit context parameter, pass it in EAX
 if (usesthis || usesnest)
 // otherwise check the first formal parameter
 else
 {
 Type* t = arg->type->toBasetype();
-// 32bit ints, pointers, classes, static arrays, AAs, ref and out params
+// 32bit ints, pointers, classes, static arrays, AAs, ref and out params,
+// and structs with size <= 4 and != 3
 // are candidate for being passed in EAX
 if (
 (arg->storageClass & (STCref|STCout))
 ||
 ((arg->storageClass & STCin) &&
 ((t->isscalar() && !t->isfloating()) ||
-t->ty == Tclass || t->ty == Tsarray || t->ty == Taarray) &&
+t->ty == Tclass || t->ty == Tsarray || t->ty == Taarray ||
-(t->size() <= PTRSIZE))
+(t->ty == Tstruct && t->size() != 3)
+) && (t->size() <= PTRSIZE))
 )
 {
 arg->llvmAttrs |= llvm::Attribute::InReg;
 assert((f->thisAttrs & llvm::Attribute::InReg) == 0 && "can't have two inreg args!");
+// structs need to go from {...}* byval to {...} inreg
+if ((arg->storageClass & STCin) && t->ty == Tstruct)
+{
+int n_param = f->reverseParams ? f->firstRealArg + n - 1 - n_inreg : f->firstRealArg + n_inreg;
+assert(isaPointer(paramvec[n_param]) && (arg->llvmAttrs & llvm::Attribute::ByVal)
+&& "struct parameter expected to be {...}* byval before inreg is applied");
+paramvec[n_param] = paramvec[n_param]->getContainedType(0);
+arg->llvmAttrs &= ~llvm::Attribute::ByVal;
+f->structInregArg = true;
+}
 }
 }
 }
 }
 #endif // X86_PASS_IN_EAX
+// construct function type
+bool isvararg = !(dVararg || arrayVararg) && f->varargs;
+llvm::FunctionType* functype = llvm::FunctionType::get(actualRettype, paramvec, isvararg);
 // done
 f->retInPtr = retinptr;
 f->usesThis = usesthis;
 f->usesNest = usesnest;
 for (int i=0; i < n; ++i)
 {
 Dsymbol* argsym = (Dsymbol*)fd->parameters->data[i];
 VarDeclaration* vd = argsym->isVarDeclaration();
 assert(vd);
+IrLocal* irloc = vd->ir.irLocal;
+assert(irloc);
+// if it's inreg struct arg, allocate storage
+if (f->structInregArg && i == (f->reverseParams ? n - 1 : 0))
+{
+int n_param = f->reverseParams ? f->firstRealArg + n - 1 - i : f->firstRealArg + i;
+assert(!f->usesNest && !f->usesThis && isaStruct(functype->getParamType(n_param))
+&& "Preconditions for inreg struct arg not met!");
+LLValue* mem = DtoAlloca(functype->getParamType(n_param), "inregstructarg");
+DtoStore(irloc->value, mem);
+irloc->value = mem;
+}
 #if DMDV2
 if (vd->nestedrefs.dim)
 #else
 if (vd->nestedref)
 #endif
 {
 fd->nestedVars.insert(vd);
 }
-IrLocal* irloc = vd->ir.irLocal;
-assert(irloc);
 bool refout = vd->storage_class & (STCref | STCout);
 bool lazy = vd->storage_class & STClazy;
 if (!refout && (!DtoIsPassedByRef(vd->type) || lazy))

Mercurial > projects > ldc

comparison gen/functions.cpp @ 930:7985bb036db4