LLVM  14.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"
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/StringExtras.h"
16 #include "llvm/ADT/Triple.h"
17 #include "llvm/ADT/Twine.h"
18 #include "llvm/IR/DataLayout.h"
19 #include "llvm/IR/DerivedTypes.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/Module.h"
23 using namespace llvm;
24 
25 namespace {
26 enum 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 
33 static 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 
62 static 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.
94 static 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<Function>(GV);
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 
155  CallingConv::ID CC =
156  MSFunc ? MSFunc->getCallingConv() : (unsigned)CallingConv::C;
157  if (!DL.hasMicrosoftFastStdCallMangling() &&
159  MSFunc = nullptr;
160  if (MSFunc) {
161  if (CC == CallingConv::X86_FastCall)
162  Prefix = '@'; // fastcall functions have an @ prefix instead of _.
163  else if (CC == CallingConv::X86_VectorCall)
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.
175  if (CC == CallingConv::X86_VectorCall)
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.
193 static 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  return;
215 
216  if (TT.isWindowsMSVCEnvironment())
217  OS << " /EXPORT:";
218  else
219  OS << " -export:";
220 
221  bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
222  if (NeedQuotes)
223  OS << "\"";
224  if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
225  std::string Flag;
226  raw_string_ostream FlagOS(Flag);
227  Mangler.getNameWithPrefix(FlagOS, GV, false);
228  FlagOS.flush();
229  if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
230  OS << Flag.substr(1);
231  else
232  OS << Flag;
233  } else {
234  Mangler.getNameWithPrefix(OS, GV, false);
235  }
236  if (NeedQuotes)
237  OS << "\"";
238 
239  if (!GV->getValueType()->isFunctionTy()) {
240  if (TT.isWindowsMSVCEnvironment())
241  OS << ",DATA";
242  else
243  OS << ",data";
244  }
245 }
246 
248  const Triple &T, Mangler &M) {
249  if (!T.isWindowsMSVCEnvironment())
250  return;
251 
252  OS << " /INCLUDE:";
253  bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
254  if (NeedQuotes)
255  OS << "\"";
256  M.getNameWithPrefix(OS, GV, false);
257  if (NeedQuotes)
258  OS << "\"";
259 }
260 
llvm::alignTo
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition: Alignment.h:148
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:29
llvm
This file implements support for optimizing divisions by a constant.
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
T
llvm::Function
Definition: Function.h:62
llvm::raw_string_ostream
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:625
llvm::Value::hasName
bool hasName() const
Definition: Value.h:261
llvm::Triple
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:45
Module.h
llvm::FunctionType::getNumParams
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
llvm::CallingConv::X86_VectorCall
@ X86_VectorCall
MSVC calling convention that passes vectors and vector aggregates in SSE registers.
Definition: CallingConv.h:173
llvm::Mangler
Definition: Mangler.h:27
llvm::CallingConv::X86_FastCall
@ X86_FastCall
X86_FastCall - 'fast' analog of X86_StdCall.
Definition: CallingConv.h:107
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::FunctionType::isVarArg
bool isVarArg() const
Definition: DerivedTypes.h:123
llvm::codeview::MemberAccess::Private
@ Private
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:228
hasByteCountSuffix
static bool hasByteCountSuffix(CallingConv::ID CC)
Definition: Mangler.cpp:81
SmallString.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
Twine.h
canBeUnquotedInDirective
static bool canBeUnquotedInDirective(char C)
Definition: Mangler.cpp:193
llvm::GlobalValue::hasPrivateLinkage
bool hasPrivateLinkage() const
Definition: GlobalValue.h:450
llvm::Mangler::getNameWithPrefix
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
llvm::MCID::Flag
Flag
These should be considered private to the implementation of the MCInstrDesc class.
Definition: MCInstrDesc.h:146
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:186
llvm::Type::isFunctionTy
bool isFunctionTy() const
True if this is an instance of FunctionType.
Definition: Type.h:208
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
llvm::SmallString< 256 >
llvm::GlobalValue
Definition: GlobalValue.h:44
uint64_t
llvm::Function::getCallingConv
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:240
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:578
StringExtras.h
llvm::Function::hasStructRetAttr
bool hasStructRetAttr() const
Determine if the function returns a structure through first or second pointer argument.
Definition: Function.h:653
llvm::DataLayout::getGlobalPrefix
char getGlobalPrefix() const
Definition: DataLayout.h:317
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
addByteCountSuffix
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
Mangler.h
Triple.h
DataLayout.h
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::emitLinkerFlagsForUsedCOFF
void emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &T, Mangler &M)
Definition: Mangler.cpp:247
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
getNameWithPrefixImpl
static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName, ManglerPrefixTy PrefixTy, const DataLayout &DL, char Prefix)
Definition: Mangler.cpp:33
llvm::CallingConv::X86_StdCall
@ X86_StdCall
X86_StdCall - stdcall is the calling conventions mostly used by the Win32 API.
Definition: CallingConv.h:102
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::GlobalValue::hasDLLExportStorageClass
bool hasDLLExportStorageClass() const
Definition: GlobalValue.h:262
Function.h
llvm::TargetStackID::Default
@ Default
Definition: TargetFrameLowering.h:28
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:177
llvm::emitLinkerFlagsForGlobalCOFF
void emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV, const Triple &TT, Mangler &Mangler)
Definition: Mangler.cpp:211
llvm::raw_svector_ostream
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:658
llvm::SmallVectorImpl< char >
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:401
DerivedTypes.h
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:273
llvm::Twine::toStringRef
StringRef toStringRef(SmallVectorImpl< char > &Out) const
This returns the twine as a single StringRef if it can be represented as such.
Definition: Twine.h:477
llvm::CallingConv::C
@ C
C - The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
raw_ostream.h
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:37