LLVM 19.0.0git
Module.h
Go to the documentation of this file.
1//===- llvm/Module.h - C++ class to represent a VM module -------*- C++ -*-===//
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/// @file
10/// Module.h This file contains the declarations for the Module class.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_IR_MODULE_H
15#define LLVM_IR_MODULE_H
16
17#include "llvm-c/Types.h"
18#include "llvm/ADT/STLExtras.h"
19#include "llvm/ADT/StringMap.h"
20#include "llvm/ADT/StringRef.h"
22#include "llvm/IR/Attributes.h"
23#include "llvm/IR/Comdat.h"
24#include "llvm/IR/DataLayout.h"
25#include "llvm/IR/Function.h"
26#include "llvm/IR/GlobalAlias.h"
27#include "llvm/IR/GlobalIFunc.h"
29#include "llvm/IR/Metadata.h"
34#include <cstddef>
35#include <cstdint>
36#include <iterator>
37#include <memory>
38#include <optional>
39#include <string>
40#include <vector>
41
42namespace llvm {
43
44class Error;
45class FunctionType;
46class GVMaterializer;
47class LLVMContext;
48class MemoryBuffer;
49class ModuleSummaryIndex;
50class RandomNumberGenerator;
51class StructType;
52class VersionTuple;
53
54/// A Module instance is used to store all the information related to an
55/// LLVM module. Modules are the top level container of all other LLVM
56/// Intermediate Representation (IR) objects. Each module directly contains a
57/// list of globals variables, a list of functions, a list of libraries (or
58/// other modules) this module depends on, a symbol table, and various data
59/// about the target's characteristics.
60///
61/// A module maintains a GlobalList object that is used to hold all
62/// constant references to global variables in the module. When a global
63/// variable is destroyed, it should have no entries in the GlobalList.
64/// The main container class for the LLVM Intermediate Representation.
66 /// @name Types And Enumerations
67 /// @{
68public:
69 /// The type for the list of global variables.
71 /// The type for the list of functions.
73 /// The type for the list of aliases.
75 /// The type for the list of ifuncs.
77 /// The type for the list of named metadata.
79 /// The type of the comdat "symbol" table.
81 /// The type for mapping names to named metadata.
83
84 /// The Global Variable iterator.
86 /// The Global Variable constant iterator.
88
89 /// The Function iterators.
91 /// The Function constant iterator
93
94 /// The Function reverse iterator.
96 /// The Function constant reverse iterator.
98
99 /// The Global Alias iterators.
101 /// The Global Alias constant iterator
103
104 /// The Global IFunc iterators.
106 /// The Global IFunc constant iterator
108
109 /// The named metadata iterators.
111 /// The named metadata constant iterators.
113
114 /// This enumeration defines the supported behaviors of module flags.
116 /// Emits an error if two values disagree, otherwise the resulting value is
117 /// that of the operands.
118 Error = 1,
119
120 /// Emits a warning if two values disagree. The result value will be the
121 /// operand for the flag from the first module being linked.
122 Warning = 2,
123
124 /// Adds a requirement that another module flag be present and have a
125 /// specified value after linking is performed. The value must be a metadata
126 /// pair, where the first element of the pair is the ID of the module flag
127 /// to be restricted, and the second element of the pair is the value the
128 /// module flag should be restricted to. This behavior can be used to
129 /// restrict the allowable results (via triggering of an error) of linking
130 /// IDs with the **Override** behavior.
131 Require = 3,
132
133 /// Uses the specified value, regardless of the behavior or value of the
134 /// other module. If both modules specify **Override**, but the values
135 /// differ, an error will be emitted.
136 Override = 4,
137
138 /// Appends the two values, which are required to be metadata nodes.
139 Append = 5,
140
141 /// Appends the two values, which are required to be metadata
142 /// nodes. However, duplicate entries in the second list are dropped
143 /// during the append operation.
144 AppendUnique = 6,
145
146 /// Takes the max of the two values, which are required to be integers.
147 Max = 7,
148
149 /// Takes the min of the two values, which are required to be integers.
150 Min = 8,
151
152 // Markers:
153 ModFlagBehaviorFirstVal = Error,
154 ModFlagBehaviorLastVal = Min
155 };
156
157 /// Checks if Metadata represents a valid ModFlagBehavior, and stores the
158 /// converted result in MFB.
159 static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB);
160
161 /// Check if the given module flag metadata represents a valid module flag,
162 /// and store the flag behavior, the key string and the value metadata.
163 static bool isValidModuleFlag(const MDNode &ModFlag, ModFlagBehavior &MFB,
164 MDString *&Key, Metadata *&Val);
165
170
172 : Behavior(B), Key(K), Val(V) {}
173 };
174
175/// @}
176/// @name Member Variables
177/// @{
178private:
179 LLVMContext &Context; ///< The LLVMContext from which types and
180 ///< constants are allocated.
181 GlobalListType GlobalList; ///< The Global Variables in the module
182 FunctionListType FunctionList; ///< The Functions in the module
183 AliasListType AliasList; ///< The Aliases in the module
184 IFuncListType IFuncList; ///< The IFuncs in the module
185 NamedMDListType NamedMDList; ///< The named metadata in the module
186 std::string GlobalScopeAsm; ///< Inline Asm at global scope.
187 std::unique_ptr<ValueSymbolTable> ValSymTab; ///< Symbol table for values
188 ComdatSymTabType ComdatSymTab; ///< Symbol table for COMDATs
189 std::unique_ptr<MemoryBuffer>
190 OwnedMemoryBuffer; ///< Memory buffer directly owned by this
191 ///< module, for legacy clients only.
192 std::unique_ptr<GVMaterializer>
193 Materializer; ///< Used to materialize GlobalValues
194 std::string ModuleID; ///< Human readable identifier for the module
195 std::string SourceFileName; ///< Original source file name for module,
196 ///< recorded in bitcode.
197 std::string TargetTriple; ///< Platform target triple Module compiled on
198 ///< Format: (arch)(sub)-(vendor)-(sys0-(abi)
199 NamedMDSymTabType NamedMDSymTab; ///< NamedMDNode names.
200 DataLayout DL; ///< DataLayout associated with the module
202 CurrentIntrinsicIds; ///< Keep track of the current unique id count for
203 ///< the specified intrinsic basename.
205 UniquedIntrinsicNames; ///< Keep track of uniqued names of intrinsics
206 ///< based on unnamed types. The combination of
207 ///< ID and FunctionType maps to the extension that
208 ///< is used to make the intrinsic name unique.
209
210 friend class Constant;
211
212/// @}
213/// @name Constructors
214/// @{
215public:
216 /// Is this Module using intrinsics to record the position of debugging
217 /// information, or non-intrinsic records? See IsNewDbgInfoFormat in
218 /// \ref BasicBlock.
220
221 /// Used when printing this module in the new debug info format; removes all
222 /// declarations of debug intrinsics that are replaced by non-intrinsic
223 /// records in the new format.
224 void removeDebugIntrinsicDeclarations();
225
226 /// \see BasicBlock::convertToNewDbgValues.
228 for (auto &F : *this) {
229 F.convertToNewDbgValues();
230 }
231 IsNewDbgInfoFormat = true;
232 }
233
234 /// \see BasicBlock::convertFromNewDbgValues.
236 for (auto &F : *this) {
237 F.convertFromNewDbgValues();
238 }
239 IsNewDbgInfoFormat = false;
240 }
241
242 void setIsNewDbgInfoFormat(bool UseNewFormat) {
243 if (UseNewFormat && !IsNewDbgInfoFormat)
244 convertToNewDbgValues();
245 else if (!UseNewFormat && IsNewDbgInfoFormat)
246 convertFromNewDbgValues();
247 }
248
249 /// The Module constructor. Note that there is no default constructor. You
250 /// must provide a name for the module upon construction.
251 explicit Module(StringRef ModuleID, LLVMContext& C);
252 /// The module destructor. This will dropAllReferences.
253 ~Module();
254
255/// @}
256/// @name Module Level Accessors
257/// @{
258
259 /// Get the module identifier which is, essentially, the name of the module.
260 /// @returns the module identifier as a string
261 const std::string &getModuleIdentifier() const { return ModuleID; }
262
263 /// Returns the number of non-debug IR instructions in the module.
264 /// This is equivalent to the sum of the IR instruction counts of each
265 /// function contained in the module.
266 unsigned getInstructionCount() const;
267
268 /// Get the module's original source file name. When compiling from
269 /// bitcode, this is taken from a bitcode record where it was recorded.
270 /// For other compiles it is the same as the ModuleID, which would
271 /// contain the source file name.
272 const std::string &getSourceFileName() const { return SourceFileName; }
273
274 /// Get a short "name" for the module.
275 ///
276 /// This is useful for debugging or logging. It is essentially a convenience
277 /// wrapper around getModuleIdentifier().
278 StringRef getName() const { return ModuleID; }
279
280 /// Get the data layout string for the module's target platform. This is
281 /// equivalent to getDataLayout()->getStringRepresentation().
282 const std::string &getDataLayoutStr() const {
283 return DL.getStringRepresentation();
284 }
285
286 /// Get the data layout for the module's target platform.
287 const DataLayout &getDataLayout() const { return DL; }
288
289 /// Get the target triple which is a string describing the target host.
290 /// @returns a string containing the target triple.
291 const std::string &getTargetTriple() const { return TargetTriple; }
292
293 /// Get the global data context.
294 /// @returns LLVMContext - a container for LLVM's global information
295 LLVMContext &getContext() const { return Context; }
296
297 /// Get any module-scope inline assembly blocks.
298 /// @returns a string containing the module-scope inline assembly blocks.
299 const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; }
300
301 /// Get a RandomNumberGenerator salted for use with this module. The
302 /// RNG can be seeded via -rng-seed=<uint64> and is salted with the
303 /// ModuleID and the provided pass salt. The returned RNG should not
304 /// be shared across threads or passes.
305 ///
306 /// A unique RNG per pass ensures a reproducible random stream even
307 /// when other randomness consuming passes are added or removed. In
308 /// addition, the random stream will be reproducible across LLVM
309 /// versions when the pass does not change.
310 std::unique_ptr<RandomNumberGenerator> createRNG(const StringRef Name) const;
311
312 /// Return true if size-info optimization remark is enabled, false
313 /// otherwise.
315 return getContext().getDiagHandlerPtr()->isAnalysisRemarkEnabled(
316 "size-info");
317 }
318
319 /// @}
320 /// @name Module Level Mutators
321 /// @{
322
323 /// Set the module identifier.
324 void setModuleIdentifier(StringRef ID) { ModuleID = std::string(ID); }
325
326 /// Set the module's original source file name.
327 void setSourceFileName(StringRef Name) { SourceFileName = std::string(Name); }
328
329 /// Set the data layout
330 void setDataLayout(StringRef Desc);
331 void setDataLayout(const DataLayout &Other);
332
333 /// Set the target triple.
334 void setTargetTriple(StringRef T) { TargetTriple = std::string(T); }
335
336 /// Set the module-scope inline assembly blocks.
337 /// A trailing newline is added if the input doesn't have one.
339 GlobalScopeAsm = std::string(Asm);
340 if (!GlobalScopeAsm.empty() && GlobalScopeAsm.back() != '\n')
341 GlobalScopeAsm += '\n';
342 }
343
344 /// Append to the module-scope inline assembly blocks.
345 /// A trailing newline is added if the input doesn't have one.
347 GlobalScopeAsm += Asm;
348 if (!GlobalScopeAsm.empty() && GlobalScopeAsm.back() != '\n')
349 GlobalScopeAsm += '\n';
350 }
351
352/// @}
353/// @name Generic Value Accessors
354/// @{
355
356 /// Return the global value in the module with the specified name, of
357 /// arbitrary type. This method returns null if a global with the specified
358 /// name is not found.
359 GlobalValue *getNamedValue(StringRef Name) const;
360
361 /// Return the number of global values in the module.
362 unsigned getNumNamedValues() const;
363
364 /// Return a unique non-zero ID for the specified metadata kind. This ID is
365 /// uniqued across modules in the current LLVMContext.
366 unsigned getMDKindID(StringRef Name) const;
367
368 /// Populate client supplied SmallVector with the name for custom metadata IDs
369 /// registered in this LLVMContext.
370 void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
371
372 /// Populate client supplied SmallVector with the bundle tags registered in
373 /// this LLVMContext. The bundle tags are ordered by increasing bundle IDs.
374 /// \see LLVMContext::getOperandBundleTagID
375 void getOperandBundleTags(SmallVectorImpl<StringRef> &Result) const;
376
377 std::vector<StructType *> getIdentifiedStructTypes() const;
378
379 /// Return a unique name for an intrinsic whose mangling is based on an
380 /// unnamed type. The Proto represents the function prototype.
381 std::string getUniqueIntrinsicName(StringRef BaseName, Intrinsic::ID Id,
382 const FunctionType *Proto);
383
384/// @}
385/// @name Function Accessors
386/// @{
387
388 /// Look up the specified function in the module symbol table. If it does not
389 /// exist, add a prototype for the function and return it. Otherwise, return
390 /// the existing function.
391 ///
392 /// In all cases, the returned value is a FunctionCallee wrapper around the
393 /// 'FunctionType *T' passed in, as well as the 'Value*' of the Function. The
394 /// function type of the function may differ from the function type stored in
395 /// FunctionCallee if it was previously created with a different type.
396 ///
397 /// Note: For library calls getOrInsertLibFunc() should be used instead.
398 FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T,
400
401 FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T);
402
403 /// Same as above, but takes a list of function arguments, which makes it
404 /// easier for clients to use.
405 template <typename... ArgsTy>
408 ArgsTy... Args) {
409 SmallVector<Type*, sizeof...(ArgsTy)> ArgTys{Args...};
410 return getOrInsertFunction(Name,
411 FunctionType::get(RetTy, ArgTys, false),
413 }
414
415 /// Same as above, but without the attributes.
416 template <typename... ArgsTy>
418 ArgsTy... Args) {
419 return getOrInsertFunction(Name, AttributeList{}, RetTy, Args...);
420 }
421
422 // Avoid an incorrect ordering that'd otherwise compile incorrectly.
423 template <typename... ArgsTy>
426 FunctionType *Invalid, ArgsTy... Args) = delete;
427
428 /// Look up the specified function in the module symbol table. If it does not
429 /// exist, return null.
431
432/// @}
433/// @name Global Variable Accessors
434/// @{
435
436 /// Look up the specified global variable in the module symbol table. If it
437 /// does not exist, return null. If AllowInternal is set to true, this
438 /// function will return types that have InternalLinkage. By default, these
439 /// types are not returned.
441 return getGlobalVariable(Name, false);
442 }
443
444 GlobalVariable *getGlobalVariable(StringRef Name, bool AllowInternal) const;
445
447 bool AllowInternal = false) {
448 return static_cast<const Module *>(this)->getGlobalVariable(Name,
449 AllowInternal);
450 }
451
452 /// Return the global variable in the module with the specified name, of
453 /// arbitrary type. This method returns null if a global with the specified
454 /// name is not found.
456 return getGlobalVariable(Name, true);
457 }
459 return const_cast<GlobalVariable *>(
460 static_cast<const Module *>(this)->getNamedGlobal(Name));
461 }
462
463 /// Look up the specified global in the module symbol table.
464 /// If it does not exist, invoke a callback to create a declaration of the
465 /// global and return it. The global is constantexpr casted to the expected
466 /// type if necessary.
467 Constant *
469 function_ref<GlobalVariable *()> CreateGlobalCallback);
470
471 /// Look up the specified global in the module symbol table. If required, this
472 /// overload constructs the global variable using its constructor's defaults.
474
475/// @}
476/// @name Global Alias Accessors
477/// @{
478
479 /// Return the global alias in the module with the specified name, of
480 /// arbitrary type. This method returns null if a global with the specified
481 /// name is not found.
482 GlobalAlias *getNamedAlias(StringRef Name) const;
483
484/// @}
485/// @name Global IFunc Accessors
486/// @{
487
488 /// Return the global ifunc in the module with the specified name, of
489 /// arbitrary type. This method returns null if a global with the specified
490 /// name is not found.
491 GlobalIFunc *getNamedIFunc(StringRef Name) const;
492
493/// @}
494/// @name Named Metadata Accessors
495/// @{
496
497 /// Return the first NamedMDNode in the module with the specified name. This
498 /// method returns null if a NamedMDNode with the specified name is not found.
499 NamedMDNode *getNamedMetadata(const Twine &Name) const;
500
501 /// Return the named MDNode in the module with the specified name. This method
502 /// returns a new NamedMDNode if a NamedMDNode with the specified name is not
503 /// found.
504 NamedMDNode *getOrInsertNamedMetadata(StringRef Name);
505
506 /// Remove the given NamedMDNode from this module and delete it.
507 void eraseNamedMetadata(NamedMDNode *NMD);
508
509/// @}
510/// @name Comdat Accessors
511/// @{
512
513 /// Return the Comdat in the module with the specified name. It is created
514 /// if it didn't already exist.
515 Comdat *getOrInsertComdat(StringRef Name);
516
517/// @}
518/// @name Module Flags Accessors
519/// @{
520
521 /// Returns the module flags in the provided vector.
522 void getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const;
523
524 /// Return the corresponding value if Key appears in module flags, otherwise
525 /// return null.
526 Metadata *getModuleFlag(StringRef Key) const;
527
528 /// Returns the NamedMDNode in the module that represents module-level flags.
529 /// This method returns null if there are no module-level flags.
530 NamedMDNode *getModuleFlagsMetadata() const;
531
532 /// Returns the NamedMDNode in the module that represents module-level flags.
533 /// If module-level flags aren't found, it creates the named metadata that
534 /// contains them.
535 NamedMDNode *getOrInsertModuleFlagsMetadata();
536
537 /// Add a module-level flag to the module-level flags metadata. It will create
538 /// the module-level flags named metadata if it doesn't already exist.
539 void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val);
540 void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Constant *Val);
541 void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, uint32_t Val);
542 void addModuleFlag(MDNode *Node);
543 /// Like addModuleFlag but replaces the old module flag if it already exists.
544 void setModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val);
545
546 /// @}
547 /// @name Materialization
548 /// @{
549
550 /// Sets the GVMaterializer to GVM. This module must not yet have a
551 /// Materializer. To reset the materializer for a module that already has one,
552 /// call materializeAll first. Destroying this module will destroy
553 /// its materializer without materializing any more GlobalValues. Without
554 /// destroying the Module, there is no way to detach or destroy a materializer
555 /// without materializing all the GVs it controls, to avoid leaving orphan
556 /// unmaterialized GVs.
557 void setMaterializer(GVMaterializer *GVM);
558 /// Retrieves the GVMaterializer, if any, for this Module.
559 GVMaterializer *getMaterializer() const { return Materializer.get(); }
560 bool isMaterialized() const { return !getMaterializer(); }
561
562 /// Make sure the GlobalValue is fully read.
563 llvm::Error materialize(GlobalValue *GV);
564
565 /// Make sure all GlobalValues in this Module are fully read and clear the
566 /// Materializer.
567 llvm::Error materializeAll();
568
569 llvm::Error materializeMetadata();
570
571 /// Detach global variable \p GV from the list but don't delete it.
572 void removeGlobalVariable(GlobalVariable *GV) { GlobalList.remove(GV); }
573 /// Remove global variable \p GV from the list and delete it.
574 void eraseGlobalVariable(GlobalVariable *GV) { GlobalList.erase(GV); }
575 /// Insert global variable \p GV at the end of the global variable list and
576 /// take ownership.
578 insertGlobalVariable(GlobalList.end(), GV);
579 }
580 /// Insert global variable \p GV into the global variable list before \p
581 /// Where and take ownership.
583 GlobalList.insert(Where, GV);
584 }
585 // Use global_size() to get the total number of global variables.
586 // Use globals() to get the range of all global variables.
587
588private:
589/// @}
590/// @name Direct access to the globals list, functions list, and symbol table
591/// @{
592
593 /// Get the Module's list of global variables (constant).
594 const GlobalListType &getGlobalList() const { return GlobalList; }
595 /// Get the Module's list of global variables.
596 GlobalListType &getGlobalList() { return GlobalList; }
597
598 static GlobalListType Module::*getSublistAccess(GlobalVariable*) {
599 return &Module::GlobalList;
600 }
602
603public:
604 /// Get the Module's list of functions (constant).
605 const FunctionListType &getFunctionList() const { return FunctionList; }
606 /// Get the Module's list of functions.
607 FunctionListType &getFunctionList() { return FunctionList; }
609 return &Module::FunctionList;
610 }
611
612 /// Detach \p Alias from the list but don't delete it.
613 void removeAlias(GlobalAlias *Alias) { AliasList.remove(Alias); }
614 /// Remove \p Alias from the list and delete it.
615 void eraseAlias(GlobalAlias *Alias) { AliasList.erase(Alias); }
616 /// Insert \p Alias at the end of the alias list and take ownership.
617 void insertAlias(GlobalAlias *Alias) { AliasList.insert(AliasList.end(), Alias); }
618 // Use alias_size() to get the size of AliasList.
619 // Use aliases() to get a range of all Alias objects in AliasList.
620
621 /// Detach \p IFunc from the list but don't delete it.
622 void removeIFunc(GlobalIFunc *IFunc) { IFuncList.remove(IFunc); }
623 /// Remove \p IFunc from the list and delete it.
624 void eraseIFunc(GlobalIFunc *IFunc) { IFuncList.erase(IFunc); }
625 /// Insert \p IFunc at the end of the alias list and take ownership.
626 void insertIFunc(GlobalIFunc *IFunc) { IFuncList.push_back(IFunc); }
627 // Use ifunc_size() to get the number of functions in IFuncList.
628 // Use ifuncs() to get the range of all IFuncs.
629
630 /// Detach \p MDNode from the list but don't delete it.
631 void removeNamedMDNode(NamedMDNode *MDNode) { NamedMDList.remove(MDNode); }
632 /// Remove \p MDNode from the list and delete it.
633 void eraseNamedMDNode(NamedMDNode *MDNode) { NamedMDList.erase(MDNode); }
634 /// Insert \p MDNode at the end of the alias list and take ownership.
636 NamedMDList.push_back(MDNode);
637 }
638 // Use named_metadata_size() to get the size of the named meatadata list.
639 // Use named_metadata() to get the range of all named metadata.
640
641private: // Please use functions like insertAlias(), removeAlias() etc.
642 /// Get the Module's list of aliases (constant).
643 const AliasListType &getAliasList() const { return AliasList; }
644 /// Get the Module's list of aliases.
645 AliasListType &getAliasList() { return AliasList; }
646
647 static AliasListType Module::*getSublistAccess(GlobalAlias*) {
648 return &Module::AliasList;
649 }
651
652 /// Get the Module's list of ifuncs (constant).
653 const IFuncListType &getIFuncList() const { return IFuncList; }
654 /// Get the Module's list of ifuncs.
655 IFuncListType &getIFuncList() { return IFuncList; }
656
657 static IFuncListType Module::*getSublistAccess(GlobalIFunc*) {
658 return &Module::IFuncList;
659 }
661
662 /// Get the Module's list of named metadata (constant).
663 const NamedMDListType &getNamedMDList() const { return NamedMDList; }
664 /// Get the Module's list of named metadata.
665 NamedMDListType &getNamedMDList() { return NamedMDList; }
666
667 static NamedMDListType Module::*getSublistAccess(NamedMDNode*) {
668 return &Module::NamedMDList;
669 }
670
671public:
672 /// Get the symbol table of global variable and function identifiers
673 const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
674 /// Get the Module's symbol table of global variable and function identifiers.
675 ValueSymbolTable &getValueSymbolTable() { return *ValSymTab; }
676
677 /// Get the Module's symbol table for COMDATs (constant).
678 const ComdatSymTabType &getComdatSymbolTable() const { return ComdatSymTab; }
679 /// Get the Module's symbol table for COMDATs.
680 ComdatSymTabType &getComdatSymbolTable() { return ComdatSymTab; }
681
682/// @}
683/// @name Global Variable Iteration
684/// @{
685
686 global_iterator global_begin() { return GlobalList.begin(); }
687 const_global_iterator global_begin() const { return GlobalList.begin(); }
688 global_iterator global_end () { return GlobalList.end(); }
689 const_global_iterator global_end () const { return GlobalList.end(); }
690 size_t global_size () const { return GlobalList.size(); }
691 bool global_empty() const { return GlobalList.empty(); }
692
694 return make_range(global_begin(), global_end());
695 }
697 return make_range(global_begin(), global_end());
698 }
699
700/// @}
701/// @name Function Iteration
702/// @{
703
704 iterator begin() { return FunctionList.begin(); }
705 const_iterator begin() const { return FunctionList.begin(); }
706 iterator end () { return FunctionList.end(); }
707 const_iterator end () const { return FunctionList.end(); }
708 reverse_iterator rbegin() { return FunctionList.rbegin(); }
709 const_reverse_iterator rbegin() const{ return FunctionList.rbegin(); }
710 reverse_iterator rend() { return FunctionList.rend(); }
711 const_reverse_iterator rend() const { return FunctionList.rend(); }
712 size_t size() const { return FunctionList.size(); }
713 bool empty() const { return FunctionList.empty(); }
714
716 return make_range(begin(), end());
717 }
719 return make_range(begin(), end());
720 }
721
722/// @}
723/// @name Alias Iteration
724/// @{
725
726 alias_iterator alias_begin() { return AliasList.begin(); }
727 const_alias_iterator alias_begin() const { return AliasList.begin(); }
728 alias_iterator alias_end () { return AliasList.end(); }
729 const_alias_iterator alias_end () const { return AliasList.end(); }
730 size_t alias_size () const { return AliasList.size(); }
731 bool alias_empty() const { return AliasList.empty(); }
732
734 return make_range(alias_begin(), alias_end());
735 }
737 return make_range(alias_begin(), alias_end());
738 }
739
740/// @}
741/// @name IFunc Iteration
742/// @{
743
744 ifunc_iterator ifunc_begin() { return IFuncList.begin(); }
745 const_ifunc_iterator ifunc_begin() const { return IFuncList.begin(); }
746 ifunc_iterator ifunc_end () { return IFuncList.end(); }
747 const_ifunc_iterator ifunc_end () const { return IFuncList.end(); }
748 size_t ifunc_size () const { return IFuncList.size(); }
749 bool ifunc_empty() const { return IFuncList.empty(); }
750
752 return make_range(ifunc_begin(), ifunc_end());
753 }
755 return make_range(ifunc_begin(), ifunc_end());
756 }
757
758 /// @}
759 /// @name Convenience iterators
760 /// @{
761
767
770
777
780
781 /// @}
782 /// @name Named Metadata Iteration
783 /// @{
784
785 named_metadata_iterator named_metadata_begin() { return NamedMDList.begin(); }
787 return NamedMDList.begin();
788 }
789
790 named_metadata_iterator named_metadata_end() { return NamedMDList.end(); }
792 return NamedMDList.end();
793 }
794
795 size_t named_metadata_size() const { return NamedMDList.size(); }
796 bool named_metadata_empty() const { return NamedMDList.empty(); }
797
799 return make_range(named_metadata_begin(), named_metadata_end());
800 }
802 return make_range(named_metadata_begin(), named_metadata_end());
803 }
804
805 /// An iterator for DICompileUnits that skips those marked NoDebug.
807 NamedMDNode *CUs;
808 unsigned Idx;
809
810 void SkipNoDebugCUs();
811
812 public:
813 using iterator_category = std::input_iterator_tag;
815 using difference_type = std::ptrdiff_t;
818
820 : CUs(CUs), Idx(Idx) {
821 SkipNoDebugCUs();
822 }
823
825 ++Idx;
826 SkipNoDebugCUs();
827 return *this;
828 }
829
832 ++Idx;
833 return T;
834 }
835
837 return Idx == I.Idx;
838 }
839
841 return Idx != I.Idx;
842 }
843
844 DICompileUnit *operator*() const;
845 DICompileUnit *operator->() const;
846 };
847
849 auto *CUs = getNamedMetadata("llvm.dbg.cu");
850 return debug_compile_units_iterator(CUs, 0);
851 }
852
854 auto *CUs = getNamedMetadata("llvm.dbg.cu");
855 return debug_compile_units_iterator(CUs, CUs ? CUs->getNumOperands() : 0);
856 }
857
858 /// Return an iterator for all DICompileUnits listed in this Module's
859 /// llvm.dbg.cu named metadata node and aren't explicitly marked as
860 /// NoDebug.
862 auto *CUs = getNamedMetadata("llvm.dbg.cu");
863 return make_range(
865 debug_compile_units_iterator(CUs, CUs ? CUs->getNumOperands() : 0));
866 }
867/// @}
868
869 /// Destroy ConstantArrays in LLVMContext if they are not used.
870 /// ConstantArrays constructed during linking can cause quadratic memory
871 /// explosion. Releasing all unused constants can cause a 20% LTO compile-time
872 /// slowdown for a large application.
873 ///
874 /// NOTE: Constants are currently owned by LLVMContext. This can then only
875 /// be called where all uses of the LLVMContext are understood.
876 void dropTriviallyDeadConstantArrays();
877
878/// @name Utility functions for printing and dumping Module objects
879/// @{
880
881 /// Print the module to an output stream with an optional
882 /// AssemblyAnnotationWriter. If \c ShouldPreserveUseListOrder, then include
883 /// uselistorder directives so that use-lists can be recreated when reading
884 /// the assembly.
886 bool ShouldPreserveUseListOrder = false,
887 bool IsForDebug = false) const;
888
889 /// Dump the module to stderr (for debugging).
890 void dump() const;
891
892 /// This function causes all the subinstructions to "let go" of all references
893 /// that they are maintaining. This allows one to 'delete' a whole class at
894 /// a time, even though there may be circular references... first all
895 /// references are dropped, and all use counts go to zero. Then everything
896 /// is delete'd for real. Note that no operations are valid on an object
897 /// that has "dropped all references", except operator delete.
898 void dropAllReferences();
899
900/// @}
901/// @name Utility functions for querying Debug information.
902/// @{
903
904 /// Returns the Number of Register ParametersDwarf Version by checking
905 /// module flags.
906 unsigned getNumberRegisterParameters() const;
907
908 /// Returns the Dwarf Version by checking module flags.
909 unsigned getDwarfVersion() const;
910
911 /// Returns the DWARF format by checking module flags.
912 bool isDwarf64() const;
913
914 /// Returns the CodeView Version by checking module flags.
915 /// Returns zero if not present in module.
916 unsigned getCodeViewFlag() const;
917
918/// @}
919/// @name Utility functions for querying and setting PIC level
920/// @{
921
922 /// Returns the PIC level (small or large model)
923 PICLevel::Level getPICLevel() const;
924
925 /// Set the PIC level (small or large model)
926 void setPICLevel(PICLevel::Level PL);
927/// @}
928
929/// @}
930/// @name Utility functions for querying and setting PIE level
931/// @{
932
933 /// Returns the PIE level (small or large model)
934 PIELevel::Level getPIELevel() const;
935
936 /// Set the PIE level (small or large model)
937 void setPIELevel(PIELevel::Level PL);
938/// @}
939
940 /// @}
941 /// @name Utility function for querying and setting code model
942 /// @{
943
944 /// Returns the code model (tiny, small, kernel, medium or large model)
945 std::optional<CodeModel::Model> getCodeModel() const;
946
947 /// Set the code model (tiny, small, kernel, medium or large)
948 void setCodeModel(CodeModel::Model CL);
949 /// @}
950
951 /// @}
952 /// @name Utility function for querying and setting the large data threshold
953 /// @{
954
955 /// Returns the code model (tiny, small, kernel, medium or large model)
956 std::optional<uint64_t> getLargeDataThreshold() const;
957
958 /// Set the code model (tiny, small, kernel, medium or large)
959 void setLargeDataThreshold(uint64_t Threshold);
960 /// @}
961
962 /// @name Utility functions for querying and setting PGO summary
963 /// @{
964
965 /// Attach profile summary metadata to this module.
966 void setProfileSummary(Metadata *M, ProfileSummary::Kind Kind);
967
968 /// Returns profile summary metadata. When IsCS is true, use the context
969 /// sensitive profile summary.
970 Metadata *getProfileSummary(bool IsCS) const;
971 /// @}
972
973 /// Returns whether semantic interposition is to be respected.
974 bool getSemanticInterposition() const;
975
976 /// Set whether semantic interposition is to be respected.
977 void setSemanticInterposition(bool);
978
979 /// Returns true if PLT should be avoided for RTLib calls.
980 bool getRtLibUseGOT() const;
981
982 /// Set that PLT should be avoid for RTLib calls.
983 void setRtLibUseGOT();
984
985 /// Get/set whether referencing global variables can use direct access
986 /// relocations on ELF targets.
987 bool getDirectAccessExternalData() const;
988 void setDirectAccessExternalData(bool Value);
989
990 /// Get/set whether synthesized functions should get the uwtable attribute.
991 UWTableKind getUwtable() const;
992 void setUwtable(UWTableKind Kind);
993
994 /// Get/set whether synthesized functions should get the "frame-pointer"
995 /// attribute.
996 FramePointerKind getFramePointer() const;
997 void setFramePointer(FramePointerKind Kind);
998
999 /// Get/set what kind of stack protector guard to use.
1000 StringRef getStackProtectorGuard() const;
1001 void setStackProtectorGuard(StringRef Kind);
1002
1003 /// Get/set which register to use as the stack protector guard register. The
1004 /// empty string is equivalent to "global". Other values may be "tls" or
1005 /// "sysreg".
1006 StringRef getStackProtectorGuardReg() const;
1007 void setStackProtectorGuardReg(StringRef Reg);
1008
1009 /// Get/set a symbol to use as the stack protector guard.
1010 StringRef getStackProtectorGuardSymbol() const;
1011 void setStackProtectorGuardSymbol(StringRef Symbol);
1012
1013 /// Get/set what offset from the stack protector to use.
1014 int getStackProtectorGuardOffset() const;
1015 void setStackProtectorGuardOffset(int Offset);
1016
1017 /// Get/set the stack alignment overridden from the default.
1018 unsigned getOverrideStackAlignment() const;
1019 void setOverrideStackAlignment(unsigned Align);
1020
1021 unsigned getMaxTLSAlignment() const;
1022
1023 /// @name Utility functions for querying and setting the build SDK version
1024 /// @{
1025
1026 /// Attach a build SDK version metadata to this module.
1027 void setSDKVersion(const VersionTuple &V);
1028
1029 /// Get the build SDK version metadata.
1030 ///
1031 /// An empty version is returned if no such metadata is attached.
1032 VersionTuple getSDKVersion() const;
1033 /// @}
1034
1035 /// Take ownership of the given memory buffer.
1036 void setOwnedMemoryBuffer(std::unique_ptr<MemoryBuffer> MB);
1037
1038 /// Set the partial sample profile ratio in the profile summary module flag,
1039 /// if applicable.
1040 void setPartialSampleProfileRatio(const ModuleSummaryIndex &Index);
1041
1042 /// Get the target variant triple which is a string describing a variant of
1043 /// the target host platform. For example, Mac Catalyst can be a variant
1044 /// target triple for a macOS target.
1045 /// @returns a string containing the target variant triple.
1046 StringRef getDarwinTargetVariantTriple() const;
1047
1048 /// Set the target variant triple which is a string describing a variant of
1049 /// the target host platform.
1050 void setDarwinTargetVariantTriple(StringRef T);
1051
1052 /// Get the target variant version build SDK version metadata.
1053 ///
1054 /// An empty version is returned if no such metadata is attached.
1055 VersionTuple getDarwinTargetVariantSDKVersion() const;
1056
1057 /// Set the target variant version build SDK version metadata.
1058 void setDarwinTargetVariantSDKVersion(VersionTuple Version);
1059};
1060
1061/// Given "llvm.used" or "llvm.compiler.used" as a global name, collect the
1062/// initializer elements of that global in a SmallVector and return the global
1063/// itself.
1064GlobalVariable *collectUsedGlobalVariables(const Module &M,
1065 SmallVectorImpl<GlobalValue *> &Vec,
1066 bool CompilerUsed);
1067
1068/// An raw_ostream inserter for modules.
1070 M.print(O, nullptr);
1071 return O;
1072}
1073
1074// Create wrappers for C Binding types (see CBindingWrapping.h).
1076
1077/* LLVMModuleProviderRef exists for historical reasons, but now just holds a
1078 * Module.
1079 */
1081 return reinterpret_cast<Module*>(MP);
1082}
1083
1084} // end namespace llvm
1085
1086#endif // LLVM_IR_MODULE_H
aarch64 promote const
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This file defines the StringMap class.
always inline
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
#define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:135
return RetTy
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
std::string Name
std::optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:1290
uint64_t Offset
Definition: ELF_riscv.cpp:478
static Function * getFunction(Constant *C)
Definition: Evaluator.cpp:236
This file contains the declaration of the GlobalIFunc class, which represents a single indirect funct...
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
Machine Check Debug Module
unsigned Reg
static Constant * getOrInsertGlobal(Module &M, StringRef Name, Type *Ty)
This file contains the declarations for metadata subclasses.
#define T
LLVMContext & Context
static CodeModel::Model getCodeModel(const PPCSubtarget &S, const TargetMachine &TM, const MachineOperand &MO)
This file contains some templates that are useful if you are working with the STL at all.
raw_pwrite_stream & OS
static GlobalVariable * getGlobalVariable(Module &M, Type *Ty, WebAssemblyTargetMachine &TM, const char *Name)
This is an important base class in LLVM.
Definition: Constant.h:41
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
A handy container for a FunctionType+Callee-pointer pair, which can be passed around as a single enti...
Definition: DerivedTypes.h:168
Class to represent function types.
Definition: DerivedTypes.h:103
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
Metadata node.
Definition: Metadata.h:1067
A single uniqued string.
Definition: Metadata.h:720
Root of the metadata hierarchy.
Definition: Metadata.h:62
Class to hold module path string table and global value map, and encapsulate methods for operating on...
An iterator for DICompileUnits that skips those marked NoDebug.
Definition: Module.h:806
debug_compile_units_iterator & operator++()
Definition: Module.h:824
bool operator==(const debug_compile_units_iterator &I) const
Definition: Module.h:836
debug_compile_units_iterator operator++(int)
Definition: Module.h:830
std::input_iterator_tag iterator_category
Definition: Module.h:813
debug_compile_units_iterator(NamedMDNode *CUs, unsigned Idx)
Definition: Module.h:819
bool operator!=(const debug_compile_units_iterator &I) const
Definition: Module.h:840
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
global_iterator global_begin()
Definition: Module.h:686
void removeIFunc(GlobalIFunc *IFunc)
Detach IFunc from the list but don't delete it.
Definition: Module.h:622
const_global_iterator global_begin() const
Definition: Module.h:687
const_iterator begin() const
Definition: Module.h:705
ifunc_iterator ifunc_begin()
Definition: Module.h:744
void eraseNamedMDNode(NamedMDNode *MDNode)
Remove MDNode from the list and delete it.
Definition: Module.h:633
const std::string & getModuleInlineAsm() const
Get any module-scope inline assembly blocks.
Definition: Module.h:299
ModFlagBehavior
This enumeration defines the supported behaviors of module flags.
Definition: Module.h:115
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:295
void insertIFunc(GlobalIFunc *IFunc)
Insert IFunc at the end of the alias list and take ownership.
Definition: Module.h:626
iterator_range< const_alias_iterator > aliases() const
Definition: Module.h:736
void setModuleInlineAsm(StringRef Asm)
Set the module-scope inline assembly blocks.
Definition: Module.h:338
const ComdatSymTabType & getComdatSymbolTable() const
Get the Module's symbol table for COMDATs (constant).
Definition: Module.h:678
bool IsNewDbgInfoFormat
Is this Module using intrinsics to record the position of debugging information, or non-intrinsic rec...
Definition: Module.h:219
global_iterator global_end()
Definition: Module.h:688
GlobalVariable * getNamedGlobal(StringRef Name)
Definition: Module.h:458
NamedMDListType::iterator named_metadata_iterator
The named metadata iterators.
Definition: Module.h:110
size_t alias_size() const
Definition: Module.h:730
const_global_iterator global_end() const
Definition: Module.h:689
bool global_empty() const
Definition: Module.h:691
iterator begin()
Definition: Module.h:704
void convertToNewDbgValues()
Definition: Module.h:227
FunctionCallee getOrInsertFunction(StringRef Name, AttributeList AttributeList, Type *RetTy, ArgsTy... Args)
Same as above, but takes a list of function arguments, which makes it easier for clients to use.
Definition: Module.h:406
const_ifunc_iterator ifunc_end() const
Definition: Module.h:747
void convertFromNewDbgValues()
Definition: Module.h:235
iterator_range< ifunc_iterator > ifuncs()
Definition: Module.h:751
bool named_metadata_empty() const
Definition: Module.h:796
ValueSymbolTable & getValueSymbolTable()
Get the Module's symbol table of global variable and function identifiers.
Definition: Module.h:675
NamedMDListType::const_iterator const_named_metadata_iterator
The named metadata constant iterators.
Definition: Module.h:112
const_named_metadata_iterator named_metadata_begin() const
Definition: Module.h:786
size_t global_size() const
Definition: Module.h:690
iterator_range< debug_compile_units_iterator > debug_compile_units() const
Return an iterator for all DICompileUnits listed in this Module's llvm.dbg.cu named metadata node and...
Definition: Module.h:861
iterator_range< iterator > functions()
Definition: Module.h:715
StringRef getName() const
Get a short "name" for the module.
Definition: Module.h:278
GVMaterializer * getMaterializer() const
Retrieves the GVMaterializer, if any, for this Module.
Definition: Module.h:559
const std::string & getSourceFileName() const
Get the module's original source file name.
Definition: Module.h:272
IFuncListType::iterator ifunc_iterator
The Global IFunc iterators.
Definition: Module.h:105
const_alias_iterator alias_end() const
Definition: Module.h:729
void removeAlias(GlobalAlias *Alias)
Detach Alias from the list but don't delete it.
Definition: Module.h:613
iterator_range< named_metadata_iterator > named_metadata()
Definition: Module.h:798
named_metadata_iterator named_metadata_begin()
Definition: Module.h:785
ifunc_iterator ifunc_end()
Definition: Module.h:746
GlobalListType::const_iterator const_global_iterator
The Global Variable constant iterator.
Definition: Module.h:87
iterator_range< alias_iterator > aliases()
Definition: Module.h:733
const std::string & getTargetTriple() const
Get the target triple which is a string describing the target host.
Definition: Module.h:291
void insertGlobalVariable(GlobalListType::iterator Where, GlobalVariable *GV)
Insert global variable GV into the global variable list before Where and take ownership.
Definition: Module.h:582
alias_iterator alias_end()
Definition: Module.h:728
const_alias_iterator alias_begin() const
Definition: Module.h:727
const_reverse_iterator rbegin() const
Definition: Module.h:709
alias_iterator alias_begin()
Definition: Module.h:726
reverse_iterator rend()
Definition: Module.h:710
FunctionListType::iterator iterator
The Function iterators.
Definition: Module.h:90
GlobalVariable * getGlobalVariable(StringRef Name, bool AllowInternal=false)
Definition: Module.h:446
void eraseIFunc(GlobalIFunc *IFunc)
Remove IFunc from the list and delete it.
Definition: Module.h:624
bool shouldEmitInstrCountChangedRemark()
Return true if size-info optimization remark is enabled, false otherwise.
Definition: Module.h:314
GlobalListType::iterator global_iterator
The Global Variable iterator.
Definition: Module.h:85
size_t size() const
Definition: Module.h:712
FunctionListType::const_reverse_iterator const_reverse_iterator
The Function constant reverse iterator.
Definition: Module.h:97
bool alias_empty() const
Definition: Module.h:731
FunctionCallee getOrInsertFunction(StringRef Name, AttributeList AttributeList, FunctionType *Invalid, ArgsTy... Args)=delete
iterator_range< global_iterator > globals()
Definition: Module.h:693
const_reverse_iterator rend() const
Definition: Module.h:711
iterator_range< const_named_metadata_iterator > named_metadata() const
Definition: Module.h:801
IFuncListType::const_iterator const_ifunc_iterator
The Global IFunc constant iterator.
Definition: Module.h:107
size_t ifunc_size() const
Definition: Module.h:748
FunctionListType & getFunctionList()
Get the Module's list of functions.
Definition: Module.h:607
void eraseAlias(GlobalAlias *Alias)
Remove Alias from the list and delete it.
Definition: Module.h:615
const std::string & getModuleIdentifier() const
Get the module identifier which is, essentially, the name of the module.
Definition: Module.h:261
void eraseGlobalVariable(GlobalVariable *GV)
Remove global variable GV from the list and delete it.
Definition: Module.h:574
reverse_iterator rbegin()
Definition: Module.h:708
FunctionCallee getOrInsertFunction(StringRef Name, Type *RetTy, ArgsTy... Args)
Same as above, but without the attributes.
Definition: Module.h:417
void insertNamedMDNode(NamedMDNode *MDNode)
Insert MDNode at the end of the alias list and take ownership.
Definition: Module.h:635
const_named_metadata_iterator named_metadata_end() const
Definition: Module.h:791
bool empty() const
Definition: Module.h:713
void removeNamedMDNode(NamedMDNode *MDNode)
Detach MDNode from the list but don't delete it.
Definition: Module.h:631
AliasListType::iterator alias_iterator
The Global Alias iterators.
Definition: Module.h:100
iterator end()
Definition: Module.h:706
GlobalVariable * getGlobalVariable(StringRef Name) const
Look up the specified global variable in the module symbol table.
Definition: Module.h:440
void insertGlobalVariable(GlobalVariable *GV)
Insert global variable GV at the end of the global variable list and take ownership.
Definition: Module.h:577
const ValueSymbolTable & getValueSymbolTable() const
Get the symbol table of global variable and function identifiers.
Definition: Module.h:673
size_t named_metadata_size() const
Definition: Module.h:795
named_metadata_iterator named_metadata_end()
Definition: Module.h:790
bool isMaterialized() const
Definition: Module.h:560
const GlobalVariable * getNamedGlobal(StringRef Name) const
Return the global variable in the module with the specified name, of arbitrary type.
Definition: Module.h:455
AliasListType::const_iterator const_alias_iterator
The Global Alias constant iterator.
Definition: Module.h:102
ComdatSymTabType & getComdatSymbolTable()
Get the Module's symbol table for COMDATs.
Definition: Module.h:680
FunctionListType::reverse_iterator reverse_iterator
The Function reverse iterator.
Definition: Module.h:95
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.h:287
iterator_range< const_iterator > functions() const
Definition: Module.h:718
void setIsNewDbgInfoFormat(bool UseNewFormat)
Definition: Module.h:242
iterator_range< const_global_iterator > globals() const
Definition: Module.h:696
void setModuleIdentifier(StringRef ID)
Set the module identifier.
Definition: Module.h:324
iterator_range< const_ifunc_iterator > ifuncs() const
Definition: Module.h:754
const_iterator end() const
Definition: Module.h:707
void setSourceFileName(StringRef Name)
Set the module's original source file name.
Definition: Module.h:327
const_ifunc_iterator ifunc_begin() const
Definition: Module.h:745
const std::string & getDataLayoutStr() const
Get the data layout string for the module's target platform.
Definition: Module.h:282
static FunctionListType Module::* getSublistAccess(Function *)
Definition: Module.h:608
void appendModuleInlineAsm(StringRef Asm)
Append to the module-scope inline assembly blocks.
Definition: Module.h:346
FunctionListType::const_iterator const_iterator
The Function constant iterator.
Definition: Module.h:92
void insertAlias(GlobalAlias *Alias)
Insert Alias at the end of the alias list and take ownership.
Definition: Module.h:617
debug_compile_units_iterator debug_compile_units_begin() const
Definition: Module.h:848
void setTargetTriple(StringRef T)
Set the target triple.
Definition: Module.h:334
bool ifunc_empty() const
Definition: Module.h:749
void removeGlobalVariable(GlobalVariable *GV)
Detach global variable GV from the list but don't delete it.
Definition: Module.h:572
debug_compile_units_iterator debug_compile_units_end() const
Definition: Module.h:853
A tuple of MDNodes.
Definition: Metadata.h:1729
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
This class provides a symbol table of name/value pairs.
LLVM Value Representation.
Definition: Value.h:74
Represents a version number in the form major[.minor[.subminor[.build]]].
Definition: VersionTuple.h:29
Iterator wrapper that concatenates sequences together.
Definition: STLExtras.h:1032
An efficient, type-erasing, non-owning reference to a callable.
base_list_type::const_reverse_iterator const_reverse_iterator
Definition: ilist.h:125
base_list_type::reverse_iterator reverse_iterator
Definition: ilist.h:123
base_list_type::const_iterator const_iterator
Definition: ilist.h:122
base_list_type::iterator iterator
Definition: ilist.h:121
An intrusive list with ownership and callbacks specified/controlled by ilist_traits,...
Definition: ilist.h:328
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:61
struct LLVMOpaqueModuleProvider * LLVMModuleProviderRef
Interface used to provide a module to JIT or interpreter.
Definition: Types.h:124
This provides a very simple, boring adaptor for a begin and end iterator into a range type.
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
FramePointerKind
Definition: CodeGen.h:90
APInt operator*(APInt a, uint64_t RHS)
Definition: APInt.h:2165
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
UWTableKind
Definition: CodeGen.h:120
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:303
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition: APFixedPoint.h:293
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition: Module.cpp:843
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Description of the encoding of one expression Op.
ModFlagBehavior Behavior
Definition: Module.h:167
ModuleFlagEntry(ModFlagBehavior B, MDString *K, Metadata *V)
Definition: Module.h:171