WebAssemblyMachineFunctionInfo.h Source File (original) (raw)

15#ifndef LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYMACHINEFUNCTIONINFO_H

16#define LLVM_LIB_TARGET_WEBASSEMBLY_WEBASSEMBLYMACHINEFUNCTIONINFO_H

23namespace llvm {

24class WebAssemblyTargetLowering;

26struct WasmEHFuncInfo;

28namespace yaml {

29struct WebAssemblyFunctionInfo;

30}

35 std::vector Params;

36 std::vector Results;

37 std::vector Locals;

40 std::vector WARegs;

53 unsigned VarargVreg = -1U;

57 unsigned BasePtrVreg = -1U;

60 unsigned FrameBaseVreg = -1U;

63 unsigned FrameBaseLocal = -1U;

66 bool CFGStackified = false;

68public:

76 const override;

82 const std::vector &getParams() const { return Params; }

88 Params.clear();

90 }

92 void setNumLocals(size_t NumLocals) { Locals.resize(NumLocals, MVT::i32); }

93 void setLocal(size_t i, MVT VT) { Locals[i] = VT; }

95 const std::vector &getLocals() const { return Locals; }

98 assert(VarargVreg != -1U && "Vararg vreg hasn't been set");

99 return VarargVreg;

100 }

102

104 assert(BasePtrVreg != -1U && "Base ptr vreg hasn't been set");

105 return BasePtrVreg;

106 }

109 assert(FrameBaseVreg != -1U && "Frame base vreg hasn't been set");

110 return FrameBaseVreg;

111 }

113

117 assert(FrameBaseLocal != -1U && "Frame base local hasn't been set");

118 return FrameBaseLocal;

119 }

121

123 assert(MRI.getUniqueVRegDef(VReg));

125 if (I >= VRegStackified.size())

126 VRegStackified.resize(I + 1);

127 VRegStackified.set(I);

128 }

131 if (I < VRegStackified.size())

132 VRegStackified.reset(I);

133 }

136 if (I >= VRegStackified.size())

137 return false;

138 return VRegStackified.test(I);

139 }

140

142 void setWAReg(unsigned VReg, unsigned WAReg) {

145 assert(I < WARegs.size());

146 WARegs[I] = WAReg;

147 }

150 assert(I < WARegs.size());

151 return WARegs[I];

152 }

153

156};

157

159 LLVMContext &Ctx, const DataLayout &DL, Type *Ty,

160 SmallVectorImpl &ValueVTs);

161

163 SmallVectorImpl &ValueVTs);

164

165

166

168 const Function &ContextFunc, const TargetMachine &TM,

169 SmallVectorImpl &Params,

170 SmallVectorImpl &Results);

171

172void valTypesFromMVTs(ArrayRef In, SmallVectorImplwasm::ValType &Out);

173

175 const SmallVectorImpl &Results,

176 const SmallVectorImpl &Params);

177

178namespace yaml {

179

181

183 std::vector Params;

184 std::vector Results;

186

187

189

193

196};

197

200 YamlIO.mapOptional("params", MFI.Params, std::vector());

201 YamlIO.mapOptional("results", MFI.Results, std::vector());

204 }

205};

206

210 YamlIO.mapRequired(Key.str().c_str(),

211 SrcToUnwindDest[std::atoi(Key.str().c_str())]);

212 }

213

215 for (auto KV : SrcToUnwindDest)

216 YamlIO.mapRequired(std::to_string(KV.first).c_str(), KV.second);

217 }

218};

219

220}

221

222}

223

224#endif

unsigned const MachineRegisterInfo * MRI

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Function Alias Analysis Results

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

This file provides WebAssembly-specific target descriptions.

bool test(unsigned Idx) const

void resize(unsigned N, bool t=false)

resize - Grow or shrink the bitvector.

size_type size() const

size - Returns the number of bits in this bitvector.

Allocate memory in an ever growing pool, as if by bump-pointer.

MachineRegisterInfo - Keep track of information for virtual and physical registers,...

static unsigned virtReg2Index(Register Reg)

Convert a virtual register number to a 0-based index.

StringRef - Represent a constant reference to a string, i.e.

TargetSubtargetInfo - Generic base class for all target subtargets.

LLVM Value Representation.

This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information ...

void setFrameBaseVreg(unsigned Reg)

bool isVRegStackified(unsigned VReg) const

bool isCFGStackified() const

WebAssemblyFunctionInfo(const Function &F, const TargetSubtargetInfo *STI)

~WebAssemblyFunctionInfo() override

const std::vector< MVT > & getResults() const

unsigned getFrameBaseLocal() const

void setLocal(size_t i, MVT VT)

unsigned getWAReg(unsigned VReg) const

MachineFunctionInfo * clone(BumpPtrAllocator &Allocator, MachineFunction &DestMF, const DenseMap< MachineBasicBlock *, MachineBasicBlock * > &Src2DstMBB) const override

Make a functionally equivalent copy of this MachineFunctionInfo in MF.

void initWARegs(MachineRegisterInfo &MRI)

void setWAReg(unsigned VReg, unsigned WAReg)

void clearParamsAndResults()

void setBasePointerVreg(unsigned Reg)

void setNumLocals(size_t NumLocals)

void setVarargBufferVreg(unsigned Reg)

void setCFGStackified(bool Value=true)

unsigned getFrameBaseVreg() const

void setFrameBaseLocal(unsigned Local)

unsigned getVarargBufferVreg() const

void unstackifyVReg(unsigned VReg)

void stackifyVReg(MachineRegisterInfo &MRI, unsigned VReg)

unsigned getBasePointerVreg() const

const std::vector< MVT > & getLocals() const

void clearFrameBaseVreg()

void initializeBaseYamlFields(MachineFunction &MF, const yaml::WebAssemblyFunctionInfo &YamlMFI)

bool isFrameBaseVirtual() const

const std::vector< MVT > & getParams() const

static const unsigned UnusedReg

This is an optimization pass for GlobalISel generic memory operations.

void computeSignatureVTs(const FunctionType *Ty, const Function *TargetFunc, const Function &ContextFunc, const TargetMachine &TM, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results)

void valTypesFromMVTs(ArrayRef< MVT > In, SmallVectorImpl< wasm::ValType > &Out)

wasm::WasmSignature * signatureFromMVTs(MCContext &Ctx, const SmallVectorImpl< MVT > &Results, const SmallVectorImpl< MVT > &Params)

void computeLegalValueVTs(const WebAssemblyTargetLowering &TLI, LLVMContext &Ctx, const DataLayout &DL, Type *Ty, SmallVectorImpl< MVT > &ValueVTs)

MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...

static void output(IO &YamlIO, BBNumberMap &SrcToUnwindDest)

static void inputOne(IO &YamlIO, StringRef Key, BBNumberMap &SrcToUnwindDest)

Targets should override this in a way that mirrors the implementation of llvm::MachineFunctionInfo.

static void mapping(IO &YamlIO, WebAssemblyFunctionInfo &MFI)

~WebAssemblyFunctionInfo()=default

WebAssemblyFunctionInfo()=default

void mappingImpl(yaml::IO &YamlIO) override

std::vector< FlowStringValue > Results

std::vector< FlowStringValue > Params

BBNumberMap SrcToUnwindDest