LLVM 17.0.0git
Mangler.cpp
Go to the documentation of this file.
1//===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===//
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// Unified name mangler for assembly backends.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/IR/Mangler.h"
16#include "llvm/ADT/Triple.h"
17#include "llvm/ADT/Twine.h"
18#include "llvm/IR/DataLayout.h"
20#include "llvm/IR/Function.h"
21#include "llvm/IR/Module.h"
23using namespace llvm;
24
25namespace {
26enum ManglerPrefixTy {
27 Default, ///< Emit default string before each symbol.
28 Private, ///< Emit "private" prefix before each symbol.
29 LinkerPrivate ///< Emit "linker private" prefix before each symbol.
30};
31}
32
33static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName,
34 ManglerPrefixTy PrefixTy,
35 const DataLayout &DL, char Prefix) {
36 SmallString<256> TmpData;
37 StringRef Name = GVName.toStringRef(TmpData);
38 assert(!Name.empty() && "getNameWithPrefix requires non-empty name");
39
40 // No need to do anything special if the global has the special "do not
41 // mangle" flag in the name.
42 if (Name[0] == '\1') {
43 OS << Name.substr(1);
44 return;
45 }
46
47 if (DL.doNotMangleLeadingQuestionMark() && Name[0] == '?')
48 Prefix = '\0';
49
50 if (PrefixTy == Private)
51 OS << DL.getPrivateGlobalPrefix();
52 else if (PrefixTy == LinkerPrivate)
53 OS << DL.getLinkerPrivateGlobalPrefix();
54
55 if (Prefix != '\0')
56 OS << Prefix;
57
58 // If this is a simple string that doesn't need escaping, just append it.
59 OS << Name;
60}
61
62static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName,
63 const DataLayout &DL,
64 ManglerPrefixTy PrefixTy) {
65 char Prefix = DL.getGlobalPrefix();
66 return getNameWithPrefixImpl(OS, GVName, PrefixTy, DL, Prefix);
67}
68
70 const DataLayout &DL) {
71 return getNameWithPrefixImpl(OS, GVName, DL, Default);
72}
73
75 const Twine &GVName, const DataLayout &DL) {
76 raw_svector_ostream OS(OutName);
77 char Prefix = DL.getGlobalPrefix();
78 return getNameWithPrefixImpl(OS, GVName, Default, DL, Prefix);
79}
80
82 switch (CC) {
86 return true;
87 default:
88 return false;
89 }
90}
91
92/// Microsoft fastcall and stdcall functions require a suffix on their name
93/// indicating the number of words of arguments they take.
94static void addByteCountSuffix(raw_ostream &OS, const Function *F,
95 const DataLayout &DL) {
96 // Calculate arguments size total.
97 unsigned ArgWords = 0;
98
99 const unsigned PtrSize = DL.getPointerSize();
100
101 for (const Argument &A : F->args()) {
102 // For the purposes of the byte count suffix, structs returned by pointer
103 // do not count as function arguments.
104 if (A.hasStructRetAttr())
105 continue;
106
107 // 'Dereference' type in case of byval or inalloca parameter attribute.
108 uint64_t AllocSize = A.hasPassPointeeByValueCopyAttr() ?
109 A.getPassPointeeByValueCopySize(DL) :
110 DL.getTypeAllocSize(A.getType());
111
112 // Size should be aligned to pointer size.
113 ArgWords += alignTo(AllocSize, PtrSize);
114 }
115
116 OS << '@' << ArgWords;
117}
118
120 bool CannotUsePrivateLabel) const {
121 ManglerPrefixTy PrefixTy = Default;
122 if (GV->hasPrivateLinkage()) {
123 if (CannotUsePrivateLabel)
124 PrefixTy = LinkerPrivate;
125 else
126 PrefixTy = Private;
127 }
128
129 const DataLayout &DL = GV->getParent()->getDataLayout();
130 if (!GV->hasName()) {
131 // Get the ID for the global, assigning a new one if we haven't got one
132 // already.
133 unsigned &ID = AnonGlobalIDs[GV];
134 if (ID == 0)
135 ID = AnonGlobalIDs.size();
136
137 // Must mangle the global into a unique ID.
138 getNameWithPrefixImpl(OS, "__unnamed_" + Twine(ID), DL, PrefixTy);
139 return;
140 }
141
142 StringRef Name = GV->getName();
143 char Prefix = DL.getGlobalPrefix();
144
145 // Mangle functions with Microsoft calling conventions specially. Only do
146 // this mangling for x86_64 vectorcall and 32-bit x86.
147 const Function *MSFunc = dyn_cast_or_null<Function>(GV->getAliaseeObject());
148
149 // Don't add byte count suffixes when '\01' or '?' are in the first
150 // character.
151 if (Name.startswith("\01") ||
152 (DL.doNotMangleLeadingQuestionMark() && Name.startswith("?")))
153 MSFunc = nullptr;
154
156 MSFunc ? MSFunc->getCallingConv() : (unsigned)CallingConv::C;
157 if (!DL.hasMicrosoftFastStdCallMangling() &&
159 MSFunc = nullptr;
160 if (MSFunc) {
162 Prefix = '@'; // fastcall functions have an @ prefix instead of _.
164 Prefix = '\0'; // vectorcall functions have no prefix.
165 }
166
167 getNameWithPrefixImpl(OS, Name, PrefixTy, DL, Prefix);
168
169 if (!MSFunc)
170 return;
171
172 // If we are supposed to add a microsoft-style suffix for stdcall, fastcall,
173 // or vectorcall, add it. These functions have a suffix of @N where N is the
174 // cumulative byte size of all of the parameters to the function in decimal.
176 OS << '@'; // vectorcall functions use a double @ suffix.
177 FunctionType *FT = MSFunc->getFunctionType();
178 if (hasByteCountSuffix(CC) &&
179 // "Pure" variadic functions do not receive @0 suffix.
180 (!FT->isVarArg() || FT->getNumParams() == 0 ||
181 (FT->getNumParams() == 1 && MSFunc->hasStructRetAttr())))
182 addByteCountSuffix(OS, MSFunc, DL);
183}
184
186 const GlobalValue *GV,
187 bool CannotUsePrivateLabel) const {
188 raw_svector_ostream OS(OutName);
189 getNameWithPrefix(OS, GV, CannotUsePrivateLabel);
190}
191
192// Check if the name needs quotes to be safe for the linker to interpret.
193static bool canBeUnquotedInDirective(char C) {
194 return isAlnum(C) || C == '_' || C == '@';
195}
196
198 if (Name.empty())
199 return false;
200
201 // If any of the characters in the string is an unacceptable character, force
202 // quotes.
203 for (char C : Name) {
205 return false;
206 }
207
208 return true;
209}
210
212 const Triple &TT, Mangler &Mangler) {
213 if (GV->hasDLLExportStorageClass() && !GV->isDeclaration()) {
214
215 if (TT.isWindowsMSVCEnvironment())
216 OS << " /EXPORT:";
217 else
218 OS << " -export:";
219
220 bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
221 if (NeedQuotes)
222 OS << "\"";
223 if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
224 std::string Flag;
225 raw_string_ostream FlagOS(Flag);
226 Mangler.getNameWithPrefix(FlagOS, GV, false);
227 FlagOS.flush();
228 if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
229 OS << Flag.substr(1);
230 else
231 OS << Flag;
232 } else {
233 Mangler.getNameWithPrefix(OS, GV, false);
234 }
235 if (NeedQuotes)
236 OS << "\"";
237
238 if (!GV->getValueType()->isFunctionTy()) {
239 if (TT.isWindowsMSVCEnvironment())
240 OS << ",DATA";
241 else
242 OS << ",data";
243 }
244 }
245 if (GV->hasHiddenVisibility() && !GV->isDeclaration() && TT.isOSCygMing()) {
246
247 OS << " -exclude-symbols:";
248
249 bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
250 if (NeedQuotes)
251 OS << "\"";
252
253 std::string Flag;
254 raw_string_ostream FlagOS(Flag);
255 Mangler.getNameWithPrefix(FlagOS, GV, false);
256 FlagOS.flush();
257 if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
258 OS << Flag.substr(1);
259 else
260 OS << Flag;
261
262 if (NeedQuotes)
263 OS << "\"";
264 }
265}
266
268 const Triple &T, Mangler &M) {
269 if (!T.isWindowsMSVCEnvironment())
270 return;
271
272 OS << " /INCLUDE:";
273 bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
274 if (NeedQuotes)
275 OS << "\"";
276 M.getNameWithPrefix(OS, GV, false);
277 if (NeedQuotes)
278 OS << "\"";
279}
280
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This header is deprecated in favour of llvm/TargetParser/Triple.h.
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
@ Default
Definition: DwarfDebug.cpp:86
std::string Name
#define F(x, y, z)
Definition: MD5.cpp:55
static bool canBeUnquotedInDirective(char C)
Definition: Mangler.cpp:193
static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName, ManglerPrefixTy PrefixTy, const DataLayout &DL, char Prefix)
Definition: Mangler.cpp:33
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:94
static bool hasByteCountSuffix(CallingConv::ID CC)
Definition: Mangler.cpp:81
Module.h This file contains the declarations for the Module class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file contains some functions that are useful when dealing with strings.
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:114
char getGlobalPrefix() const
Definition: DataLayout.h:319
Class to represent function types.
Definition: DerivedTypes.h:103
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
bool isVarArg() const
Definition: DerivedTypes.h:123
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:174
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:237
bool hasStructRetAttr() const
Determine if the function returns a structure through first or second pointer argument.
Definition: Function.h:625
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:275
bool hasPrivateLinkage() const
Definition: GlobalValue.h:522
bool hasHiddenVisibility() const
Definition: GlobalValue.h:246
bool hasDLLExportStorageClass() const
Definition: GlobalValue.h:277
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:369
Type * getValueType() const
Definition: GlobalValue.h:292
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:119
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
Definition: SmallString.h:26
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:577
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:473
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:240
bool hasName() const
Definition: Value.h:261
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:642
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:672
@ X86_StdCall
stdcall is mostly used by the Win32 API.
Definition: CallingConv.h:96
@ X86_VectorCall
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:160
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
@ X86_FastCall
'fast' analog of X86_StdCall.
Definition: CallingConv.h:100
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)
Definition: Mangler.cpp:267
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:155
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:211
@ Default
The result values are uniform if and only if all operands are uniform.