RecordName.cpp Source File (original) (raw)

23using namespace llvm;

26namespace {

29 TypeCollection &Types;

33 SmallString<256> Name;

35public:

36 explicit TypeNameComputer(TypeCollection &Types) : Types(Types) {}

38 StringRef name() const { return Name; }

42 Error visitTypeBegin(CVType &Record) override;

43 Error visitTypeBegin(CVType &Record, TypeIndex Index) override;

44 Error visitTypeEnd(CVType &Record) override;

46#define TYPE_RECORD(EnumName, EnumVal, Name) \

47 Error visitKnownRecord(CVType &CVR, Name##Record &Record) override;

48#define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)

49#define MEMBER_RECORD(EnumName, EnumVal, Name)

50#include "llvm/DebugInfo/CodeView/CodeViewTypes.def"

51};

52}

55 llvm_unreachable("Must call visitTypeBegin with a TypeIndex!");

57}

59Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {

61 Name = "";

62 CurrentTypeIndex = Index;

64}

68Error TypeNameComputer::visitKnownRecord(CVType &CVR,

70 Name = "";

72}

74Error TypeNameComputer::visitKnownRecord(CVRecord &CVR,

75 StringIdRecord &String) {

76 Name = String.getString();

78}

80Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {

81 auto Indices = Args.getIndices();

82 uint32_t Size = Indices.size();

83 Name = "(";

84 for (uint32_t I = 0; I < Size; ++I) {

85 if (Indices[I] < CurrentTypeIndex)

87 else

88 Name.append("<unknown 0x" + utohexstr(Indices[I].getIndex()) + ">");

89 if (I + 1 != Size)

91 }

94}

96Error TypeNameComputer::visitKnownRecord(CVType &CVR,

97 StringListRecord &Strings) {

99 uint32_t Size = Indices.size();

100 Name = "\"";

101 for (uint32_t I = 0; I < Size; ++I) {

103 if (I + 1 != Size)

104 Name.append("\" \"");

105 }

108}

109

110Error TypeNameComputer::visitKnownRecord(CVType &CVR, ClassRecord &Class) {

111 Name = Class.getName();

113}

114

115Error TypeNameComputer::visitKnownRecord(CVType &CVR, UnionRecord &Union) {

116 Name = Union.getName();

118}

119

120Error TypeNameComputer::visitKnownRecord(CVType &CVR, EnumRecord &Enum) {

121 Name = Enum.getName();

123}

124

125Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {

128}

129

130Error TypeNameComputer::visitKnownRecord(CVType &CVR, VFTableRecord &VFT) {

133}

134

135Error TypeNameComputer::visitKnownRecord(CVType &CVR, MemberFuncIdRecord &Id) {

136 Name = Id.getName();

138}

139

140Error TypeNameComputer::visitKnownRecord(CVType &CVR, ProcedureRecord &Proc) {

143 Name = formatv("{0} {1}", Ret, Params).sstr<256>();

145}

146

147Error TypeNameComputer::visitKnownRecord(CVType &CVR,

148 MemberFunctionRecord &MF) {

152 Name = formatv("{0} {1}::{2}", Ret, Class, Params).sstr<256>();

154}

155

156Error TypeNameComputer::visitKnownRecord(CVType &CVR, FuncIdRecord &Func) {

157 Name = Func.getName();

159}

160

161Error TypeNameComputer::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {

164}

165

166Error TypeNameComputer::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {

167

170

173 Name = formatv("{0} {1}::*", Pointee, Class);

174 } else {

176

177 if (Ptr.getMode() == PointerMode::LValueReference)

179 else if (Ptr.getMode() == PointerMode::RValueReference)

181 else if (Ptr.getMode() == PointerMode::Pointer)

183

184

185

187 Name.append(" const");

189 Name.append(" volatile");

191 Name.append(" __unaligned");

193 Name.append(" __restrict");

194 }

196}

197

198Error TypeNameComputer::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {

199 uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());

200

201 if (Mods & uint16_t(ModifierOptions::Const))

202 Name.append("const ");

203 if (Mods & uint16_t(ModifierOptions::Volatile))

204 Name.append("volatile ");

205 if (Mods & uint16_t(ModifierOptions::Unaligned))

206 Name.append("__unaligned ");

209}

210

211Error TypeNameComputer::visitKnownRecord(CVType &CVR,

212 VFTableShapeRecord &Shape) {

215}

216

217Error TypeNameComputer::visitKnownRecord(

218 CVType &CVR, UdtModSourceLineRecord &ModSourceLine) {

220}

221

222Error TypeNameComputer::visitKnownRecord(CVType &CVR,

223 UdtSourceLineRecord &SourceLine) {

225}

226

227Error TypeNameComputer::visitKnownRecord(CVType &CVR, BitFieldRecord &BF) {

229}

230

231Error TypeNameComputer::visitKnownRecord(CVType &CVR,

232 MethodOverloadListRecord &Overloads) {

234}

235

236Error TypeNameComputer::visitKnownRecord(CVType &CVR, BuildInfoRecord &BI) {

238}

239

240Error TypeNameComputer::visitKnownRecord(CVType &CVR, LabelRecord &R) {

242}

243

244Error TypeNameComputer::visitKnownRecord(CVType &CVR,

245 PrecompRecord &Precomp) {

247}

248

249Error TypeNameComputer::visitKnownRecord(CVType &CVR,

250 EndPrecompRecord &EndPrecomp) {

252}

253

256 TypeNameComputer Computer(Types);

260 return "";

261 }

262 return std::string(Computer.name());

263}

264

266 switch (Sym.kind()) {

267

268 case SymbolKind::S_GPROC32:

269 case SymbolKind::S_LPROC32:

270 case SymbolKind::S_GPROC32_ID:

271 case SymbolKind::S_LPROC32_ID:

272 case SymbolKind::S_LPROC32_DPC:

273 case SymbolKind::S_LPROC32_DPC_ID:

274 return 35;

275

276 case SymbolKind::S_THUNK32:

277 return 21;

278

279 case SymbolKind::S_SECTION:

280 return 16;

281

282 case SymbolKind::S_COFFGROUP:

283 return 14;

284

285 case SymbolKind::S_PUB32:

286 case SymbolKind::S_FILESTATIC:

287 case SymbolKind::S_REGREL32:

288 case SymbolKind::S_GDATA32:

289 case SymbolKind::S_LDATA32:

290 case SymbolKind::S_LMANDATA:

291 case SymbolKind::S_GMANDATA:

292 case SymbolKind::S_LTHREAD32:

293 case SymbolKind::S_GTHREAD32:

294 case SymbolKind::S_PROCREF:

295 case SymbolKind::S_LPROCREF:

296 return 10;

297

298 case SymbolKind::S_REGISTER:

299 case SymbolKind::S_LOCAL:

300 return 6;

301

302 case SymbolKind::S_BLOCK32:

303 return 18;

304

305 case SymbolKind::S_LABEL32:

306 return 7;

307

308 case SymbolKind::S_OBJNAME:

309 case SymbolKind::S_EXPORT:

310 case SymbolKind::S_UDT:

311 return 4;

312

313 case SymbolKind::S_BPREL32:

314 return 8;

315

316 case SymbolKind::S_UNAMESPACE:

317 return 0;

318 default:

319 return -1;

320 }

321}

322

324 if (Sym.kind() == SymbolKind::S_CONSTANT) {

325

326

328

334 return Const.Name;

335 }

336

340

343}

if(auto Err=PB.parsePassPipeline(MPM, Passes)) return wrap(std MPM run * Mod

static int getSymbolNameOffset(CVSymbol Sym)

Definition RecordName.cpp:265

This file defines the SmallString class.

Provides read only access to a subclass of BinaryStream.

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

const RecordRecTy * getType() const

void append(StringRef RHS)

Append from a StringRef.

void push_back(const T &Elt)

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

StringRef drop_front(size_t N=1) const

Return a StringRef equal to 'this' but with the first N elements dropped.

StringRef getName() const

ArrayRef< uint8_t > content() const

TypeIndex getReturnType() const

TypeIndex getArgumentList() const

TypeIndex getClassType() const

TypeIndex getReferentType() const

MemberPointerInfo getMemberInfo() const

bool isPointerToMember() const

PointerMode getMode() const

TypeIndex getReturnType() const

TypeIndex getArgumentList() const

ArrayRef< TypeIndex > getIndices() const

Error visitSymbolEnd(CVSymbol &Record) override

Error visitSymbolBegin(CVSymbol &Record) override

virtual StringRef getTypeName(TypeIndex Index)=0

StringRef getName() const

uint32_t getEntryCount() const

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

constexpr char Args[]

Key for Kernel::Metadata::mArgs.

CVRecord< TypeLeafKind > CVType

LLVM_ABI std::string computeTypeName(TypeCollection &Types, TypeIndex Index)

Definition RecordName.cpp:254

CVRecord< SymbolKind > CVSymbol

LLVM_ABI StringRef getSymbolName(CVSymbol Sym)

Definition RecordName.cpp:323

LLVM_ABI Error visitTypeRecord(CVType &Record, TypeIndex Index, TypeVisitorCallbacks &Callbacks, VisitorDataSource Source=VDS_BytesPresent)

NodeAddr< FuncNode * > Func

This is an optimization pass for GlobalISel generic memory operations.

std::string utohexstr(uint64_t X, bool LowerCase=false, unsigned Width=0)

auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)

void cantFail(Error Err, const char *Msg=nullptr)

Report a fatal error if Err is a failure value.

void consumeError(Error Err)

Consume a Error without doing anything.

StringRef toStringRef(bool B)

Construct a string ref from a boolean.