From a54cf176613f9ae8301519a61b8935652c0fb8ae Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Fri, 11 Jul 2008 22:44:52 +0000 Subject: [PATCH] Include a frame index in the "fixed stack" pseudo source value instead of using the frame index for the SVOffset, which was inconsistent. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@53486 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/PseudoSourceValue.h | 4 +-- lib/CodeGen/PseudoSourceValue.cpp | 37 ++++++++++++++++++----- lib/CodeGen/SelectionDAG/LegalizeDAG.cpp | 29 ++++++++---------- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 4 +-- lib/Target/PowerPC/PPCISelLowering.cpp | 12 ++++---- lib/Target/X86/X86ISelLowering.cpp | 19 +++++------- 6 files changed, 60 insertions(+), 45 deletions(-) diff --git a/include/llvm/CodeGen/PseudoSourceValue.h b/include/llvm/CodeGen/PseudoSourceValue.h index 6d7fb1fa81b..95ae1d43ab3 100644 --- a/include/llvm/CodeGen/PseudoSourceValue.h +++ b/include/llvm/CodeGen/PseudoSourceValue.h @@ -35,9 +35,9 @@ namespace llvm { return V->getValueID() == PseudoSourceValueVal; } - /// A pseudo source value referencing to the stack frame of a function, + /// A pseudo source value referencing a fixed stack frame entry, /// e.g., a spill slot. - static const PseudoSourceValue *getFixedStack(); + static const PseudoSourceValue *getFixedStack(int FI); /// A source value referencing the area below the stack frame of a function, /// e.g., the argument space. diff --git a/lib/CodeGen/PseudoSourceValue.cpp b/lib/CodeGen/PseudoSourceValue.cpp index c62e49a4b08..ea704e6e9c4 100644 --- a/lib/CodeGen/PseudoSourceValue.cpp +++ b/lib/CodeGen/PseudoSourceValue.cpp @@ -13,28 +13,27 @@ #include "llvm/CodeGen/PseudoSourceValue.h" #include "llvm/DerivedTypes.h" +#include "llvm/Support/Compiler.h" #include "llvm/Support/ManagedStatic.h" +#include namespace llvm { - static ManagedStatic PSVs; + static ManagedStatic PSVs; - const PseudoSourceValue *PseudoSourceValue::getFixedStack() - { return &(*PSVs)[0]; } const PseudoSourceValue *PseudoSourceValue::getStack() - { return &(*PSVs)[1]; } + { return &(*PSVs)[0]; } const PseudoSourceValue *PseudoSourceValue::getGOT() + { return &(*PSVs)[1]; } + const PseudoSourceValue *PseudoSourceValue::getJumpTable() { return &(*PSVs)[2]; } const PseudoSourceValue *PseudoSourceValue::getConstantPool() { return &(*PSVs)[3]; } - const PseudoSourceValue *PseudoSourceValue::getJumpTable() - { return &(*PSVs)[4]; } static const char *const PSVNames[] = { - "FixedStack", "Stack", "GOT", - "ConstantPool", "JumpTable" + "ConstantPool" }; PseudoSourceValue::PseudoSourceValue() : @@ -43,4 +42,26 @@ namespace llvm { void PseudoSourceValue::print(std::ostream &OS) const { OS << PSVNames[this - *PSVs]; } + + /// FixedStackPseudoSourceValue - A specialized PseudoSourceValue + /// for holding FixedStack values, which must include a frame + /// index. + class VISIBILITY_HIDDEN FixedStackPseudoSourceValue + : public PseudoSourceValue { + const int FI; + public: + explicit FixedStackPseudoSourceValue(int fi) : FI(fi) {} + virtual void print(std::ostream &OS) const { + OS << "FixedStack" << FI; + } + }; + + static ManagedStatic > FSValues; + + const PseudoSourceValue *PseudoSourceValue::getFixedStack(int FI) { + const PseudoSourceValue *&V = (*FSValues)[FI]; + if (!V) + V = new FixedStackPseudoSourceValue(FI); + return V; + } } diff --git a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp index 4b4c02bd8d8..632653b624d 100644 --- a/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp +++ b/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp @@ -780,13 +780,11 @@ PerformInsertVectorEltInMemory(SDOperand Vec, SDOperand Val, SDOperand Idx) { MVT PtrVT = TLI.getPointerTy(); SDOperand StackPtr = DAG.CreateStackTemporary(VT); - FrameIndexSDNode *StackPtrFI = cast(StackPtr.Val); - int SPFI = StackPtrFI->getIndex(); + int SPFI = cast(StackPtr.Val)->getIndex(); // Store the vector. SDOperand Ch = DAG.getStore(DAG.getEntryNode(), Tmp1, StackPtr, - PseudoSourceValue::getFixedStack(), - SPFI); + PseudoSourceValue::getFixedStack(SPFI), 0); // Truncate or zero extend offset to target pointer type. unsigned CastOpc = IdxVT.bitsGT(PtrVT) ? ISD::TRUNCATE : ISD::ZERO_EXTEND; @@ -797,9 +795,10 @@ PerformInsertVectorEltInMemory(SDOperand Vec, SDOperand Val, SDOperand Idx) { SDOperand StackPtr2 = DAG.getNode(ISD::ADD, IdxVT, Tmp3, StackPtr); // Store the scalar value. Ch = DAG.getTruncStore(Ch, Tmp2, StackPtr2, - PseudoSourceValue::getFixedStack(), SPFI, EltVT); + PseudoSourceValue::getFixedStack(SPFI), 0, EltVT); // Load the updated vector. - return DAG.getLoad(VT, Ch, StackPtr, PseudoSourceValue::getFixedStack(),SPFI); + return DAG.getLoad(VT, Ch, StackPtr, + PseudoSourceValue::getFixedStack(SPFI), 0); } /// LegalizeOp - We know that the specified value has a legal type, and @@ -4906,12 +4905,12 @@ SDOperand SelectionDAGLegalize::EmitStackConvert(SDOperand SrcOp, if (SrcSize > SlotSize) Store = DAG.getTruncStore(DAG.getEntryNode(), SrcOp, FIPtr, - PseudoSourceValue::getFixedStack(), SPFI, SlotVT, - false, SrcAlign); + PseudoSourceValue::getFixedStack(SPFI), 0, + SlotVT, false, SrcAlign); else { assert(SrcSize == SlotSize && "Invalid store"); Store = DAG.getStore(DAG.getEntryNode(), SrcOp, FIPtr, - PseudoSourceValue::getFixedStack(), SPFI, + PseudoSourceValue::getFixedStack(SPFI), 0, false, SrcAlign); } @@ -4933,9 +4932,9 @@ SDOperand SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) { int SPFI = StackPtrFI->getIndex(); SDOperand Ch = DAG.getStore(DAG.getEntryNode(), Node->getOperand(0), StackPtr, - PseudoSourceValue::getFixedStack(), SPFI); + PseudoSourceValue::getFixedStack(SPFI), 0); return DAG.getLoad(Node->getValueType(0), Ch, StackPtr, - PseudoSourceValue::getFixedStack(), SPFI); + PseudoSourceValue::getFixedStack(SPFI), 0); } @@ -7017,15 +7016,13 @@ void SelectionDAGLegalize::SplitVectorOp(SDOperand Op, SDOperand &Lo, // Lower to a store/load so that it can be split. // FIXME: this could be improved probably. SDOperand Ptr = DAG.CreateStackTemporary(InOp.getValueType()); - FrameIndexSDNode *FI = cast(Ptr.Val); + int FI = cast(Ptr.Val)->getIndex(); SDOperand St = DAG.getStore(DAG.getEntryNode(), InOp, Ptr, - PseudoSourceValue::getFixedStack(), - FI->getIndex()); + PseudoSourceValue::getFixedStack(FI), 0); InOp = DAG.getLoad(Op.getValueType(), St, Ptr, - PseudoSourceValue::getFixedStack(), - FI->getIndex()); + PseudoSourceValue::getFixedStack(FI), 0); } // Split the vector and convert each of the pieces now. SplitVectorOp(InOp, Lo, Hi); diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index db315380865..cc1acf47db7 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -4361,8 +4361,8 @@ MachineMemOperand MemSDNode::getMemOperand() const { const FrameIndexSDNode *FI = dyn_cast(getBasePtr().Val); if (!getSrcValue() && FI) - return MachineMemOperand(PseudoSourceValue::getFixedStack(), Flags, - FI->getIndex(), Size, getAlignment()); + return MachineMemOperand(PseudoSourceValue::getFixedStack(FI->getIndex()), + Flags, 0, Size, getAlignment()); else return MachineMemOperand(getSrcValue(), Flags, getSrcValueOffset(), Size, getAlignment()); diff --git a/lib/Target/PowerPC/PPCISelLowering.cpp b/lib/Target/PowerPC/PPCISelLowering.cpp index fc626eebbd4..dc38c7c9440 100644 --- a/lib/Target/PowerPC/PPCISelLowering.cpp +++ b/lib/Target/PowerPC/PPCISelLowering.cpp @@ -1943,8 +1943,8 @@ StoreTailCallArgumentsToStackSlot(SelectionDAG &DAG, int FI = TailCallArgs[i].FrameIdx; // Store relative to framepointer. MemOpChains.push_back(DAG.getStore(Chain, Arg, FIN, - PseudoSourceValue::getFixedStack(), - FI)); + PseudoSourceValue::getFixedStack(FI), + 0)); } } @@ -1972,10 +1972,10 @@ static SDOperand EmitTailCallStoreFPAndRetAddr(SelectionDAG &DAG, MVT VT = isPPC64 ? MVT::i64 : MVT::i32; SDOperand NewRetAddrFrIdx = DAG.getFrameIndex(NewRetAddr, VT); Chain = DAG.getStore(Chain, OldRetAddr, NewRetAddrFrIdx, - PseudoSourceValue::getFixedStack(), NewRetAddr); + PseudoSourceValue::getFixedStack(NewRetAddr), 0); SDOperand NewFramePtrIdx = DAG.getFrameIndex(NewFPIdx, VT); Chain = DAG.getStore(Chain, OldFP, NewFramePtrIdx, - PseudoSourceValue::getFixedStack(), NewFPIdx); + PseudoSourceValue::getFixedStack(NewFPIdx), 0); } return Chain; } @@ -3029,8 +3029,8 @@ SDOperand PPCTargetLowering::LowerSINT_TO_FP(SDOperand Op, SelectionDAG &DAG) { Op.getOperand(0)); // STD the extended value into the stack slot. - MachineMemOperand MO(PseudoSourceValue::getFixedStack(), - MachineMemOperand::MOStore, FrameIdx, 8, 8); + MachineMemOperand MO(PseudoSourceValue::getFixedStack(FrameIdx), + MachineMemOperand::MOStore, 0, 8, 8); SDOperand Store = DAG.getNode(PPCISD::STD_32, MVT::Other, DAG.getEntryNode(), Ext64, FIdx, DAG.getMemOperand(MO)); diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp index 5dd0116726e..213b9446beb 100644 --- a/lib/Target/X86/X86ISelLowering.cpp +++ b/lib/Target/X86/X86ISelLowering.cpp @@ -1134,7 +1134,7 @@ SDOperand X86TargetLowering::LowerMemArgument(SDOperand Op, SelectionDAG &DAG, if (Flags.isByVal()) return FIN; return DAG.getLoad(VA.getValVT(), Root, FIN, - PseudoSourceValue::getFixedStack(), FI); + PseudoSourceValue::getFixedStack(FI), 0); } SDOperand @@ -1320,8 +1320,7 @@ X86TargetLowering::LowerFORMAL_ARGUMENTS(SDOperand Op, SelectionDAG &DAG) { SDOperand Val = DAG.getCopyFromReg(Root, VReg, MVT::i64); SDOperand Store = DAG.getStore(Val.getValue(1), Val, FIN, - PseudoSourceValue::getFixedStack(), - RegSaveFrameIndex); + PseudoSourceValue::getFixedStack(RegSaveFrameIndex), 0); MemOps.push_back(Store); FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN, DAG.getIntPtrConstant(8)); @@ -1336,8 +1335,7 @@ X86TargetLowering::LowerFORMAL_ARGUMENTS(SDOperand Op, SelectionDAG &DAG) { SDOperand Val = DAG.getCopyFromReg(Root, VReg, MVT::v4f32); SDOperand Store = DAG.getStore(Val.getValue(1), Val, FIN, - PseudoSourceValue::getFixedStack(), - RegSaveFrameIndex); + PseudoSourceValue::getFixedStack(RegSaveFrameIndex), 0); MemOps.push_back(Store); FIN = DAG.getNode(ISD::ADD, getPointerTy(), FIN, DAG.getIntPtrConstant(16)); @@ -1435,7 +1433,7 @@ EmitTailCallStoreRetAddr(SelectionDAG & DAG, MachineFunction &MF, MVT VT = Is64Bit ? MVT::i64 : MVT::i32; SDOperand NewRetAddrFrIdx = DAG.getFrameIndex(NewReturnAddrFI, VT); Chain = DAG.getStore(Chain, RetAddrFrIdx, NewRetAddrFrIdx, - PseudoSourceValue::getFixedStack(), NewReturnAddrFI); + PseudoSourceValue::getFixedStack(NewReturnAddrFI), 0); return Chain; } @@ -1652,7 +1650,7 @@ SDOperand X86TargetLowering::LowerCALL(SDOperand Op, SelectionDAG &DAG) { // Store relative to framepointer. MemOpChains2.push_back( DAG.getStore(Chain, Arg, FIN, - PseudoSourceValue::getFixedStack(), FI)); + PseudoSourceValue::getFixedStack(FI), 0)); } } } @@ -4403,8 +4401,7 @@ SDOperand X86TargetLowering::LowerSINT_TO_FP(SDOperand Op, SelectionDAG &DAG) { SDOperand StackSlot = DAG.getFrameIndex(SSFI, getPointerTy()); SDOperand Chain = DAG.getStore(DAG.getEntryNode(), Op.getOperand(0), StackSlot, - PseudoSourceValue::getFixedStack(), - SSFI); + PseudoSourceValue::getFixedStack(SSFI), 0); // Build the FILD SDVTList Tys; @@ -4439,7 +4436,7 @@ SDOperand X86TargetLowering::LowerSINT_TO_FP(SDOperand Op, SelectionDAG &DAG) { Ops.push_back(InFlag); Chain = DAG.getNode(X86ISD::FST, Tys, &Ops[0], Ops.size()); Result = DAG.getLoad(Op.getValueType(), Chain, StackSlot, - PseudoSourceValue::getFixedStack(), SSFI); + PseudoSourceValue::getFixedStack(SSFI), 0); } return Result; @@ -4479,7 +4476,7 @@ FP_TO_SINTHelper(SDOperand Op, SelectionDAG &DAG) { if (isScalarFPTypeInSSEReg(Op.getOperand(0).getValueType())) { assert(Op.getValueType() == MVT::i64 && "Invalid FP_TO_SINT to lower!"); Chain = DAG.getStore(Chain, Value, StackSlot, - PseudoSourceValue::getFixedStack(), SSFI); + PseudoSourceValue::getFixedStack(SSFI), 0); SDVTList Tys = DAG.getVTList(Op.getOperand(0).getValueType(), MVT::Other); SDOperand Ops[] = { Chain, StackSlot, DAG.getValueType(Op.getOperand(0).getValueType()) -- 2.34.1