1//===-- Module.cpp - Implement the Module class ---------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the Module class for the IR library.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/IR/Module.h"
15#include "SymbolTableListTraitsImpl.h"
16#include "llvm/ADT/DenseSet.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/SmallString.h"
19#include "llvm/ADT/StringExtras.h"
20#include "llvm/IR/Constants.h"
21#include "llvm/IR/DerivedTypes.h"
22#include "llvm/IR/GVMaterializer.h"
23#include "llvm/IR/InstrTypes.h"
24#include "llvm/IR/LLVMContext.h"
25#include "llvm/IR/LeakDetector.h"
26#include "llvm/Support/Dwarf.h"
27#include "llvm/Support/Path.h"
28#include "llvm/Support/RandomNumberGenerator.h"
29#include <algorithm>
30#include <cstdarg>
31#include <cstdlib>
32using namespace llvm;
33
34//===----------------------------------------------------------------------===//
35// Methods to implement the globals and functions lists.
36//
37
38// Explicit instantiations of SymbolTableListTraits since some of the methods
39// are not in the public header file.
40template class llvm::SymbolTableListTraits<Function, Module>;
41template class llvm::SymbolTableListTraits<GlobalVariable, Module>;
42template class llvm::SymbolTableListTraits<GlobalAlias, Module>;
43
44//===----------------------------------------------------------------------===//
45// Primitive Module methods.
46//
47
48Module::Module(StringRef MID, LLVMContext &C)
49    : Context(C), Materializer(), ModuleID(MID), RNG(nullptr), DL("") {
50  ValSymTab = new ValueSymbolTable();
51  NamedMDSymTab = new StringMap<NamedMDNode *>();
52  Context.addModule(this);
53}
54
55Module::~Module() {
56  Context.removeModule(this);
57  dropAllReferences();
58  GlobalList.clear();
59  FunctionList.clear();
60  AliasList.clear();
61  NamedMDList.clear();
62  delete ValSymTab;
63  delete static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab);
64  delete RNG;
65}
66
67/// getNamedValue - Return the first global value in the module with
68/// the specified name, of arbitrary type.  This method returns null
69/// if a global with the specified name is not found.
70GlobalValue *Module::getNamedValue(StringRef Name) const {
71  return cast_or_null<GlobalValue>(getValueSymbolTable().lookup(Name));
72}
73
74/// getMDKindID - Return a unique non-zero ID for the specified metadata kind.
75/// This ID is uniqued across modules in the current LLVMContext.
76unsigned Module::getMDKindID(StringRef Name) const {
77  return Context.getMDKindID(Name);
78}
79
80/// getMDKindNames - Populate client supplied SmallVector with the name for
81/// custom metadata IDs registered in this LLVMContext.   ID #0 is not used,
82/// so it is filled in as an empty string.
83void Module::getMDKindNames(SmallVectorImpl<StringRef> &Result) const {
84  return Context.getMDKindNames(Result);
85}
86
87
88//===----------------------------------------------------------------------===//
89// Methods for easy access to the functions in the module.
90//
91
92// getOrInsertFunction - Look up the specified function in the module symbol
93// table.  If it does not exist, add a prototype for the function and return
94// it.  This is nice because it allows most passes to get away with not handling
95// the symbol table directly for this common task.
96//
97Constant *Module::getOrInsertFunction(StringRef Name,
98                                      FunctionType *Ty,
99                                      AttributeSet AttributeList) {
100  // See if we have a definition for the specified function already.
101  GlobalValue *F = getNamedValue(Name);
102  if (!F) {
103    // Nope, add it
104    Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
105    if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
106      New->setAttributes(AttributeList);
107    FunctionList.push_back(New);
108    return New;                    // Return the new prototype.
109  }
110
111  // If the function exists but has the wrong type, return a bitcast to the
112  // right type.
113  if (F->getType() != PointerType::getUnqual(Ty))
114    return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
115
116  // Otherwise, we just found the existing function or a prototype.
117  return F;
118}
119
120Constant *Module::getOrInsertFunction(StringRef Name,
121                                      FunctionType *Ty) {
122  return getOrInsertFunction(Name, Ty, AttributeSet());
123}
124
125// getOrInsertFunction - Look up the specified function in the module symbol
126// table.  If it does not exist, add a prototype for the function and return it.
127// This version of the method takes a null terminated list of function
128// arguments, which makes it easier for clients to use.
129//
130Constant *Module::getOrInsertFunction(StringRef Name,
131                                      AttributeSet AttributeList,
132                                      Type *RetTy, ...) {
133  va_list Args;
134  va_start(Args, RetTy);
135
136  // Build the list of argument types...
137  std::vector<Type*> ArgTys;
138  while (Type *ArgTy = va_arg(Args, Type*))
139    ArgTys.push_back(ArgTy);
140
141  va_end(Args);
142
143  // Build the function type and chain to the other getOrInsertFunction...
144  return getOrInsertFunction(Name,
145                             FunctionType::get(RetTy, ArgTys, false),
146                             AttributeList);
147}
148
149Constant *Module::getOrInsertFunction(StringRef Name,
150                                      Type *RetTy, ...) {
151  va_list Args;
152  va_start(Args, RetTy);
153
154  // Build the list of argument types...
155  std::vector<Type*> ArgTys;
156  while (Type *ArgTy = va_arg(Args, Type*))
157    ArgTys.push_back(ArgTy);
158
159  va_end(Args);
160
161  // Build the function type and chain to the other getOrInsertFunction...
162  return getOrInsertFunction(Name,
163                             FunctionType::get(RetTy, ArgTys, false),
164                             AttributeSet());
165}
166
167// getFunction - Look up the specified function in the module symbol table.
168// If it does not exist, return null.
169//
170Function *Module::getFunction(StringRef Name) const {
171  return dyn_cast_or_null<Function>(getNamedValue(Name));
172}
173
174//===----------------------------------------------------------------------===//
175// Methods for easy access to the global variables in the module.
176//
177
178/// getGlobalVariable - Look up the specified global variable in the module
179/// symbol table.  If it does not exist, return null.  The type argument
180/// should be the underlying type of the global, i.e., it should not have
181/// the top-level PointerType, which represents the address of the global.
182/// If AllowLocal is set to true, this function will return types that
183/// have an local. By default, these types are not returned.
184///
185GlobalVariable *Module::getGlobalVariable(StringRef Name, bool AllowLocal) {
186  if (GlobalVariable *Result =
187      dyn_cast_or_null<GlobalVariable>(getNamedValue(Name)))
188    if (AllowLocal || !Result->hasLocalLinkage())
189      return Result;
190  return nullptr;
191}
192
193/// getOrInsertGlobal - Look up the specified global in the module symbol table.
194///   1. If it does not exist, add a declaration of the global and return it.
195///   2. Else, the global exists but has the wrong type: return the function
196///      with a constantexpr cast to the right type.
197///   3. Finally, if the existing global is the correct declaration, return the
198///      existing global.
199Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
200  // See if we have a definition for the specified global already.
201  GlobalVariable *GV = dyn_cast_or_null<GlobalVariable>(getNamedValue(Name));
202  if (!GV) {
203    // Nope, add it
204    GlobalVariable *New =
205      new GlobalVariable(*this, Ty, false, GlobalVariable::ExternalLinkage,
206                         nullptr, Name);
207     return New;                    // Return the new declaration.
208  }
209
210  // If the variable exists but has the wrong type, return a bitcast to the
211  // right type.
212  Type *GVTy = GV->getType();
213  PointerType *PTy = PointerType::get(Ty, GVTy->getPointerAddressSpace());
214  if (GVTy != PTy)
215    return ConstantExpr::getBitCast(GV, PTy);
216
217  // Otherwise, we just found the existing function or a prototype.
218  return GV;
219}
220
221//===----------------------------------------------------------------------===//
222// Methods for easy access to the global variables in the module.
223//
224
225// getNamedAlias - Look up the specified global in the module symbol table.
226// If it does not exist, return null.
227//
228GlobalAlias *Module::getNamedAlias(StringRef Name) const {
229  return dyn_cast_or_null<GlobalAlias>(getNamedValue(Name));
230}
231
232/// getNamedMetadata - Return the first NamedMDNode in the module with the
233/// specified name. This method returns null if a NamedMDNode with the
234/// specified name is not found.
235NamedMDNode *Module::getNamedMetadata(const Twine &Name) const {
236  SmallString<256> NameData;
237  StringRef NameRef = Name.toStringRef(NameData);
238  return static_cast<StringMap<NamedMDNode*> *>(NamedMDSymTab)->lookup(NameRef);
239}
240
241/// getOrInsertNamedMetadata - Return the first named MDNode in the module
242/// with the specified name. This method returns a new NamedMDNode if a
243/// NamedMDNode with the specified name is not found.
244NamedMDNode *Module::getOrInsertNamedMetadata(StringRef Name) {
245  NamedMDNode *&NMD =
246    (*static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab))[Name];
247  if (!NMD) {
248    NMD = new NamedMDNode(Name);
249    NMD->setParent(this);
250    NamedMDList.push_back(NMD);
251  }
252  return NMD;
253}
254
255/// eraseNamedMetadata - Remove the given NamedMDNode from this module and
256/// delete it.
257void Module::eraseNamedMetadata(NamedMDNode *NMD) {
258  static_cast<StringMap<NamedMDNode *> *>(NamedMDSymTab)->erase(NMD->getName());
259  NamedMDList.erase(NMD);
260}
261
262/// getModuleFlagsMetadata - Returns the module flags in the provided vector.
263void Module::
264getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const {
265  const NamedMDNode *ModFlags = getModuleFlagsMetadata();
266  if (!ModFlags) return;
267
268  for (const MDNode *Flag : ModFlags->operands()) {
269    if (Flag->getNumOperands() >= 3 && isa<ConstantInt>(Flag->getOperand(0)) &&
270        isa<MDString>(Flag->getOperand(1))) {
271      // Check the operands of the MDNode before accessing the operands.
272      // The verifier will actually catch these failures.
273      ConstantInt *Behavior = cast<ConstantInt>(Flag->getOperand(0));
274      MDString *Key = cast<MDString>(Flag->getOperand(1));
275      Value *Val = Flag->getOperand(2);
276      Flags.push_back(ModuleFlagEntry(ModFlagBehavior(Behavior->getZExtValue()),
277                                      Key, Val));
278    }
279  }
280}
281
282/// Return the corresponding value if Key appears in module flags, otherwise
283/// return null.
284Value *Module::getModuleFlag(StringRef Key) const {
285  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
286  getModuleFlagsMetadata(ModuleFlags);
287  for (const ModuleFlagEntry &MFE : ModuleFlags) {
288    if (Key == MFE.Key->getString())
289      return MFE.Val;
290  }
291  return nullptr;
292}
293
294/// getModuleFlagsMetadata - Returns the NamedMDNode in the module that
295/// represents module-level flags. This method returns null if there are no
296/// module-level flags.
297NamedMDNode *Module::getModuleFlagsMetadata() const {
298  return getNamedMetadata("llvm.module.flags");
299}
300
301/// getOrInsertModuleFlagsMetadata - Returns the NamedMDNode in the module that
302/// represents module-level flags. If module-level flags aren't found, it
303/// creates the named metadata that contains them.
304NamedMDNode *Module::getOrInsertModuleFlagsMetadata() {
305  return getOrInsertNamedMetadata("llvm.module.flags");
306}
307
308/// addModuleFlag - Add a module-level flag to the module-level flags
309/// metadata. It will create the module-level flags named metadata if it doesn't
310/// already exist.
311void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
312                           Value *Val) {
313  Type *Int32Ty = Type::getInt32Ty(Context);
314  Value *Ops[3] = {
315    ConstantInt::get(Int32Ty, Behavior), MDString::get(Context, Key), Val
316  };
317  getOrInsertModuleFlagsMetadata()->addOperand(MDNode::get(Context, Ops));
318}
319void Module::addModuleFlag(ModFlagBehavior Behavior, StringRef Key,
320                           uint32_t Val) {
321  Type *Int32Ty = Type::getInt32Ty(Context);
322  addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
323}
324void Module::addModuleFlag(MDNode *Node) {
325  assert(Node->getNumOperands() == 3 &&
326         "Invalid number of operands for module flag!");
327  assert(isa<ConstantInt>(Node->getOperand(0)) &&
328         isa<MDString>(Node->getOperand(1)) &&
329         "Invalid operand types for module flag!");
330  getOrInsertModuleFlagsMetadata()->addOperand(Node);
331}
332
333void Module::setDataLayout(StringRef Desc) {
334  DL.reset(Desc);
335
336  if (Desc.empty()) {
337    DataLayoutStr = "";
338  } else {
339    DataLayoutStr = DL.getStringRepresentation();
340    // DataLayoutStr is now equivalent to Desc, but since the representation
341    // is not unique, they may not be identical.
342  }
343}
344
345void Module::setDataLayout(const DataLayout *Other) {
346  if (!Other) {
347    DataLayoutStr = "";
348    DL.reset("");
349  } else {
350    DL = *Other;
351    DataLayoutStr = DL.getStringRepresentation();
352  }
353}
354
355const DataLayout *Module::getDataLayout() const {
356  if (DataLayoutStr.empty())
357    return nullptr;
358  return &DL;
359}
360
361// We want reproducible builds, but ModuleID may be a full path so we just use
362// the filename to salt the RNG (although it is not guaranteed to be unique).
363RandomNumberGenerator &Module::getRNG() const {
364  if (RNG == nullptr) {
365    StringRef Salt = sys::path::filename(ModuleID);
366    RNG = new RandomNumberGenerator(Salt);
367  }
368  return *RNG;
369}
370
371//===----------------------------------------------------------------------===//
372// Methods to control the materialization of GlobalValues in the Module.
373//
374void Module::setMaterializer(GVMaterializer *GVM) {
375  assert(!Materializer &&
376         "Module already has a GVMaterializer.  Call MaterializeAllPermanently"
377         " to clear it out before setting another one.");
378  Materializer.reset(GVM);
379}
380
381bool Module::isMaterializable(const GlobalValue *GV) const {
382  if (Materializer)
383    return Materializer->isMaterializable(GV);
384  return false;
385}
386
387bool Module::isDematerializable(const GlobalValue *GV) const {
388  if (Materializer)
389    return Materializer->isDematerializable(GV);
390  return false;
391}
392
393bool Module::Materialize(GlobalValue *GV, std::string *ErrInfo) {
394  if (!Materializer)
395    return false;
396
397  std::error_code EC = Materializer->Materialize(GV);
398  if (!EC)
399    return false;
400  if (ErrInfo)
401    *ErrInfo = EC.message();
402  return true;
403}
404
405void Module::Dematerialize(GlobalValue *GV) {
406  if (Materializer)
407    return Materializer->Dematerialize(GV);
408}
409
410std::error_code Module::materializeAll() {
411  if (!Materializer)
412    return std::error_code();
413  return Materializer->MaterializeModule(this);
414}
415
416std::error_code Module::materializeAllPermanently(bool ReleaseBuffer) {
417  if (std::error_code EC = materializeAll())
418    return EC;
419
420  if (ReleaseBuffer)
421    Materializer->releaseBuffer();
422
423  Materializer.reset();
424  return std::error_code();
425}
426
427//===----------------------------------------------------------------------===//
428// Other module related stuff.
429//
430
431
432// dropAllReferences() - This function causes all the subelements to "let go"
433// of all references that they are maintaining.  This allows one to 'delete' a
434// whole module at a time, even though there may be circular references... first
435// all references are dropped, and all use counts go to zero.  Then everything
436// is deleted for real.  Note that no operations are valid on an object that
437// has "dropped all references", except operator delete.
438//
439void Module::dropAllReferences() {
440  for (Function &F : *this)
441    F.dropAllReferences();
442
443  for (GlobalVariable &GV : globals())
444    GV.dropAllReferences();
445
446  for (GlobalAlias &GA : aliases())
447    GA.dropAllReferences();
448}
449
450unsigned Module::getDwarfVersion() const {
451  Value *Val = getModuleFlag("Dwarf Version");
452  if (!Val)
453    return dwarf::DWARF_VERSION;
454  return cast<ConstantInt>(Val)->getZExtValue();
455}
456
457Comdat *Module::getOrInsertComdat(StringRef Name) {
458  Comdat C;
459  StringMapEntry<Comdat> &Entry =
460      ComdatSymTab.GetOrCreateValue(Name, std::move(C));
461  Entry.second.Name = &Entry;
462  return &Entry.second;
463}
464