// This function does roughly the same thing as GenerateThunk, but in a // very different way, so that va_start and va_end work correctly. // FIXME: This function assumes "this" is the first non-sret LLVM argument of // a function, and that there is an alloca built in the entry block // for all accesses to "this". // FIXME: This function assumes there is only one "ret" statement per function. // FIXME: Cloning isn't correct in the presence of indirect goto! // FIXME: This implementation of thunks bloats codesize by duplicating the // function definition. There are alternatives: // 1. Add some sort of stub support to LLVM for cases where we can // do a this adjustment, then a sibcall. // 2. We could transform the definition to take a va_list instead of an // actual variable argument list, then have the thunks (including a // no-op thunk for the regular definition) call va_start/va_end. // There's a bit of per-call overhead for this solution, but it's // better for codesize if the definition is long. void CodeGenFunction::GenerateVarArgsThunk( llvm::Function *Fn, const CGFunctionInfo &FnInfo, GlobalDecl GD, const ThunkInfo &Thunk) { const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl()); const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>(); QualType ResultType = FPT->getReturnType(); // Get the original function assert(FnInfo.isVariadic()); llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo); llvm::Value *Callee = CGM.GetAddrOfFunction(GD, Ty, /*ForVTable=*/true); llvm::Function *BaseFn = cast<llvm::Function>(Callee); // Clone to thunk. llvm::ValueToValueMapTy VMap; llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap, /*ModuleLevelChanges=*/false); CGM.getModule().getFunctionList().push_back(NewFn); Fn->replaceAllUsesWith(NewFn); NewFn->takeName(Fn); Fn->eraseFromParent(); Fn = NewFn; // "Initialize" CGF (minimally). CurFn = Fn; // Get the "this" value llvm::Function::arg_iterator AI = Fn->arg_begin(); if (CGM.ReturnTypeUsesSRet(FnInfo)) ++AI; // Find the first store of "this", which will be to the alloca associated // with "this". llvm::Value *ThisPtr = &*AI; llvm::BasicBlock *EntryBB = Fn->begin(); llvm::Instruction *ThisStore = 0; for (llvm::BasicBlock::iterator I = EntryBB->begin(), E = EntryBB->end(); I != E; I++) { if (isa<llvm::StoreInst>(I) && I->getOperand(0) == ThisPtr) { ThisStore = cast<llvm::StoreInst>(I); break; } } assert(ThisStore && "Store of this should be in entry block?"); // Adjust "this", if necessary. Builder.SetInsertPoint(ThisStore); llvm::Value *AdjustedThisPtr = CGM.getCXXABI().performThisAdjustment(*this, ThisPtr, Thunk.This); ThisStore->setOperand(0, AdjustedThisPtr); if (!Thunk.Return.isEmpty()) { // Fix up the returned value, if necessary. for (llvm::Function::iterator I = Fn->begin(), E = Fn->end(); I != E; I++) { llvm::Instruction *T = I->getTerminator(); if (isa<llvm::ReturnInst>(T)) { RValue RV = RValue::get(T->getOperand(0)); T->eraseFromParent(); Builder.SetInsertPoint(&*I); RV = PerformReturnAdjustment(*this, ResultType, RV, Thunk); Builder.CreateRet(RV.getScalarVal()); break; } } } }