| //===- subzero/src/IceTargetLoweringARM32.h - ARM32 lowering ----*- C++ -*-===// |
| // |
| // The Subzero Code Generator |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file declares the TargetLoweringARM32 class, which implements the |
| // TargetLowering interface for the ARM 32-bit architecture. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef SUBZERO_SRC_ICETARGETLOWERINGARM32_H |
| #define SUBZERO_SRC_ICETARGETLOWERINGARM32_H |
| |
| #include "IceDefs.h" |
| #include "IceInstARM32.h" |
| #include "IceRegistersARM32.h" |
| #include "IceTargetLowering.h" |
| |
| namespace Ice { |
| |
| class TargetARM32 : public TargetLowering { |
| TargetARM32() = delete; |
| TargetARM32(const TargetARM32 &) = delete; |
| TargetARM32 &operator=(const TargetARM32 &) = delete; |
| |
| public: |
| // TODO(jvoung): return a unique_ptr. |
| static TargetARM32 *create(Cfg *Func) { return new TargetARM32(Func); } |
| |
| void translateOm1() override; |
| void translateO2() override; |
| bool doBranchOpt(Inst *I, const CfgNode *NextNode) override; |
| |
| SizeT getNumRegisters() const override { return RegARM32::Reg_NUM; } |
| Variable *getPhysicalRegister(SizeT RegNum, Type Ty = IceType_void) override; |
| IceString getRegName(SizeT RegNum, Type Ty) const override; |
| llvm::SmallBitVector getRegisterSet(RegSetMask Include, |
| RegSetMask Exclude) const override; |
| const llvm::SmallBitVector &getRegisterSetForType(Type Ty) const override { |
| return TypeToRegisterSet[Ty]; |
| } |
| bool hasFramePointer() const override { return UsesFramePointer; } |
| SizeT getFrameOrStackReg() const override { |
| return UsesFramePointer ? RegARM32::Reg_fp : RegARM32::Reg_sp; |
| } |
| size_t typeWidthInBytesOnStack(Type Ty) const override { |
| // Round up to the next multiple of 4 bytes. In particular, i1, |
| // i8, and i16 are rounded up to 4 bytes. |
| return (typeWidthInBytes(Ty) + 3) & ~3; |
| } |
| void emitVariable(const Variable *Var) const override; |
| |
| const char *getConstantPrefix() const final { return "#"; } |
| void emit(const ConstantUndef *C) const final; |
| void emit(const ConstantInteger32 *C) const final; |
| void emit(const ConstantInteger64 *C) const final; |
| void emit(const ConstantFloat *C) const final; |
| void emit(const ConstantDouble *C) const final; |
| |
| void lowerArguments() override; |
| void addProlog(CfgNode *Node) override; |
| void addEpilog(CfgNode *Node) override; |
| |
| // Ensure that a 64-bit Variable has been split into 2 32-bit |
| // Variables, creating them if necessary. This is needed for all |
| // I64 operations. |
| void split64(Variable *Var); |
| Operand *loOperand(Operand *Operand); |
| Operand *hiOperand(Operand *Operand); |
| |
| protected: |
| explicit TargetARM32(Cfg *Func); |
| |
| void postLower() override; |
| |
| void lowerAlloca(const InstAlloca *Inst) override; |
| void lowerArithmetic(const InstArithmetic *Inst) override; |
| void lowerAssign(const InstAssign *Inst) override; |
| void lowerBr(const InstBr *Inst) override; |
| void lowerCall(const InstCall *Inst) override; |
| void lowerCast(const InstCast *Inst) override; |
| void lowerExtractElement(const InstExtractElement *Inst) override; |
| void lowerFcmp(const InstFcmp *Inst) override; |
| void lowerIcmp(const InstIcmp *Inst) override; |
| void lowerIntrinsicCall(const InstIntrinsicCall *Inst) override; |
| void lowerInsertElement(const InstInsertElement *Inst) override; |
| void lowerLoad(const InstLoad *Inst) override; |
| void lowerPhi(const InstPhi *Inst) override; |
| void lowerRet(const InstRet *Inst) override; |
| void lowerSelect(const InstSelect *Inst) override; |
| void lowerStore(const InstStore *Inst) override; |
| void lowerSwitch(const InstSwitch *Inst) override; |
| void lowerUnreachable(const InstUnreachable *Inst) override; |
| void prelowerPhis() override; |
| void lowerPhiAssignments(CfgNode *Node, |
| const AssignList &Assignments) override; |
| void doAddressOptLoad() override; |
| void doAddressOptStore() override; |
| void randomlyInsertNop(float Probability) override; |
| |
| enum OperandLegalization { |
| Legal_None = 0, |
| Legal_Reg = 1 << 0, // physical register, not stack location |
| Legal_Flex = 1 << 1, // A flexible operand2, which can hold rotated |
| // small immediates, or shifted registers. |
| Legal_Mem = 1 << 2, // includes [r0, r1 lsl #2] as well as [sp, #12] |
| Legal_All = ~Legal_None |
| }; |
| typedef uint32_t LegalMask; |
| Operand *legalize(Operand *From, LegalMask Allowed = Legal_All, |
| int32_t RegNum = Variable::NoRegister); |
| Variable *legalizeToVar(Operand *From, int32_t RegNum = Variable::NoRegister); |
| |
| Variable *makeReg(Type Ty, int32_t RegNum = Variable::NoRegister); |
| static Type stackSlotType(); |
| Variable *copyToReg(Operand *Src, int32_t RegNum = Variable::NoRegister); |
| |
| // Returns a vector in a register with the given constant entries. |
| Variable *makeVectorOfZeros(Type Ty, int32_t RegNum = Variable::NoRegister); |
| |
| void makeRandomRegisterPermutation( |
| llvm::SmallVectorImpl<int32_t> &Permutation, |
| const llvm::SmallBitVector &ExcludeRegisters) const override; |
| |
| // The following are helpers that insert lowered ARM32 instructions |
| // with minimal syntactic overhead, so that the lowering code can |
| // look as close to assembly as practical. |
| |
| void _ldr(Variable *Dest, OperandARM32Mem *Addr) { |
| Context.insert(InstARM32Ldr::create(Func, Dest, Addr)); |
| } |
| // If Dest=nullptr is passed in, then a new variable is created, |
| // marked as infinite register allocation weight, and returned |
| // through the in/out Dest argument. |
| void _mov(Variable *&Dest, Operand *Src0, |
| int32_t RegNum = Variable::NoRegister) { |
| if (Dest == nullptr) |
| Dest = makeReg(Src0->getType(), RegNum); |
| Context.insert(InstARM32Mov::create(Func, Dest, Src0)); |
| } |
| // The Operand can only be a 16-bit immediate or a ConstantRelocatable |
| // (with an upper16 relocation). |
| void _movt(Variable *&Dest, Operand *Src0) { |
| Context.insert(InstARM32Movt::create(Func, Dest, Src0)); |
| } |
| void _movw(Variable *&Dest, Operand *Src0) { |
| Context.insert(InstARM32Movw::create(Func, Dest, Src0)); |
| } |
| void _mvn(Variable *&Dest, Operand *Src0) { |
| Context.insert(InstARM32Mvn::create(Func, Dest, Src0)); |
| } |
| void _ret(Variable *LR, Variable *Src0 = nullptr) { |
| Context.insert(InstARM32Ret::create(Func, LR, Src0)); |
| } |
| |
| bool UsesFramePointer; |
| bool NeedsStackAlignment; |
| llvm::SmallBitVector TypeToRegisterSet[IceType_NUM]; |
| llvm::SmallBitVector ScratchRegs; |
| llvm::SmallBitVector RegsUsed; |
| VarList PhysicalRegisters[IceType_NUM]; |
| static IceString RegNames[]; |
| |
| private: |
| ~TargetARM32() override {} |
| }; |
| |
| class TargetDataARM32 : public TargetDataLowering { |
| TargetDataARM32() = delete; |
| TargetDataARM32(const TargetDataARM32 &) = delete; |
| TargetDataARM32 &operator=(const TargetDataARM32 &) = delete; |
| |
| public: |
| static TargetDataLowering *create(GlobalContext *Ctx) { |
| return new TargetDataARM32(Ctx); |
| } |
| |
| void lowerGlobals(std::unique_ptr<VariableDeclarationList> Vars) const final; |
| void lowerConstants() const final; |
| |
| protected: |
| explicit TargetDataARM32(GlobalContext *Ctx); |
| |
| private: |
| void lowerGlobal(const VariableDeclaration &Var) const; |
| ~TargetDataARM32() override {} |
| template <typename T> static void emitConstantPool(GlobalContext *Ctx); |
| }; |
| |
| } // end of namespace Ice |
| |
| #endif // SUBZERO_SRC_ICETARGETLOWERINGARM32_H |