static void replaceFrameIndexes(MachineFunction &MF, SmallVector<std::pair<int,int64_t>, 16> &FR) { MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); const SmallVector<std::pair<int,int64_t>, 16>::iterator FRB = FR.begin(); const SmallVector<std::pair<int,int64_t>, 16>::iterator FRE = FR.end(); SmallVector<std::pair<int,int64_t>, 16>::iterator FRI = FRB; for (; FRI != FRE; ++FRI) { MFI->RemoveStackObject(FRI->first); int NFI = MFI->CreateFixedObject(4, FRI->second, true); MBlazeFI->recordReplacement(FRI->first, NFI); for (MachineFunction::iterator MB=MF.begin(), ME=MF.end(); MB!=ME; ++MB) { MachineBasicBlock::iterator MBB = MB->begin(); const MachineBasicBlock::iterator MBE = MB->end(); for (; MBB != MBE; ++MBB) { MachineInstr::mop_iterator MIB = MBB->operands_begin(); const MachineInstr::mop_iterator MIE = MBB->operands_end(); for (MachineInstr::mop_iterator MII = MIB; MII != MIE; ++MII) { if (!MII->isFI() || MII->getIndex() != FRI->first) continue; DEBUG(dbgs() << "FOUND FI#" << MII->getIndex() << "\n"); MII->setIndex(NFI); } } } } }
static void determineFrameLayout(MachineFunction &MF) { MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); // Replace the dummy '0' SPOffset by the negative offsets, as explained on // LowerFORMAL_ARGUMENTS. Leaving '0' for while is necessary to avoid // the approach done by calculateFrameObjectOffsets to the stack frame. MBlazeFI->adjustLoadArgsFI(MFI); MBlazeFI->adjustStoreVarArgsFI(MFI); // Get the number of bytes to allocate from the FrameInfo unsigned FrameSize = MFI->getStackSize(); DEBUG(dbgs() << "Original Frame Size: " << FrameSize << "\n" ); // Get the alignments provided by the target, and the maximum alignment // (if any) of the fixed frame objects. // unsigned MaxAlign = MFI->getMaxAlignment(); unsigned TargetAlign = MF.getTarget().getFrameLowering()->getStackAlignment(); unsigned AlignMask = TargetAlign - 1; // Make sure the frame is aligned. FrameSize = (FrameSize + AlignMask) & ~AlignMask; MFI->setStackSize(FrameSize); DEBUG(dbgs() << "Aligned Frame Size: " << FrameSize << "\n" ); }
void MBlazeRegisterInfo:: processFunctionBeforeFrameFinalized(MachineFunction &MF) const { // Set the stack offset where GP must be saved/loaded from. MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); if (MBlazeFI->needGPSaveRestore()) MFI->setObjectOffset(MBlazeFI->getGPFI(), MBlazeFI->getGPStackOffset()); }
void MBlazeFrameInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, RegScavenger *RS) const { MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); if (MFI->adjustsStack()) { MBlazeFI->setRAStackOffset(0); MFI->CreateFixedObject(4,0,true); } if (hasFP(MF)) { MBlazeFI->setFPStackOffset(4); MFI->CreateFixedObject(4,4,true); } }
SDValue MBlazeTargetLowering::LowerVASTART(SDValue Op, SelectionDAG &DAG) const { MachineFunction &MF = DAG.getMachineFunction(); MBlazeFunctionInfo *FuncInfo = MF.getInfo<MBlazeFunctionInfo>(); DebugLoc dl = Op.getDebugLoc(); SDValue FI = DAG.getFrameIndex(FuncInfo->getVarArgsFrameIndex(), getPointerTy()); // vastart just stores the address of the VarArgsFrameIndex slot into the // memory location argument. const Value *SV = cast<SrcValueSDNode>(Op.getOperand(2))->getValue(); return DAG.getStore(Op.getOperand(0), dl, FI, Op.getOperand(1), MachinePointerInfo(SV), false, false, 0); }
void MBlazeFrameLowering::emitPrologue(MachineFunction &MF) const { MachineBasicBlock &MBB = MF.front(); MachineFrameInfo *MFI = MF.getFrameInfo(); const MBlazeInstrInfo &TII = *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); MachineBasicBlock::iterator MBBI = MBB.begin(); DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc(); llvm::CallingConv::ID CallConv = MF.getFunction()->getCallingConv(); bool requiresRA = CallConv == llvm::CallingConv::MBLAZE_INTR; // Determine the correct frame layout determineFrameLayout(MF); // Get the number of bytes to allocate from the FrameInfo. unsigned StackSize = MFI->getStackSize(); // No need to allocate space on the stack. if (StackSize == 0 && !MFI->adjustsStack() && !requiresRA) return; int FPOffset = MBlazeFI->getFPStackOffset(); int RAOffset = MBlazeFI->getRAStackOffset(); // Adjust stack : addi R1, R1, -imm BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADDIK), MBlaze::R1) .addReg(MBlaze::R1).addImm(-StackSize); // swi R15, R1, stack_loc if (MFI->adjustsStack() || requiresRA) { BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI)) .addReg(MBlaze::R15).addReg(MBlaze::R1).addImm(RAOffset); } if (hasFP(MF)) { // swi R19, R1, stack_loc BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI)) .addReg(MBlaze::R19).addReg(MBlaze::R1).addImm(FPOffset); // add R19, R1, R0 BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADD), MBlaze::R19) .addReg(MBlaze::R1).addReg(MBlaze::R0); } }
void MBlazeFrameInfo::emitPrologue(MachineFunction &MF) const { MachineBasicBlock &MBB = MF.front(); MachineFrameInfo *MFI = MF.getFrameInfo(); const MBlazeInstrInfo &TII = *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); MachineBasicBlock::iterator MBBI = MBB.begin(); DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc(); // Replace the dummy '0' SPOffset by the negative offsets, as explained on // LowerFORMAL_ARGUMENTS. Leaving '0' for while is necessary to avoid // the approach done by calculateFrameObjectOffsets to the stack frame. MBlazeFI->adjustLoadArgsFI(MFI); MBlazeFI->adjustStoreVarArgsFI(MFI); // Get the number of bytes to allocate from the FrameInfo. unsigned StackSize = MFI->getStackSize(); // No need to allocate space on the stack. if (StackSize == 0 && !MFI->adjustsStack()) return; int FPOffset = MBlazeFI->getFPStackOffset(); int RAOffset = MBlazeFI->getRAStackOffset(); // Adjust stack : addi R1, R1, -imm BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADDI), MBlaze::R1) .addReg(MBlaze::R1).addImm(-StackSize); // swi R15, R1, stack_loc if (MFI->adjustsStack()) { BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI)) .addReg(MBlaze::R15).addReg(MBlaze::R1).addImm(RAOffset); } if (hasFP(MF)) { // swi R19, R1, stack_loc BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI)) .addReg(MBlaze::R19).addReg(MBlaze::R1).addImm(FPOffset); // add R19, R1, R0 BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADD), MBlaze::R19) .addReg(MBlaze::R1).addReg(MBlaze::R0); } }
void MBlazeFrameLowering::emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const { MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr(); MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); const MBlazeInstrInfo &TII = *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); DebugLoc dl = MBBI->getDebugLoc(); llvm::CallingConv::ID CallConv = MF.getFunction()->getCallingConv(); bool requiresRA = CallConv == llvm::CallingConv::MBLAZE_INTR; // Get the FI's where RA and FP are saved. int FPOffset = MBlazeFI->getFPStackOffset(); int RAOffset = MBlazeFI->getRAStackOffset(); if (hasFP(MF)) { // add R1, R19, R0 BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADD), MBlaze::R1) .addReg(MBlaze::R19).addReg(MBlaze::R0); // lwi R19, R1, stack_loc BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R19) .addReg(MBlaze::R1).addImm(FPOffset); } // lwi R15, R1, stack_loc if (MFI->adjustsStack() || requiresRA) { BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R15) .addReg(MBlaze::R1).addImm(RAOffset); } // Get the number of bytes from FrameInfo int StackSize = (int) MFI->getStackSize(); // addi R1, R1, imm if (StackSize) { BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADDIK), MBlaze::R1) .addReg(MBlaze::R1).addImm(StackSize); } }
/// getGlobalBaseReg - Return a virtual register initialized with the /// the global base register value. Output instructions required to /// initialize the register in the function entry block, if necessary. /// unsigned MBlazeInstrInfo::getGlobalBaseReg(MachineFunction *MF) const { MBlazeFunctionInfo *MBlazeFI = MF->getInfo<MBlazeFunctionInfo>(); unsigned GlobalBaseReg = MBlazeFI->getGlobalBaseReg(); if (GlobalBaseReg != 0) return GlobalBaseReg; // Insert the set of GlobalBaseReg into the first MBB of the function MachineBasicBlock &FirstMBB = MF->front(); MachineBasicBlock::iterator MBBI = FirstMBB.begin(); MachineRegisterInfo &RegInfo = MF->getRegInfo(); const TargetInstrInfo *TII = MF->getTarget().getInstrInfo(); GlobalBaseReg = RegInfo.createVirtualRegister(MBlaze::GPRRegisterClass); BuildMI(FirstMBB, MBBI, DebugLoc(), TII->get(TargetOpcode::COPY), GlobalBaseReg).addReg(MBlaze::R20); RegInfo.addLiveIn(MBlaze::R20); MBlazeFI->setGlobalBaseReg(GlobalBaseReg); return GlobalBaseReg; }
void MBlazeFrameLowering:: processFunctionBeforeCalleeSavedScan(MachineFunction &MF, RegScavenger *RS) const { MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); llvm::CallingConv::ID CallConv = MF.getFunction()->getCallingConv(); bool requiresRA = CallConv == llvm::CallingConv::MBLAZE_INTR; if (MFI->adjustsStack() || requiresRA) { MBlazeFI->setRAStackOffset(0); MFI->CreateFixedObject(4,0,true); } if (hasFP(MF)) { MBlazeFI->setFPStackOffset(4); MFI->CreateFixedObject(4,4,true); } interruptFrameLayout(MF); analyzeFrameIndexes(MF); }
void MBlazeFrameInfo::emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const { MachineBasicBlock::iterator MBBI = prior(MBB.end()); MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); const MBlazeInstrInfo &TII = *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); DebugLoc dl = MBBI->getDebugLoc(); // Get the FI's where RA and FP are saved. int FPOffset = MBlazeFI->getFPStackOffset(); int RAOffset = MBlazeFI->getRAStackOffset(); if (hasFP(MF)) { // add R1, R19, R0 BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADD), MBlaze::R1) .addReg(MBlaze::R19).addReg(MBlaze::R0); // lwi R19, R1, stack_loc BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R19) .addReg(MBlaze::R1).addImm(FPOffset); } // lwi R15, R1, stack_loc if (MFI->adjustsStack()) { BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R15) .addReg(MBlaze::R1).addImm(RAOffset); } // Get the number of bytes from FrameInfo int StackSize = (int) MFI->getStackSize(); // addi R1, R1, imm if (StackSize) { BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADDI), MBlaze::R1) .addReg(MBlaze::R1).addImm(StackSize); } }
/// getGlobalBaseReg - Return a virtual register initialized with the /// the global base register value. Output instructions required to /// initialize the register in the function entry block, if necessary. /// unsigned MBlazeInstrInfo::getGlobalBaseReg(MachineFunction *MF) const { MBlazeFunctionInfo *MBlazeFI = MF->getInfo<MBlazeFunctionInfo>(); unsigned GlobalBaseReg = MBlazeFI->getGlobalBaseReg(); if (GlobalBaseReg != 0) return GlobalBaseReg; // Insert the set of GlobalBaseReg into the first MBB of the function MachineBasicBlock &FirstMBB = MF->front(); MachineBasicBlock::iterator MBBI = FirstMBB.begin(); MachineRegisterInfo &RegInfo = MF->getRegInfo(); const TargetInstrInfo *TII = MF->getTarget().getInstrInfo(); GlobalBaseReg = RegInfo.createVirtualRegister(MBlaze::CPURegsRegisterClass); bool Ok = TII->copyRegToReg(FirstMBB, MBBI, GlobalBaseReg, MBlaze::R20, MBlaze::CPURegsRegisterClass, MBlaze::CPURegsRegisterClass, DebugLoc()); assert(Ok && "Couldn't assign to global base register!"); Ok = Ok; // Silence warning when assertions are turned off. RegInfo.addLiveIn(MBlaze::R20); MBlazeFI->setGlobalBaseReg(GlobalBaseReg); return GlobalBaseReg; }
static void analyzeFrameIndexes(MachineFunction &MF) { if (MBDisableStackAdjust) return; MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); const MachineRegisterInfo &MRI = MF.getRegInfo(); MachineRegisterInfo::livein_iterator LII = MRI.livein_begin(); MachineRegisterInfo::livein_iterator LIE = MRI.livein_end(); const SmallVector<int, 16> &LiveInFI = MBlazeFI->getLiveIn(); SmallVector<MachineInstr*, 16> EraseInstr; SmallVector<std::pair<int,int64_t>, 16> FrameRelocate; MachineBasicBlock *MBB = MF.getBlockNumbered(0); MachineBasicBlock::iterator MIB = MBB->begin(); MachineBasicBlock::iterator MIE = MBB->end(); int StackAdjust = 0; int StackOffset = -28; // In this loop we are searching frame indexes that corrospond to incoming // arguments that are already in the stack. We look for instruction sequences // like the following: // // LWI REG, FI1, 0 // ... // SWI REG, FI2, 0 // // As long as there are no defs of REG in the ... part, we can eliminate // the SWI instruction because the value has already been stored to the // stack by the caller. All we need to do is locate FI at the correct // stack location according to the calling convensions. // // Additionally, if the SWI operation kills the def of REG then we don't // need the LWI operation so we can erase it as well. for (unsigned i = 0, e = LiveInFI.size(); i < e; ++i) { for (MachineBasicBlock::iterator I=MIB; I != MIE; ++I) { if (I->getOpcode() != MBlaze::LWI || I->getNumOperands() != 3 || !I->getOperand(1).isFI() || !I->getOperand(0).isReg() || I->getOperand(1).getIndex() != LiveInFI[i]) continue; unsigned FIReg = I->getOperand(0).getReg(); MachineBasicBlock::iterator SI = I; for (SI++; SI != MIE; ++SI) { if (!SI->getOperand(0).isReg() || !SI->getOperand(1).isFI() || SI->getOpcode() != MBlaze::SWI) continue; int FI = SI->getOperand(1).getIndex(); if (SI->getOperand(0).getReg() != FIReg || MFI->isFixedObjectIndex(FI) || MFI->getObjectSize(FI) != 4) continue; if (SI->getOperand(0).isDef()) break; if (SI->getOperand(0).isKill()) { DEBUG(dbgs() << "LWI for FI#" << I->getOperand(1).getIndex() << " removed\n"); EraseInstr.push_back(I); } EraseInstr.push_back(SI); DEBUG(dbgs() << "SWI for FI#" << FI << " removed\n"); FrameRelocate.push_back(std::make_pair(FI,StackOffset)); DEBUG(dbgs() << "FI#" << FI << " relocated to " << StackOffset << "\n"); StackOffset -= 4; StackAdjust += 4; break; } } } // In this loop we are searching for frame indexes that corrospond to // incoming arguments that are in registers. We look for instruction // sequences like the following: // // ... SWI REG, FI, 0 // // As long as the ... part does not define REG and if REG is an incoming // parameter register then we know that, according to ABI convensions, the // caller has allocated stack space for it already. Instead of allocating // stack space on our frame, we record the correct location in the callers // frame. for (MachineRegisterInfo::livein_iterator LI = LII; LI != LIE; ++LI) { for (MachineBasicBlock::iterator I=MIB; I != MIE; ++I) { if (I->definesRegister(LI->first)) break; if (I->getOpcode() != MBlaze::SWI || I->getNumOperands() != 3 || !I->getOperand(1).isFI() || !I->getOperand(0).isReg() || I->getOperand(1).getIndex() < 0) continue; if (I->getOperand(0).getReg() == LI->first) { int FI = I->getOperand(1).getIndex(); MBlazeFI->recordLiveIn(FI); int FILoc = 0; switch (LI->first) { default: llvm_unreachable("invalid incoming parameter!"); case MBlaze::R5: FILoc = -4; break; case MBlaze::R6: FILoc = -8; break; case MBlaze::R7: FILoc = -12; break; case MBlaze::R8: FILoc = -16; break; case MBlaze::R9: FILoc = -20; break; case MBlaze::R10: FILoc = -24; break; } StackAdjust += 4; FrameRelocate.push_back(std::make_pair(FI,FILoc)); DEBUG(dbgs() << "FI#" << FI << " relocated to " << FILoc << "\n"); break; } } } // Go ahead and erase all of the instructions that we determined were // no longer needed. for (int i = 0, e = EraseInstr.size(); i < e; ++i) MBB->erase(EraseInstr[i]); // Replace all of the frame indexes that we have relocated with new // fixed object frame indexes. replaceFrameIndexes(MF, FrameRelocate); }
/// LowerFormalArguments - transform physical registers into /// virtual registers and generate load operations for /// arguments places on the stack. SDValue MBlazeTargetLowering:: LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv, bool isVarArg, const SmallVectorImpl<ISD::InputArg> &Ins, DebugLoc dl, SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const { MachineFunction &MF = DAG.getMachineFunction(); MachineFrameInfo *MFI = MF.getFrameInfo(); MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); unsigned StackReg = MF.getTarget().getRegisterInfo()->getFrameRegister(MF); MBlazeFI->setVarArgsFrameIndex(0); // Used with vargs to acumulate store chains. std::vector<SDValue> OutChains; // Keep track of the last register used for arguments unsigned ArgRegEnd = 0; // Assign locations to all of the incoming arguments. SmallVector<CCValAssign, 16> ArgLocs; CCState CCInfo(CallConv, isVarArg, getTargetMachine(), ArgLocs, *DAG.getContext()); CCInfo.AnalyzeFormalArguments(Ins, CC_MBlaze); SDValue StackPtr; for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) { CCValAssign &VA = ArgLocs[i]; // Arguments stored on registers if (VA.isRegLoc()) { MVT RegVT = VA.getLocVT(); ArgRegEnd = VA.getLocReg(); TargetRegisterClass *RC = 0; if (RegVT == MVT::i32) RC = MBlaze::GPRRegisterClass; else if (RegVT == MVT::f32) RC = MBlaze::GPRRegisterClass; else llvm_unreachable("RegVT not supported by LowerFormalArguments"); // Transform the arguments stored on // physical registers into virtual ones unsigned Reg = MF.addLiveIn(ArgRegEnd, RC); SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, Reg, RegVT); // If this is an 8 or 16-bit value, it has been passed promoted // to 32 bits. Insert an assert[sz]ext to capture this, then // truncate to the right size. If if is a floating point value // then convert to the correct type. if (VA.getLocInfo() != CCValAssign::Full) { unsigned Opcode = 0; if (VA.getLocInfo() == CCValAssign::SExt) Opcode = ISD::AssertSext; else if (VA.getLocInfo() == CCValAssign::ZExt) Opcode = ISD::AssertZext; if (Opcode) ArgValue = DAG.getNode(Opcode, dl, RegVT, ArgValue, DAG.getValueType(VA.getValVT())); ArgValue = DAG.getNode(ISD::TRUNCATE, dl, VA.getValVT(), ArgValue); } InVals.push_back(ArgValue); } else { // VA.isRegLoc() // sanity check assert(VA.isMemLoc()); // The last argument is not a register ArgRegEnd = 0; // The stack pointer offset is relative to the caller stack frame. // Since the real stack size is unknown here, a negative SPOffset // is used so there's a way to adjust these offsets when the stack // size get known (on EliminateFrameIndex). A dummy SPOffset is // used instead of a direct negative address (which is recorded to // be used on emitPrologue) to avoid mis-calc of the first stack // offset on PEI::calculateFrameObjectOffsets. // Arguments are always 32-bit. unsigned ArgSize = VA.getLocVT().getSizeInBits()/8; unsigned StackLoc = VA.getLocMemOffset() + 4; int FI = MFI->CreateFixedObject(ArgSize, 0, true); MBlazeFI->recordLoadArgsFI(FI, -StackLoc); // Create load nodes to retrieve arguments from the stack SDValue FIN = DAG.getFrameIndex(FI, getPointerTy()); InVals.push_back(DAG.getLoad(VA.getValVT(), dl, Chain, FIN, MachinePointerInfo::getFixedStack(FI), false, false, 0)); } } // To meet ABI, when VARARGS are passed on registers, the registers // must have their values written to the caller stack frame. If the last // argument was placed in the stack, there's no need to save any register. if ((isVarArg) && ArgRegEnd) { if (StackPtr.getNode() == 0) StackPtr = DAG.getRegister(StackReg, getPointerTy()); // The last register argument that must be saved is MBlaze::R10 TargetRegisterClass *RC = MBlaze::GPRRegisterClass; unsigned Begin = MBlazeRegisterInfo::getRegisterNumbering(MBlaze::R5); unsigned Start = MBlazeRegisterInfo::getRegisterNumbering(ArgRegEnd+1); unsigned End = MBlazeRegisterInfo::getRegisterNumbering(MBlaze::R10); unsigned StackLoc = Start - Begin + 1; for (; Start <= End; ++Start, ++StackLoc) { unsigned Reg = MBlazeRegisterInfo::getRegisterFromNumbering(Start); unsigned LiveReg = MF.addLiveIn(Reg, RC); SDValue ArgValue = DAG.getCopyFromReg(Chain, dl, LiveReg, MVT::i32); int FI = MFI->CreateFixedObject(4, 0, true); MBlazeFI->recordStoreVarArgsFI(FI, -(StackLoc*4)); SDValue PtrOff = DAG.getFrameIndex(FI, getPointerTy()); OutChains.push_back(DAG.getStore(Chain, dl, ArgValue, PtrOff, MachinePointerInfo(), false, false, 0)); // Record the frame index of the first variable argument // which is a value necessary to VASTART. if (!MBlazeFI->getVarArgsFrameIndex()) MBlazeFI->setVarArgsFrameIndex(FI); } } // All stores are grouped in one node to allow the matching between // the size of Ins and InVals. This only happens when on varg functions if (!OutChains.empty()) { OutChains.push_back(Chain); Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, &OutChains[0], OutChains.size()); } return Chain; }