1 // WebAssemblyMachineFunctionInfo.h-WebAssembly machine function info-*- C++ -*- 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// 9 /// \file 10 /// This file declares WebAssembly-specific per-machine-function 11 /// information. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYMACHINEFUNCTIONINFO_H 16 #define LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYMACHINEFUNCTIONINFO_H 17 18 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" 19 #include "llvm/BinaryFormat/Wasm.h" 20 #include "llvm/CodeGen/MIRYamlMapping.h" 21 #include "llvm/CodeGen/MachineRegisterInfo.h" 22 #include "llvm/MC/MCSymbolWasm.h" 23 24 namespace llvm { 25 26 namespace yaml { 27 struct WebAssemblyFunctionInfo; 28 } 29 30 /// This class is derived from MachineFunctionInfo and contains private 31 /// WebAssembly-specific information for each MachineFunction. 32 class WebAssemblyFunctionInfo final : public MachineFunctionInfo { 33 MachineFunction &MF; 34 35 std::vector<MVT> Params; 36 std::vector<MVT> Results; 37 std::vector<MVT> Locals; 38 39 /// A mapping from CodeGen vreg index to WebAssembly register number. 40 std::vector<unsigned> WARegs; 41 42 /// A mapping from CodeGen vreg index to a boolean value indicating whether 43 /// the given register is considered to be "stackified", meaning it has been 44 /// determined or made to meet the stack requirements: 45 /// - single use (per path) 46 /// - single def (per path) 47 /// - defined and used in LIFO order with other stack registers 48 BitVector VRegStackified; 49 50 // A virtual register holding the pointer to the vararg buffer for vararg 51 // functions. It is created and set in TLI::LowerFormalArguments and read by 52 // TLI::LowerVASTART 53 unsigned VarargVreg = -1U; 54 55 // A virtual register holding the base pointer for functions that have 56 // overaligned values on the user stack. 57 unsigned BasePtrVreg = -1U; 58 // A virtual register holding the frame base. This is either FP or SP 59 // after it has been replaced by a vreg 60 unsigned FrameBaseVreg = -1U; 61 // The local holding the frame base. This is either FP or SP 62 // after WebAssemblyExplicitLocals 63 unsigned FrameBaseLocal = -1U; 64 65 // Function properties. 66 bool CFGStackified = false; 67 68 public: 69 explicit WebAssemblyFunctionInfo(MachineFunction &MF) : MF(MF) {} 70 ~WebAssemblyFunctionInfo() override; 71 void initializeBaseYamlFields(const yaml::WebAssemblyFunctionInfo &YamlMFI); 72 73 void addParam(MVT VT) { Params.push_back(VT); } 74 const std::vector<MVT> &getParams() const { return Params; } 75 76 void addResult(MVT VT) { Results.push_back(VT); } 77 const std::vector<MVT> &getResults() const { return Results; } 78 79 void clearParamsAndResults() { 80 Params.clear(); 81 Results.clear(); 82 } 83 84 void setNumLocals(size_t NumLocals) { Locals.resize(NumLocals, MVT::i32); } 85 void setLocal(size_t i, MVT VT) { Locals[i] = VT; } 86 void addLocal(MVT VT) { Locals.push_back(VT); } 87 const std::vector<MVT> &getLocals() const { return Locals; } 88 89 unsigned getVarargBufferVreg() const { 90 assert(VarargVreg != -1U && "Vararg vreg hasn't been set"); 91 return VarargVreg; 92 } 93 void setVarargBufferVreg(unsigned Reg) { VarargVreg = Reg; } 94 95 unsigned getBasePointerVreg() const { 96 assert(BasePtrVreg != -1U && "Base ptr vreg hasn't been set"); 97 return BasePtrVreg; 98 } 99 void setFrameBaseVreg(unsigned Reg) { FrameBaseVreg = Reg; } 100 unsigned getFrameBaseVreg() const { 101 assert(FrameBaseVreg != -1U && "Frame base vreg hasn't been set"); 102 return FrameBaseVreg; 103 } 104 // Return true if the frame base physreg has been replaced by a virtual reg. 105 bool isFrameBaseVirtual() const { return FrameBaseVreg != -1U; } 106 void setFrameBaseLocal(unsigned Local) { FrameBaseLocal = Local; } 107 unsigned getFrameBaseLocal() const { 108 assert(FrameBaseLocal != -1U && "Frame base local hasn't been set"); 109 return FrameBaseLocal; 110 } 111 void setBasePointerVreg(unsigned Reg) { BasePtrVreg = Reg; } 112 113 static const unsigned UnusedReg = -1u; 114 115 void stackifyVReg(unsigned VReg) { 116 assert(MF.getRegInfo().getUniqueVRegDef(VReg)); 117 auto I = Register::virtReg2Index(VReg); 118 if (I >= VRegStackified.size()) 119 VRegStackified.resize(I + 1); 120 VRegStackified.set(I); 121 } 122 void unstackifyVReg(unsigned VReg) { 123 auto I = Register::virtReg2Index(VReg); 124 if (I < VRegStackified.size()) 125 VRegStackified.reset(I); 126 } 127 bool isVRegStackified(unsigned VReg) const { 128 auto I = Register::virtReg2Index(VReg); 129 if (I >= VRegStackified.size()) 130 return false; 131 return VRegStackified.test(I); 132 } 133 134 void initWARegs(); 135 void setWAReg(unsigned VReg, unsigned WAReg) { 136 assert(WAReg != UnusedReg); 137 auto I = Register::virtReg2Index(VReg); 138 assert(I < WARegs.size()); 139 WARegs[I] = WAReg; 140 } 141 unsigned getWAReg(unsigned VReg) const { 142 auto I = Register::virtReg2Index(VReg); 143 assert(I < WARegs.size()); 144 return WARegs[I]; 145 } 146 147 // For a given stackified WAReg, return the id number to print with push/pop. 148 static unsigned getWARegStackId(unsigned Reg) { 149 assert(Reg & INT32_MIN); 150 return Reg & INT32_MAX; 151 } 152 153 bool isCFGStackified() const { return CFGStackified; } 154 void setCFGStackified(bool Value = true) { CFGStackified = Value; } 155 }; 156 157 void computeLegalValueVTs(const Function &F, const TargetMachine &TM, Type *Ty, 158 SmallVectorImpl<MVT> &ValueVTs); 159 160 // Compute the signature for a given FunctionType (Ty). Note that it's not the 161 // signature for F (F is just used to get varous context) 162 void computeSignatureVTs(const FunctionType *Ty, const Function &F, 163 const TargetMachine &TM, SmallVectorImpl<MVT> &Params, 164 SmallVectorImpl<MVT> &Results); 165 166 void valTypesFromMVTs(const ArrayRef<MVT> &In, 167 SmallVectorImpl<wasm::ValType> &Out); 168 169 std::unique_ptr<wasm::WasmSignature> 170 signatureFromMVTs(const SmallVectorImpl<MVT> &Results, 171 const SmallVectorImpl<MVT> &Params); 172 173 namespace yaml { 174 175 struct WebAssemblyFunctionInfo final : public yaml::MachineFunctionInfo { 176 bool CFGStackified = false; 177 178 WebAssemblyFunctionInfo() = default; 179 WebAssemblyFunctionInfo(const llvm::WebAssemblyFunctionInfo &MFI); 180 181 void mappingImpl(yaml::IO &YamlIO) override; 182 ~WebAssemblyFunctionInfo() = default; 183 }; 184 185 template <> struct MappingTraits<WebAssemblyFunctionInfo> { 186 static void mapping(IO &YamlIO, WebAssemblyFunctionInfo &MFI) { 187 YamlIO.mapOptional("isCFGStackified", MFI.CFGStackified, false); 188 } 189 }; 190 191 } // end namespace yaml 192 193 } // end namespace llvm 194 195 #endif 196