Mangler.cpp Source File (original) (raw)

25using namespace llvm;

27namespace {

28enum ManglerPrefixTy {

29 Default,

30 Private,

31 LinkerPrivate

32};

33}

36 ManglerPrefixTy PrefixTy,

40 assert(!Name.empty() && "getNameWithPrefix requires non-empty name");

44 if (Name[0] == '\1') {

45 OS << Name.substr(1);

46 return;

47 }

49 if (DL.doNotMangleLeadingQuestionMark() && Name[0] == '?')

50 Prefix = '\0';

52 if (PrefixTy == Private)

53 OS << DL.getPrivateGlobalPrefix();

54 else if (PrefixTy == LinkerPrivate)

55 OS << DL.getLinkerPrivateGlobalPrefix();

57 if (Prefix != '\0')

58 OS << Prefix;

61 OS << Name;

62}

66 ManglerPrefixTy PrefixTy) {

67 char Prefix = DL.getGlobalPrefix();

69}

79 char Prefix = DL.getGlobalPrefix();

81}

84 switch (CC) {

88 return true;

89 default:

90 return false;

91 }

92}

99 unsigned ArgWords = 0;

100

101 const unsigned PtrSize = DL.getPointerSize();

102

103 for (const Argument &A : F->args()) {

104

105

106 if (A.hasStructRetAttr())

107 continue;

108

109

110 uint64_t AllocSize = A.hasPassPointeeByValueCopyAttr() ?

111 A.getPassPointeeByValueCopySize(DL) :

112 DL.getTypeAllocSize(A.getType());

113

114

115 ArgWords += alignTo(AllocSize, PtrSize);

116 }

117

118 OS << '@' << ArgWords;

119}

120

122 bool CannotUsePrivateLabel) const {

123 ManglerPrefixTy PrefixTy = Default;

124 assert(GV != nullptr && "Invalid Global Value");

126 if (CannotUsePrivateLabel)

127 PrefixTy = LinkerPrivate;

128 else

129 PrefixTy = Private;

130 }

131

134

135

136 unsigned &ID = AnonGlobalIDs[GV];

137 if (ID == 0)

138 ID = AnonGlobalIDs.size();

139

140

142 return;

143 }

144

146 char Prefix = DL.getGlobalPrefix();

147

148

149

151

152

153

154 if (Name.starts_with("\01") ||

155 (DL.doNotMangleLeadingQuestionMark() && Name.starts_with("?")))

156 MSFunc = nullptr;

157

160 if (.hasMicrosoftFastStdCallMangling() &&

162 MSFunc = nullptr;

163 if (MSFunc) {

165 Prefix = '@';

167 Prefix = '\0';

168 }

169

171

172 if (!MSFunc)

173 return;

174

175

176

177

179 OS << '@';

182

186}

187

190 bool CannotUsePrivateLabel) const {

193}

194

195

197 return isAlnum(C) || C == '_' || C == '@' || C == '#';

198}

199

201 if (Name.empty())

202 return false;

203

204

205

206 for (char C : Name) {

208 return false;

209 }

210

211 return true;

212}

213

217

218 if (TT.isWindowsMSVCEnvironment() || TT.isUEFI())

219 OS << " /EXPORT:";

220 else

221 OS << " -export:";

222

224 if (NeedQuotes)

225 OS << "\"";

226 if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {

227 std::string Flag;

232 OS << Flag.substr(1);

233 else

234 OS << Flag;

235 } else {

237 }

238 if (TT.isWindowsArm64EC()) {

239

240

241

242

243

244 if (std::optionalstd::string demangledName =

246 OS << ",EXPORTAS," << *demangledName;

247 }

248 if (NeedQuotes)

249 OS << "\"";

250

252 if (TT.isWindowsMSVCEnvironment() || TT.isUEFI())

253 OS << ",DATA";

254 else

255 OS << ",data";

256 }

257 }

259

260 OS << " -exclude-symbols:";

261

263 if (NeedQuotes)

264 OS << "\"";

265

266 std::string Flag;

271 OS << Flag.substr(1);

272 else

273 OS << Flag;

274

275 if (NeedQuotes)

276 OS << "\"";

277 }

278}

279

282 if (.isWindowsMSVCEnvironment())

283 return;

284

285 OS << " /INCLUDE:";

287 if (NeedQuotes)

288 OS << "\"";

289 M.getNameWithPrefix(OS, GV, false);

290 if (NeedQuotes)

291 OS << "\"";

292}

293

295 assert(!Name.empty() &&

296 "getArm64ECMangledFunctionName requires non-empty name");

297

298 if (Name[0] != '?') {

299

300

301 if (Name[0] == '#')

302 return std::nullopt;

303 return std::optionalstd::string(("#" + Name).str());

304 }

305

306

307 if (Name.contains("$$h"))

308 return std::nullopt;

309

310

311

312

313

314

315

316

317

318

319

320 if (Name.starts_with("??@") && Name.ends_with("@"))

321 return (Name + "$$h@").str();

322

323

325 if (!InsertIdx)

326 return std::nullopt;

327

328 return std::optionalstd::string(

329 (Name.substr(0, *InsertIdx) + "$$h" + Name.substr(*InsertIdx)).str());

330}

331

332std::optionalstd::string

334

335 if (Name[0] == '#')

336 return std::optionalstd::string(Name.substr(1));

337 if (Name[0] != '?')

338 return std::nullopt;

339

340

341 if (Name.starts_with("??@") && Name.ends_with("@$$h@"))

342 return Name.drop_back(4).str();

343

344

345 std::pair<StringRef, StringRef> Pair = Name.split("$$h");

346 if (Pair.second.empty())

347 return std::nullopt;

348 return std::optionalstd::string((Pair.first + Pair.second).str());

349}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

Module.h This file contains the declarations for the Module class.

static bool canBeUnquotedInDirective(char C)

Definition Mangler.cpp:196

static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName, ManglerPrefixTy PrefixTy, const DataLayout &DL, char Prefix)

Definition Mangler.cpp:35

static void addByteCountSuffix(raw_ostream &OS, const Function *F, const DataLayout &DL)

Microsoft fastcall and stdcall functions require a suffix on their name indicating the number of word...

Definition Mangler.cpp:96

static bool hasByteCountSuffix(CallingConv::ID CC)

Definition Mangler.cpp:83

This file defines the SmallString class.

This class represents an incoming formal argument to a Function.

A parsed version of the target data layout string in and methods for querying it.

char getGlobalPrefix() const

Class to represent function types.

unsigned getNumParams() const

Return the number of fixed parameters this function type requires.

FunctionType * getFunctionType() const

Returns the FunctionType for me.

CallingConv::ID getCallingConv() const

getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...

bool hasStructRetAttr() const

Determine if the function returns a structure through first or second pointer argument.

LLVM_ABI bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

bool hasPrivateLinkage() const

bool hasHiddenVisibility() const

bool hasDLLExportStorageClass() const

LLVM_ABI const GlobalObject * getAliaseeObject() const

LLVM_ABI const DataLayout & getDataLayout() const

Get the data layout of the module this global belongs to.

Type * getValueType() const

LLVM_ABI void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const

Print the appropriate prefix and the specified global variable's name.

Definition Mangler.cpp:121

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

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

Triple - Helper class for working with autoconf configuration names.

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

StringRef toStringRef(SmallVectorImpl< char > &Out) const

This returns the twine as a single StringRef if it can be represented as such.

bool isFunctionTy() const

True if this is an instance of FunctionType.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

This class implements an extremely fast bulk output stream that can only output to a stream.

A raw_ostream that writes to an std::string.

A raw_ostream that writes to an SmallVector or SmallString.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

@ X86_StdCall

stdcall is mostly used by the Win32 API.

@ X86_VectorCall

MSVC calling convention that passes vectors and vector aggregates in SSE registers.

@ C

The default llvm calling convention, compatible with C.

@ X86_FastCall

'fast' analog of X86_StdCall.

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI std::optional< std::string > getArm64ECMangledFunctionName(StringRef Name)

Returns the ARM64EC mangled function name unless the input is already mangled.

Definition Mangler.cpp:294

LLVM_ABI std::optional< std::string > getArm64ECDemangledFunctionName(StringRef Name)

Returns the ARM64EC demangled function name, unless the input is not mangled.

Definition Mangler.cpp:333

DEMANGLE_ABI std::optional< size_t > getArm64ECInsertionPointInMangledName(std::string_view MangledName)

auto dyn_cast_or_null(const Y &Val)

bool isAlnum(char C)

Checks whether character C is either a decimal digit or an uppercase or lowercase letter as classifie...

LLVM_ABI void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)

Definition Mangler.cpp:280

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

LLVM_ABI void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)

Definition Mangler.cpp:214

@ Default

The result values are uniform if and only if all operands are uniform.