CbC/CbC_llvm: lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp comparison

comparison lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp @ 120:1172e4bd9c6f

update 4.0.0

author	mir3636
date	Fri, 25 Nov 2016 19:14:25 +0900
parents	7d135dc70f03
children	803732b1fca8

comparison

equal deleted inserted replaced

-:34baf5011add
+:1172e4bd9c6f
 // Machine IR.
 //
 //===----------------------------------------------------------------------===//
 #include "llvm/CodeGen/FunctionLoweringInfo.h"
-#include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 MF = &mf;
 TLI = MF->getSubtarget().getTargetLowering();
 RegInfo = &MF->getRegInfo();
 MachineModuleInfo &MMI = MF->getMMI();
 const TargetFrameLowering *TFI = MF->getSubtarget().getFrameLowering();
+unsigned StackAlign = TFI->getStackAlignment();
 // Check whether the function can return without sret-demotion.
 SmallVector<ISD::OutputArg, 4> Outs;
 GetReturnInfo(Fn->getReturnType(), Fn->getAttributes(), Outs, *TLI,
 mf.getDataLayout());
 CanLowerReturn = TLI->CanLowerReturn(Fn->getCallingConv(), *MF,
 Fn->isVarArg(), Outs, Fn->getContext());
+// If this personality uses funclets, we need to do a bit more work.
+DenseMap<const AllocaInst *, TinyPtrVector<int *>> CatchObjects;
+EHPersonality Personality = classifyEHPersonality(
+Fn->hasPersonalityFn() ? Fn->getPersonalityFn() : nullptr);
+if (isFuncletEHPersonality(Personality)) {
+// Calculate state numbers if we haven't already.
+WinEHFuncInfo &EHInfo = *MF->getWinEHFuncInfo();
+if (Personality == EHPersonality::MSVC_CXX)
+calculateWinCXXEHStateNumbers(&fn, EHInfo);
+else if (isAsynchronousEHPersonality(Personality))
+calculateSEHStateNumbers(&fn, EHInfo);
+else if (Personality == EHPersonality::CoreCLR)
+calculateClrEHStateNumbers(&fn, EHInfo);
+// Map all BB references in the WinEH data to MBBs.
+for (WinEHTryBlockMapEntry &TBME : EHInfo.TryBlockMap) {
+for (WinEHHandlerType &H : TBME.HandlerArray) {
+if (const AllocaInst *AI = H.CatchObj.Alloca)
+CatchObjects.insert({AI, {}}).first->second.push_back(
+&H.CatchObj.FrameIndex);
+else
+H.CatchObj.FrameIndex = INT_MAX;
+}
+}
+}
 // Initialize the mapping of values to registers.  This is only set up for
 // instruction values that are used outside of the block that defines
 // them.
 Function::const_iterator BB = Fn->begin(), EB = Fn->end();
 if (const AllocaInst *AI = dyn_cast<AllocaInst>(I)) {
 Type *Ty = AI->getAllocatedType();
 unsigned Align =
 std::max((unsigned)MF->getDataLayout().getPrefTypeAlignment(Ty),
 AI->getAlignment());
-unsigned StackAlign = TFI->getStackAlignment();
 // Static allocas can be folded into the initial stack frame
 // adjustment. For targets that don't realign the stack, don't
 // do this if there is an extra alignment requirement.
 if (AI->isStaticAlloca() &&
 const ConstantInt *CUI = cast<ConstantInt>(AI->getArraySize());
 uint64_t TySize = MF->getDataLayout().getTypeAllocSize(Ty);
 TySize *= CUI->getZExtValue();   // Get total allocated size.
 if (TySize == 0) TySize = 1; // Don't create zero-sized stack objects.
+int FrameIndex = INT_MAX;
-StaticAllocaMap[AI] =
+auto Iter = CatchObjects.find(AI);
-MF->getFrameInfo()->CreateStackObject(TySize, Align, false, AI);
+if (Iter != CatchObjects.end() && TLI->needsFixedCatchObjects()) {
+FrameIndex = MF->getFrameInfo().CreateFixedObject(
+TySize, 0, /*Immutable=*/false, /*isAliased=*/true);
+MF->getFrameInfo().setObjectAlignment(FrameIndex, Align);
+} else {
+FrameIndex =
+MF->getFrameInfo().CreateStackObject(TySize, Align, false, AI);
+}
+StaticAllocaMap[AI] = FrameIndex;
+// Update the catch handler information.
+if (Iter != CatchObjects.end()) {
+for (int *CatchObjPtr : Iter->second)
+*CatchObjPtr = FrameIndex;
+}
 } else {
 // FIXME: Overaligned static allocas should be grouped into
 // a single dynamic allocation instead of using a separate
 // stack allocation for each one.
 if (Align <= StackAlign)
 Align = 0;
 // Inform the Frame Information that we have variable-sized objects.
-MF->getFrameInfo()->CreateVariableSizedObject(Align ? Align : 1, AI);
+MF->getFrameInfo().CreateVariableSizedObject(Align ? Align : 1, AI);
 }
 }
 // Look for inline asm that clobbers the SP register.
 if (isa<CallInst>(I) || isa<InvokeInst>(I)) {
 TLI->ComputeConstraintToUse(Op, SDValue(), DAG);
 std::pair<unsigned, const TargetRegisterClass *> PhysReg =
 TLI->getRegForInlineAsmConstraint(TRI, Op.ConstraintCode,
 Op.ConstraintVT);
 if (PhysReg.first == SP)
-MF->getFrameInfo()->setHasOpaqueSPAdjustment(true);
+MF->getFrameInfo().setHasOpaqueSPAdjustment(true);
 }
 }
 }
 }
 // Look for calls to the @llvm.va_start intrinsic. We can omit some
 // prologue boilerplate for variadic functions that don't examine their
 // arguments.
 if (const auto *II = dyn_cast<IntrinsicInst>(I)) {
 if (II->getIntrinsicID() == Intrinsic::vastart)
-MF->getFrameInfo()->setHasVAStart(true);
+MF->getFrameInfo().setHasVAStart(true);
 }
 // If we have a musttail call in a variadic function, we need to ensure we
 // forward implicit register parameters.
 if (const auto *CI = dyn_cast<CallInst>(I)) {
 if (CI->isMustTailCall() && Fn->isVarArg())
-MF->getFrameInfo()->setHasMustTailInVarArgFunc(true);
+MF->getFrameInfo().setHasMustTailInVarArgFunc(true);
 }
 // Mark values used outside their block as exported, by allocating
 // a virtual register for them.
 if (isUsedOutsideOfDefiningBlock(&*I))
 // funclets.
 // FIXME: SEH catchpads do not create funclets, so we could avoid setting
 // this in such cases in order to improve frame layout.
 if (!isa<LandingPadInst>(I)) {
 MMI.setHasEHFunclets(true);
-MF->getFrameInfo()->setHasOpaqueSPAdjustment(true);
+MF->getFrameInfo().setHasOpaqueSPAdjustment(true);
 }
 if (isa<CatchSwitchInst>(I)) {
 assert(&*BB->begin() == I &&
 "WinEHPrepare failed to remove PHIs from imaginary BBs");
 continue;
 MBBMap[&*BB]->setIsEHPad();
 if (const auto *LPI = dyn_cast<LandingPadInst>(FNP))
 LPads.push_back(LPI);
 }
-// If this personality uses funclets, we need to do a bit more work.
-if (!Fn->hasPersonalityFn())
-return;
-EHPersonality Personality = classifyEHPersonality(Fn->getPersonalityFn());
 if (!isFuncletEHPersonality(Personality))
 return;
-// Calculate state numbers if we haven't already.
 WinEHFuncInfo &EHInfo = *MF->getWinEHFuncInfo();
-if (Personality == EHPersonality::MSVC_CXX)
-calculateWinCXXEHStateNumbers(&fn, EHInfo);
-else if (isAsynchronousEHPersonality(Personality))
-calculateSEHStateNumbers(&fn, EHInfo);
-else if (Personality == EHPersonality::CoreCLR)
-calculateClrEHStateNumbers(&fn, EHInfo);
 // Map all BB references in the WinEH data to MBBs.
 for (WinEHTryBlockMapEntry &TBME : EHInfo.TryBlockMap) {
 for (WinEHHandlerType &H : TBME.HandlerArray) {
-if (H.CatchObj.Alloca) {
-assert(StaticAllocaMap.count(H.CatchObj.Alloca));
-H.CatchObj.FrameIndex = StaticAllocaMap[H.CatchObj.Alloca];
-} else {
-H.CatchObj.FrameIndex = INT_MAX;
-}
 if (H.Handler)
 H.Handler = MBBMap[H.Handler.get<const BasicBlock *>()];
 }
 }
 for (CxxUnwindMapEntry &UME : EHInfo.CxxUnwindMap)
 VisitedBBs.clear();
 ArgDbgValues.clear();
 ByValArgFrameIndexMap.clear();
 RegFixups.clear();
 StatepointStackSlots.clear();
-StatepointRelocatedValues.clear();
+StatepointSpillMaps.clear();
 PreferredExtendType.clear();
 }
 /// CreateReg - Allocate a single virtual register for the given type.
 unsigned FunctionLoweringInfo::CreateReg(MVT VT) {
 VReg = MRI.createVirtualRegister(RC);
 assert(VReg && "null vreg in exception pointer table!");
 return VReg;
 }
-/// ComputeUsesVAFloatArgument - Determine if any floating-point values are
+unsigned
-/// being passed to this variadic function, and set the MachineModuleInfo's
+FunctionLoweringInfo::getOrCreateSwiftErrorVReg(const MachineBasicBlock *MBB,
-/// usesVAFloatArgument flag if so. This flag is used to emit an undefined
+const Value *Val) {
-/// reference to _fltused on Windows, which will link in MSVCRT's
+auto Key = std::make_pair(MBB, Val);
-/// floating-point support.
+auto It = SwiftErrorVRegDefMap.find(Key);
-void llvm::ComputeUsesVAFloatArgument(const CallInst &I,
+// If this is the first use of this swifterror value in this basic block,
-MachineModuleInfo *MMI)
+// create a new virtual register.
-{
+// After we processed all basic blocks we will satisfy this "upwards exposed
-FunctionType *FT = cast<FunctionType>(
+// use" by inserting a copy or phi at the beginning of this block.
-I.getCalledValue()->getType()->getContainedType(0));
+if (It == SwiftErrorVRegDefMap.end()) {
-if (FT->isVarArg() && !MMI->usesVAFloatArgument()) {
+auto &DL = MF->getDataLayout();
-for (unsigned i = 0, e = I.getNumArgOperands(); i != e; ++i) {
+const TargetRegisterClass *RC = TLI->getRegClassFor(TLI->getPointerTy(DL));
-Type* T = I.getArgOperand(i)->getType();
+auto VReg = MF->getRegInfo().createVirtualRegister(RC);
-for (auto i : post_order(T)) {
+SwiftErrorVRegDefMap[Key] = VReg;
-if (i->isFloatingPointTy()) {
+SwiftErrorVRegUpwardsUse[Key] = VReg;
-MMI->setUsesVAFloatArgument(true);
+return VReg;
-return;
+} else return It->second;
 }
-}
-}
+void FunctionLoweringInfo::setCurrentSwiftErrorVReg(
-}
+const MachineBasicBlock *MBB, const Value *Val, unsigned VReg) {
-}
+SwiftErrorVRegDefMap[std::make_pair(MBB, Val)] = VReg;
+}
-/// AddLandingPadInfo - Extract the exception handling information from the
-/// landingpad instruction and add them to the specified machine module info.
-void llvm::AddLandingPadInfo(const LandingPadInst &I, MachineModuleInfo &MMI,
-MachineBasicBlock *MBB) {
-if (const auto *PF = dyn_cast<Function>(
-I.getParent()->getParent()->getPersonalityFn()->stripPointerCasts()))
-MMI.addPersonality(PF);
-if (I.isCleanup())
-MMI.addCleanup(MBB);
-// FIXME: New EH - Add the clauses in reverse order. This isn't 100% correct,
-//        but we need to do it this way because of how the DWARF EH emitter
-//        processes the clauses.
-for (unsigned i = I.getNumClauses(); i != 0; --i) {
-Value *Val = I.getClause(i - 1);
-if (I.isCatch(i - 1)) {
-MMI.addCatchTypeInfo(MBB,
-dyn_cast<GlobalValue>(Val->stripPointerCasts()));
-} else {
-// Add filters in a list.
-Constant *CVal = cast<Constant>(Val);
-SmallVector<const GlobalValue*, 4> FilterList;
-for (User::op_iterator
-II = CVal->op_begin(), IE = CVal->op_end(); II != IE; ++II)
-FilterList.push_back(cast<GlobalValue>((*II)->stripPointerCasts()));
-MMI.addFilterTypeInfo(MBB, FilterList);
-}
-}
-}

Mercurial > hg > CbC > CbC_llvm

comparison lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp @ 120:1172e4bd9c6f