Home | History | Annotate | Line # | Download | only in WebAssembly 
      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/CodeGen/MIRYamlMapping.h"
     20 #include "llvm/CodeGen/MachineRegisterInfo.h"
     21 #include "llvm/MC/MCSymbolWasm.h"
     22 
     23 namespace llvm {
     24 
     25 struct WasmEHFuncInfo;
     26 
     27 namespace yaml {
     28 struct WebAssemblyFunctionInfo;
     29 }
     30 
     31 /// This class is derived from MachineFunctionInfo and contains private
     32 /// WebAssembly-specific information for each MachineFunction.
     33 class WebAssemblyFunctionInfo final : public MachineFunctionInfo {
     34   const MachineFunction &MF;
     35 
     36   std::vector<MVT> Params;
     37   std::vector<MVT> Results;
     38   std::vector<MVT> Locals;
     39 
     40   /// A mapping from CodeGen vreg index to WebAssembly register number.
     41   std::vector<unsigned> WARegs;
     42 
     43   /// A mapping from CodeGen vreg index to a boolean value indicating whether
     44   /// the given register is considered to be "stackified", meaning it has been
     45   /// determined or made to meet the stack requirements:
     46   ///   - single use (per path)
     47   ///   - single def (per path)
     48   ///   - defined and used in LIFO order with other stack registers
     49   BitVector VRegStackified;
     50 
     51   // A virtual register holding the pointer to the vararg buffer for vararg
     52   // functions. It is created and set in TLI::LowerFormalArguments and read by
     53   // TLI::LowerVASTART
     54   unsigned VarargVreg = -1U;
     55 
     56   // A virtual register holding the base pointer for functions that have
     57   // overaligned values on the user stack.
     58   unsigned BasePtrVreg = -1U;
     59   // A virtual register holding the frame base. This is either FP or SP
     60   // after it has been replaced by a vreg
     61   unsigned FrameBaseVreg = -1U;
     62   // The local holding the frame base. This is either FP or SP
     63   // after WebAssemblyExplicitLocals
     64   unsigned FrameBaseLocal = -1U;
     65 
     66   // Function properties.
     67   bool CFGStackified = false;
     68 
     69   // Catchpad unwind destination info for wasm EH.
     70   WasmEHFuncInfo *WasmEHInfo = nullptr;
     71 
     72 public:
     73   explicit WebAssemblyFunctionInfo(MachineFunction &MF)
     74       : MF(MF), WasmEHInfo(MF.getWasmEHFuncInfo()) {}
     75   ~WebAssemblyFunctionInfo() override;
     76 
     77   const MachineFunction &getMachineFunction() const { return MF; }
     78 
     79   void initializeBaseYamlFields(const yaml::WebAssemblyFunctionInfo &YamlMFI);
     80 
     81   void addParam(MVT VT) { Params.push_back(VT); }
     82   const std::vector<MVT> &getParams() const { return Params; }
     83 
     84   void addResult(MVT VT) { Results.push_back(VT); }
     85   const std::vector<MVT> &getResults() const { return Results; }
     86 
     87   void clearParamsAndResults() {
     88     Params.clear();
     89     Results.clear();
     90   }
     91 
     92   void setNumLocals(size_t NumLocals) { Locals.resize(NumLocals, MVT::i32); }
     93   void setLocal(size_t i, MVT VT) { Locals[i] = VT; }
     94   void addLocal(MVT VT) { Locals.push_back(VT); }
     95   const std::vector<MVT> &getLocals() const { return Locals; }
     96 
     97   unsigned getVarargBufferVreg() const {
     98     assert(VarargVreg != -1U && "Vararg vreg hasn't been set");
     99     return VarargVreg;
    100   }
    101   void setVarargBufferVreg(unsigned Reg) { VarargVreg = Reg; }
    102 
    103   unsigned getBasePointerVreg() const {
    104     assert(BasePtrVreg != -1U && "Base ptr vreg hasn't been set");
    105     return BasePtrVreg;
    106   }
    107   void setFrameBaseVreg(unsigned Reg) { FrameBaseVreg = Reg; }
    108   unsigned getFrameBaseVreg() const {
    109     assert(FrameBaseVreg != -1U && "Frame base vreg hasn't been set");
    110     return FrameBaseVreg;
    111   }
    112   void clearFrameBaseVreg() { FrameBaseVreg = -1U; }
    113   // Return true if the frame base physreg has been replaced by a virtual reg.
    114   bool isFrameBaseVirtual() const { return FrameBaseVreg != -1U; }
    115   void setFrameBaseLocal(unsigned Local) { FrameBaseLocal = Local; }
    116   unsigned getFrameBaseLocal() const {
    117     assert(FrameBaseLocal != -1U && "Frame base local hasn't been set");
    118     return FrameBaseLocal;
    119   }
    120   void setBasePointerVreg(unsigned Reg) { BasePtrVreg = Reg; }
    121 
    122   static const unsigned UnusedReg = -1u;
    123 
    124   void stackifyVReg(MachineRegisterInfo &MRI, unsigned VReg) {
    125     assert(MRI.getUniqueVRegDef(VReg));
    126     auto I = Register::virtReg2Index(VReg);
    127     if (I >= VRegStackified.size())
    128       VRegStackified.resize(I + 1);
    129     VRegStackified.set(I);
    130   }
    131   void unstackifyVReg(unsigned VReg) {
    132     auto I = Register::virtReg2Index(VReg);
    133     if (I < VRegStackified.size())
    134       VRegStackified.reset(I);
    135   }
    136   bool isVRegStackified(unsigned VReg) const {
    137     auto I = Register::virtReg2Index(VReg);
    138     if (I >= VRegStackified.size())
    139       return false;
    140     return VRegStackified.test(I);
    141   }
    142 
    143   void initWARegs(MachineRegisterInfo &MRI);
    144   void setWAReg(unsigned VReg, unsigned WAReg) {
    145     assert(WAReg != UnusedReg);
    146     auto I = Register::virtReg2Index(VReg);
    147     assert(I < WARegs.size());
    148     WARegs[I] = WAReg;
    149   }
    150   unsigned getWAReg(unsigned VReg) const {
    151     auto I = Register::virtReg2Index(VReg);
    152     assert(I < WARegs.size());
    153     return WARegs[I];
    154   }
    155 
    156   // For a given stackified WAReg, return the id number to print with push/pop.
    157   static unsigned getWARegStackId(unsigned Reg) {
    158     assert(Reg & INT32_MIN);
    159     return Reg & INT32_MAX;
    160   }
    161 
    162   bool isCFGStackified() const { return CFGStackified; }
    163   void setCFGStackified(bool Value = true) { CFGStackified = Value; }
    164 
    165   WasmEHFuncInfo *getWasmEHFuncInfo() const { return WasmEHInfo; }
    166   void setWasmEHFuncInfo(WasmEHFuncInfo *Info) { WasmEHInfo = Info; }
    167 };
    168 
    169 void computeLegalValueVTs(const Function &F, const TargetMachine &TM, Type *Ty,
    170                           SmallVectorImpl<MVT> &ValueVTs);
    171 
    172 // Compute the signature for a given FunctionType (Ty). Note that it's not the
    173 // signature for ContextFunc (ContextFunc is just used to get varous context)
    174 void computeSignatureVTs(const FunctionType *Ty, const Function *TargetFunc,
    175                          const Function &ContextFunc, const TargetMachine &TM,
    176                          SmallVectorImpl<MVT> &Params,
    177                          SmallVectorImpl<MVT> &Results);
    178 
    179 void valTypesFromMVTs(const ArrayRef<MVT> &In,
    180                       SmallVectorImpl<wasm::ValType> &Out);
    181 
    182 std::unique_ptr<wasm::WasmSignature>
    183 signatureFromMVTs(const SmallVectorImpl<MVT> &Results,
    184                   const SmallVectorImpl<MVT> &Params);
    185 
    186 namespace yaml {
    187 
    188 using BBNumberMap = DenseMap<int, int>;
    189 
    190 struct WebAssemblyFunctionInfo final : public yaml::MachineFunctionInfo {
    191   std::vector<FlowStringValue> Params;
    192   std::vector<FlowStringValue> Results;
    193   bool CFGStackified = false;
    194   // The same as WasmEHFuncInfo's SrcToUnwindDest, but stored in the mapping of
    195   // BB numbers
    196   BBNumberMap SrcToUnwindDest;
    197 
    198   WebAssemblyFunctionInfo() = default;
    199   WebAssemblyFunctionInfo(const llvm::WebAssemblyFunctionInfo &MFI);
    200 
    201   void mappingImpl(yaml::IO &YamlIO) override;
    202   ~WebAssemblyFunctionInfo() = default;
    203 };
    204 
    205 template <> struct MappingTraits<WebAssemblyFunctionInfo> {
    206   static void mapping(IO &YamlIO, WebAssemblyFunctionInfo &MFI) {
    207     YamlIO.mapOptional("params", MFI.Params, std::vector<FlowStringValue>());
    208     YamlIO.mapOptional("results", MFI.Results, std::vector<FlowStringValue>());
    209     YamlIO.mapOptional("isCFGStackified", MFI.CFGStackified, false);
    210     YamlIO.mapOptional("wasmEHFuncInfo", MFI.SrcToUnwindDest);
    211   }
    212 };
    213 
    214 template <> struct CustomMappingTraits<BBNumberMap> {
    215   static void inputOne(IO &YamlIO, StringRef Key,
    216                        BBNumberMap &SrcToUnwindDest) {
    217     YamlIO.mapRequired(Key.str().c_str(),
    218                        SrcToUnwindDest[std::atoi(Key.str().c_str())]);
    219   }
    220 
    221   static void output(IO &YamlIO, BBNumberMap &SrcToUnwindDest) {
    222     for (auto KV : SrcToUnwindDest)
    223       YamlIO.mapRequired(std::to_string(KV.first).c_str(), KV.second);
    224   }
    225 };
    226 
    227 } // end namespace yaml
    228 
    229 } // end namespace llvm
    230 
    231 #endif
    232