2003-09-30 18:37:50 +00:00
|
|
|
//===-- llvm/Module.h - C++ class to represent a VM module ------*- C++ -*-===//
|
2005-04-21 20:19:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 20:19:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2009-03-03 02:55:14 +00:00
|
|
|
/// @file
|
|
|
|
/// Module.h This file contains the declarations for the Module class.
|
2001-10-13 06:17:32 +00:00
|
|
|
//
|
2001-06-06 20:29:01 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-01-10 00:45:19 +00:00
|
|
|
#ifndef LLVM_IR_MODULE_H
|
|
|
|
#define LLVM_IR_MODULE_H
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2014-03-09 12:20:30 +00:00
|
|
|
#include "llvm/ADT/iterator_range.h"
|
2014-06-27 18:19:56 +00:00
|
|
|
#include "llvm/IR/Comdat.h"
|
2014-02-25 20:01:08 +00:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/GlobalAlias.h"
|
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
|
|
#include "llvm/IR/Metadata.h"
|
2013-05-01 20:59:00 +00:00
|
|
|
#include "llvm/Support/CBindingWrapping.h"
|
2014-11-07 04:46:10 +00:00
|
|
|
#include "llvm/Support/CodeGen.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/DataTypes.h"
|
2014-06-12 17:38:55 +00:00
|
|
|
#include <system_error>
|
2003-11-11 22:41:34 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
2002-03-29 03:32:29 +00:00
|
|
|
class FunctionType;
|
2010-01-27 20:34:15 +00:00
|
|
|
class GVMaterializer;
|
2009-08-11 17:45:13 +00:00
|
|
|
class LLVMContext;
|
2014-06-25 15:21:42 +00:00
|
|
|
class RandomNumberGenerator;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
class StructType;
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-06-25 16:12:52 +00:00
|
|
|
template<> struct ilist_traits<Function>
|
2007-04-17 03:26:42 +00:00
|
|
|
: public SymbolTableListTraits<Function, Module> {
|
2009-03-27 22:28:33 +00:00
|
|
|
|
|
|
|
// createSentinel is used to get hold of the node that marks the end of the
|
|
|
|
// list... (same trick used here as in ilist_traits<Instruction>)
|
|
|
|
Function *createSentinel() const {
|
|
|
|
return static_cast<Function*>(&Sentinel);
|
|
|
|
}
|
|
|
|
static void destroySentinel(Function*) {}
|
|
|
|
|
|
|
|
Function *provideInitialHead() const { return createSentinel(); }
|
|
|
|
Function *ensureHead(Function*) const { return createSentinel(); }
|
|
|
|
static void noteHead(Function*, Function*) {}
|
|
|
|
|
|
|
|
private:
|
|
|
|
mutable ilist_node<Function> Sentinel;
|
2002-06-25 16:12:52 +00:00
|
|
|
};
|
2011-08-13 01:04:44 +00:00
|
|
|
|
2002-06-25 16:12:52 +00:00
|
|
|
template<> struct ilist_traits<GlobalVariable>
|
2007-04-17 03:26:42 +00:00
|
|
|
: public SymbolTableListTraits<GlobalVariable, Module> {
|
2005-01-30 00:09:23 +00:00
|
|
|
// createSentinel is used to create a node that marks the end of the list.
|
2011-08-13 01:04:44 +00:00
|
|
|
GlobalVariable *createSentinel() const {
|
|
|
|
return static_cast<GlobalVariable*>(&Sentinel);
|
|
|
|
}
|
|
|
|
static void destroySentinel(GlobalVariable*) {}
|
|
|
|
|
|
|
|
GlobalVariable *provideInitialHead() const { return createSentinel(); }
|
|
|
|
GlobalVariable *ensureHead(GlobalVariable*) const { return createSentinel(); }
|
|
|
|
static void noteHead(GlobalVariable*, GlobalVariable*) {}
|
|
|
|
private:
|
|
|
|
mutable ilist_node<GlobalVariable> Sentinel;
|
2002-06-25 16:12:52 +00:00
|
|
|
};
|
2011-08-13 01:04:44 +00:00
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
template<> struct ilist_traits<GlobalAlias>
|
|
|
|
: public SymbolTableListTraits<GlobalAlias, Module> {
|
|
|
|
// createSentinel is used to create a node that marks the end of the list.
|
2011-08-13 01:04:44 +00:00
|
|
|
GlobalAlias *createSentinel() const {
|
|
|
|
return static_cast<GlobalAlias*>(&Sentinel);
|
|
|
|
}
|
|
|
|
static void destroySentinel(GlobalAlias*) {}
|
|
|
|
|
|
|
|
GlobalAlias *provideInitialHead() const { return createSentinel(); }
|
|
|
|
GlobalAlias *ensureHead(GlobalAlias*) const { return createSentinel(); }
|
|
|
|
static void noteHead(GlobalAlias*, GlobalAlias*) {}
|
|
|
|
private:
|
|
|
|
mutable ilist_node<GlobalAlias> Sentinel;
|
2007-04-25 14:27:10 +00:00
|
|
|
};
|
2010-01-12 18:34:06 +00:00
|
|
|
|
2009-07-29 17:16:17 +00:00
|
|
|
template<> struct ilist_traits<NamedMDNode>
|
2010-07-21 23:38:33 +00:00
|
|
|
: public ilist_default_traits<NamedMDNode> {
|
2009-07-29 17:16:17 +00:00
|
|
|
// createSentinel is used to get hold of a node that marks the end of
|
|
|
|
// the list...
|
|
|
|
NamedMDNode *createSentinel() const {
|
|
|
|
return static_cast<NamedMDNode*>(&Sentinel);
|
|
|
|
}
|
|
|
|
static void destroySentinel(NamedMDNode*) {}
|
|
|
|
|
|
|
|
NamedMDNode *provideInitialHead() const { return createSentinel(); }
|
|
|
|
NamedMDNode *ensureHead(NamedMDNode*) const { return createSentinel(); }
|
|
|
|
static void noteHead(NamedMDNode*, NamedMDNode*) {}
|
2010-07-22 21:51:30 +00:00
|
|
|
void addNodeToList(NamedMDNode *) {}
|
|
|
|
void removeNodeFromList(NamedMDNode *) {}
|
2009-07-29 17:16:17 +00:00
|
|
|
private:
|
|
|
|
mutable ilist_node<NamedMDNode> Sentinel;
|
|
|
|
};
|
2002-06-25 16:12:52 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// A Module instance is used to store all the information related to an
|
2008-04-16 20:45:31 +00:00
|
|
|
/// LLVM module. Modules are the top level container of all other LLVM
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Intermediate Representation (IR) objects. Each module directly contains a
|
2008-04-16 20:45:31 +00:00
|
|
|
/// list of globals variables, a list of functions, a list of libraries (or
|
2006-05-16 06:27:31 +00:00
|
|
|
/// other modules) this module depends on, a symbol table, and various data
|
|
|
|
/// about the target's characteristics.
|
|
|
|
///
|
|
|
|
/// A module maintains a GlobalValRefMap object that is used to hold all
|
|
|
|
/// constant references to global variables in the module. When a global
|
|
|
|
/// variable is destroyed, it should have no entries in the GlobalValueRefMap.
|
|
|
|
/// @brief The main container class for the LLVM Intermediate Representation.
|
2004-06-08 17:44:21 +00:00
|
|
|
class Module {
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @name Types And Enumerations
|
|
|
|
/// @{
|
2004-06-08 17:44:21 +00:00
|
|
|
public:
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The type for the list of global variables.
|
2002-06-25 16:12:52 +00:00
|
|
|
typedef iplist<GlobalVariable> GlobalListType;
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The type for the list of functions.
|
2002-06-25 16:12:52 +00:00
|
|
|
typedef iplist<Function> FunctionListType;
|
2007-04-25 14:27:10 +00:00
|
|
|
/// The type for the list of aliases.
|
|
|
|
typedef iplist<GlobalAlias> AliasListType;
|
2009-07-29 17:16:17 +00:00
|
|
|
/// The type for the list of named metadata.
|
2010-07-21 23:38:33 +00:00
|
|
|
typedef ilist<NamedMDNode> NamedMDListType;
|
2014-06-27 18:19:56 +00:00
|
|
|
/// The type of the comdat "symbol" table.
|
|
|
|
typedef StringMap<Comdat> ComdatSymTabType;
|
2006-05-16 06:27:31 +00:00
|
|
|
|
|
|
|
/// The Global Variable iterator.
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef GlobalListType::iterator global_iterator;
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The Global Variable constant iterator.
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef GlobalListType::const_iterator const_global_iterator;
|
2001-09-10 07:58:01 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The Function iterators.
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef FunctionListType::iterator iterator;
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The Function constant iterator
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef FunctionListType::const_iterator const_iterator;
|
2001-09-10 07:58:01 +00:00
|
|
|
|
2014-07-28 21:09:32 +00:00
|
|
|
/// The Function reverse iterator.
|
|
|
|
typedef FunctionListType::reverse_iterator reverse_iterator;
|
|
|
|
/// The Function constant reverse iterator.
|
|
|
|
typedef FunctionListType::const_reverse_iterator const_reverse_iterator;
|
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
/// The Global Alias iterators.
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef AliasListType::iterator alias_iterator;
|
2007-04-25 14:27:10 +00:00
|
|
|
/// The Global Alias constant iterator
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef AliasListType::const_iterator const_alias_iterator;
|
2007-04-25 14:27:10 +00:00
|
|
|
|
2009-07-29 17:16:17 +00:00
|
|
|
/// The named metadata iterators.
|
|
|
|
typedef NamedMDListType::iterator named_metadata_iterator;
|
2014-12-05 16:02:06 +00:00
|
|
|
/// The named metadata constant iterators.
|
2009-07-29 17:16:17 +00:00
|
|
|
typedef NamedMDListType::const_iterator const_named_metadata_iterator;
|
2004-07-25 17:52:27 +00:00
|
|
|
|
2013-01-16 21:38:56 +00:00
|
|
|
/// This enumeration defines the supported behaviors of module flags.
|
|
|
|
enum ModFlagBehavior {
|
|
|
|
/// Emits an error if two values disagree, otherwise the resulting value is
|
|
|
|
/// that of the operands.
|
|
|
|
Error = 1,
|
|
|
|
|
|
|
|
/// Emits a warning if two values disagree. The result value will be the
|
|
|
|
/// operand for the flag from the first module being linked.
|
2014-01-11 00:23:11 +00:00
|
|
|
Warning = 2,
|
2013-01-16 21:38:56 +00:00
|
|
|
|
|
|
|
/// Adds a requirement that another module flag be present and have a
|
|
|
|
/// specified value after linking is performed. The value must be a metadata
|
|
|
|
/// pair, where the first element of the pair is the ID of the module flag
|
|
|
|
/// to be restricted, and the second element of the pair is the value the
|
|
|
|
/// module flag should be restricted to. This behavior can be used to
|
|
|
|
/// restrict the allowable results (via triggering of an error) of linking
|
|
|
|
/// IDs with the **Override** behavior.
|
|
|
|
Require = 3,
|
|
|
|
|
|
|
|
/// Uses the specified value, regardless of the behavior or value of the
|
|
|
|
/// other module. If both modules specify **Override**, but the values
|
|
|
|
/// differ, an error will be emitted.
|
|
|
|
Override = 4,
|
|
|
|
|
|
|
|
/// Appends the two values, which are required to be metadata nodes.
|
|
|
|
Append = 5,
|
|
|
|
|
|
|
|
/// Appends the two values, which are required to be metadata
|
|
|
|
/// nodes. However, duplicate entries in the second list are dropped
|
|
|
|
/// during the append operation.
|
2014-09-08 19:16:28 +00:00
|
|
|
AppendUnique = 6,
|
|
|
|
|
|
|
|
// Markers:
|
|
|
|
ModFlagBehaviorFirstVal = Error,
|
|
|
|
ModFlagBehaviorLastVal = AppendUnique
|
2013-01-16 21:38:56 +00:00
|
|
|
};
|
2012-02-11 11:38:06 +00:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
/// Checks if Metadata represents a valid ModFlagBehavior, and stores the
|
2014-09-08 19:16:28 +00:00
|
|
|
/// converted result in MFB.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
static bool isValidModFlagBehavior(Metadata *MD, ModFlagBehavior &MFB);
|
2014-09-08 19:16:28 +00:00
|
|
|
|
2012-02-15 22:34:20 +00:00
|
|
|
struct ModuleFlagEntry {
|
2012-02-16 10:28:10 +00:00
|
|
|
ModFlagBehavior Behavior;
|
2012-02-15 22:34:20 +00:00
|
|
|
MDString *Key;
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *Val;
|
|
|
|
ModuleFlagEntry(ModFlagBehavior B, MDString *K, Metadata *V)
|
|
|
|
: Behavior(B), Key(K), Val(V) {}
|
2012-02-15 22:34:20 +00:00
|
|
|
};
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Member Variables
|
|
|
|
/// @{
|
2003-04-22 18:02:04 +00:00
|
|
|
private:
|
2010-01-07 19:39:36 +00:00
|
|
|
LLVMContext &Context; ///< The LLVMContext from which types and
|
|
|
|
///< constants are allocated.
|
|
|
|
GlobalListType GlobalList; ///< The Global Variables in the module
|
|
|
|
FunctionListType FunctionList; ///< The Functions in the module
|
|
|
|
AliasListType AliasList; ///< The Aliases in the module
|
|
|
|
NamedMDListType NamedMDList; ///< The named metadata in the module
|
|
|
|
std::string GlobalScopeAsm; ///< Inline Asm at global scope.
|
|
|
|
ValueSymbolTable *ValSymTab; ///< Symbol table for values
|
2014-06-27 18:19:56 +00:00
|
|
|
ComdatSymTabType ComdatSymTab; ///< Symbol table for COMDATs
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<GVMaterializer>
|
|
|
|
Materializer; ///< Used to materialize GlobalValues
|
2010-01-07 19:39:36 +00:00
|
|
|
std::string ModuleID; ///< Human readable identifier for the module
|
|
|
|
std::string TargetTriple; ///< Platform target triple Module compiled on
|
2014-12-06 03:11:46 +00:00
|
|
|
///< Format: (arch)(sub)-(vendor)-(sys0-(abi)
|
2010-07-21 23:38:33 +00:00
|
|
|
void *NamedMDSymTab; ///< NamedMDNode names.
|
2015-03-04 18:43:29 +00:00
|
|
|
DataLayout DL; ///< DataLayout associated with the module
|
2014-02-25 20:01:08 +00:00
|
|
|
|
2002-10-14 03:30:23 +00:00
|
|
|
friend class Constant;
|
2001-10-13 06:17:32 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Constructors
|
|
|
|
/// @{
|
2001-06-06 20:29:01 +00:00
|
|
|
public:
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The Module constructor. Note that there is no default constructor. You
|
|
|
|
/// must provide a name for the module upon construction.
|
2009-11-06 10:58:06 +00:00
|
|
|
explicit Module(StringRef ModuleID, LLVMContext& C);
|
2006-05-16 06:27:31 +00:00
|
|
|
/// The module destructor. This will dropAllReferences.
|
2001-06-06 20:29:01 +00:00
|
|
|
~Module();
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Module Level Accessors
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get the module identifier which is, essentially, the name of the module.
|
|
|
|
/// @returns the module identifier as a string
|
2005-10-25 17:58:00 +00:00
|
|
|
const std::string &getModuleIdentifier() const { return ModuleID; }
|
|
|
|
|
2015-01-13 02:51:47 +00:00
|
|
|
/// \brief Get a short "name" for the module.
|
|
|
|
///
|
|
|
|
/// This is useful for debugging or logging. It is essentially a convenience
|
|
|
|
/// wrapper around getModuleIdentifier().
|
|
|
|
StringRef getName() const { return ModuleID; }
|
|
|
|
|
2014-02-25 20:01:08 +00:00
|
|
|
/// Get the data layout string for the module's target platform. This is
|
|
|
|
/// equivalent to getDataLayout()->getStringRepresentation().
|
2015-06-26 20:44:16 +00:00
|
|
|
const std::string &getDataLayoutStr() const {
|
2015-03-04 18:43:29 +00:00
|
|
|
return DL.getStringRepresentation();
|
|
|
|
}
|
2014-02-25 20:01:08 +00:00
|
|
|
|
|
|
|
/// Get the data layout for the module's target platform.
|
2015-03-04 18:43:29 +00:00
|
|
|
const DataLayout &getDataLayout() const;
|
2006-10-18 02:21:12 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get the target triple which is a string describing the target host.
|
|
|
|
/// @returns a string containing the target triple.
|
2005-10-25 17:58:00 +00:00
|
|
|
const std::string &getTargetTriple() const { return TargetTriple; }
|
2003-04-22 18:02:04 +00:00
|
|
|
|
2009-07-01 16:58:40 +00:00
|
|
|
/// Get the global data context.
|
|
|
|
/// @returns LLVMContext - a container for LLVM's global information
|
2009-12-29 09:01:33 +00:00
|
|
|
LLVMContext &getContext() const { return Context; }
|
2009-07-01 16:58:40 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get any module-scope inline assembly blocks.
|
|
|
|
/// @returns a string containing the module-scope inline assembly blocks.
|
2006-01-24 04:13:11 +00:00
|
|
|
const std::string &getModuleInlineAsm() const { return GlobalScopeAsm; }
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2014-12-17 18:12:10 +00:00
|
|
|
/// Get a RandomNumberGenerator salted for use with this module. The
|
|
|
|
/// RNG can be seeded via -rng-seed=<uint64> and is salted with the
|
|
|
|
/// ModuleID and the provided pass salt. The returned RNG should not
|
|
|
|
/// be shared across threads or passes.
|
|
|
|
///
|
|
|
|
/// A unique RNG per pass ensures a reproducible random stream even
|
|
|
|
/// when other randomness consuming passes are added or removed. In
|
|
|
|
/// addition, the random stream will be reproducible across LLVM
|
|
|
|
/// versions when the pass does not change.
|
|
|
|
RandomNumberGenerator *createRNG(const Pass* P) const;
|
2014-06-25 15:21:42 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Module Level Mutators
|
|
|
|
/// @{
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Set the module identifier.
|
2009-11-06 10:58:06 +00:00
|
|
|
void setModuleIdentifier(StringRef ID) { ModuleID = ID; }
|
2006-05-16 06:27:31 +00:00
|
|
|
|
2006-10-18 02:21:12 +00:00
|
|
|
/// Set the data layout
|
2014-02-25 20:01:08 +00:00
|
|
|
void setDataLayout(StringRef Desc);
|
2015-03-04 18:43:29 +00:00
|
|
|
void setDataLayout(const DataLayout &Other);
|
2006-10-18 02:21:12 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Set the target triple.
|
2009-11-06 10:58:06 +00:00
|
|
|
void setTargetTriple(StringRef T) { TargetTriple = T; }
|
2006-05-16 06:27:31 +00:00
|
|
|
|
|
|
|
/// Set the module-scope inline assembly blocks.
|
2015-03-13 19:05:24 +00:00
|
|
|
/// A trailing newline is added if the input doesn't have one.
|
2011-03-02 04:14:42 +00:00
|
|
|
void setModuleInlineAsm(StringRef Asm) {
|
|
|
|
GlobalScopeAsm = Asm;
|
|
|
|
if (!GlobalScopeAsm.empty() &&
|
|
|
|
GlobalScopeAsm[GlobalScopeAsm.size()-1] != '\n')
|
|
|
|
GlobalScopeAsm += '\n';
|
|
|
|
}
|
2008-04-16 20:45:31 +00:00
|
|
|
|
2015-03-13 19:05:24 +00:00
|
|
|
/// Append to the module-scope inline assembly blocks.
|
|
|
|
/// A trailing newline is added if the input doesn't have one.
|
2009-11-06 10:58:06 +00:00
|
|
|
void appendModuleInlineAsm(StringRef Asm) {
|
2011-03-02 04:14:42 +00:00
|
|
|
GlobalScopeAsm += Asm;
|
2010-01-26 11:58:04 +00:00
|
|
|
if (!GlobalScopeAsm.empty() &&
|
|
|
|
GlobalScopeAsm[GlobalScopeAsm.size()-1] != '\n')
|
|
|
|
GlobalScopeAsm += '\n';
|
2007-06-26 00:38:49 +00:00
|
|
|
}
|
2008-04-16 20:45:31 +00:00
|
|
|
|
2009-03-06 22:04:43 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Generic Value Accessors
|
|
|
|
/// @{
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return the global value in the module with the specified name, of
|
|
|
|
/// arbitrary type. This method returns null if a global with the specified
|
|
|
|
/// name is not found.
|
2009-11-06 10:58:06 +00:00
|
|
|
GlobalValue *getNamedValue(StringRef Name) const;
|
2009-03-06 22:04:43 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return a unique non-zero ID for the specified metadata kind. This ID is
|
|
|
|
/// uniqued across modules in the current LLVMContext.
|
2009-12-29 09:01:33 +00:00
|
|
|
unsigned getMDKindID(StringRef Name) const;
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Populate client supplied SmallVector with the name for custom metadata IDs
|
|
|
|
/// registered in this LLVMContext.
|
2009-12-29 09:01:33 +00:00
|
|
|
void getMDKindNames(SmallVectorImpl<StringRef> &Result) const;
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return the type with the specified name, or null if there is none by that
|
|
|
|
/// name.
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
StructType *getTypeByName(StringRef Name) const;
|
|
|
|
|
Ask the module for its the identified types.
When lazy reading a module, the types used in a function will not be visible to
a TypeFinder until the body is read.
This patch fixes that by asking the module for its identified struct types.
If a materializer is present, the module asks it. If not, it uses a TypeFinder.
This fixes pr21374.
I will be the first to say that this is ugly, but it was the best I could find.
Some of the options I looked at:
* Asking the LLVMContext. This could be made to work for gold, but not currently
for ld64. ld64 will load multiple modules into a single context before merging
them. This causes us to see types from future merges. Unfortunately,
MappedTypes is not just a cache when it comes to opaque types. Once the
mapping has been made, we have to remember it for as long as the key may
be used. This would mean moving MappedTypes to the Linker class and having
to drop the Linker::LinkModules static methods, which are visible from C.
* Adding an option to ignore function bodies in the TypeFinder. This would
fix the PR by picking the worst result. It would work, but unfortunately
we are currently quite dependent on the upfront type merging. I will
try to reduce our dependency, but it is not clear that we will be able
to get rid of it for now.
The only clean solution I could think of is making the Module own the types.
This would have other advantages, but it is a much bigger change. I will
propose it, but it is nice to have this fixed while that is discussed.
With the gold plugin, this patch takes the number of types in the LTO clang
binary from 52817 to 49669.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223215 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-03 07:18:23 +00:00
|
|
|
std::vector<StructType *> getIdentifiedStructTypes() const;
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Function Accessors
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Look up the specified function in the module symbol table. Four
|
|
|
|
/// possibilities:
|
2007-01-07 08:09:25 +00:00
|
|
|
/// 1. If it does not exist, add a prototype for the function and return it.
|
2009-01-15 20:18:42 +00:00
|
|
|
/// 2. If it exists, and has a local linkage, the existing function is
|
2007-01-07 08:09:25 +00:00
|
|
|
/// renamed and a new one is inserted.
|
|
|
|
/// 3. Otherwise, if the existing function has the correct prototype, return
|
|
|
|
/// the existing function.
|
|
|
|
/// 4. Finally, the function exists but has the wrong prototype: return the
|
|
|
|
/// function with a constantexpr cast to the right prototype.
|
2011-07-18 04:54:35 +00:00
|
|
|
Constant *getOrInsertFunction(StringRef Name, FunctionType *T,
|
2012-12-07 23:16:57 +00:00
|
|
|
AttributeSet AttributeList);
|
2009-01-04 22:54:40 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Constant *getOrInsertFunction(StringRef Name, FunctionType *T);
|
2002-03-29 03:32:29 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Look up the specified function in the module symbol table. If it does not
|
|
|
|
/// exist, add a prototype for the function and return it. This function
|
|
|
|
/// guarantees to return a constant of pointer to the specified function type
|
|
|
|
/// or a ConstantExpr BitCast of that type if the named function has a
|
|
|
|
/// different type. This version of the method takes a null terminated list of
|
|
|
|
/// function arguments, which makes it easier for clients to use.
|
2009-11-06 10:58:06 +00:00
|
|
|
Constant *getOrInsertFunction(StringRef Name,
|
2012-12-07 23:16:57 +00:00
|
|
|
AttributeSet AttributeList,
|
2014-11-04 01:12:21 +00:00
|
|
|
Type *RetTy, ...) LLVM_END_WITH_NULL;
|
2009-01-04 22:54:40 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Same as above, but without the attributes.
|
2011-07-18 04:54:35 +00:00
|
|
|
Constant *getOrInsertFunction(StringRef Name, Type *RetTy, ...)
|
2014-11-04 01:12:21 +00:00
|
|
|
LLVM_END_WITH_NULL;
|
2003-08-31 00:19:18 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Look up the specified function in the module symbol table. If it does not
|
|
|
|
/// exist, return null.
|
2009-11-06 10:58:06 +00:00
|
|
|
Function *getFunction(StringRef Name) const;
|
2002-03-29 03:32:29 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
2008-04-16 20:45:31 +00:00
|
|
|
/// @name Global Variable Accessors
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Look up the specified global variable in the module symbol table. If it
|
|
|
|
/// does not exist, return null. If AllowInternal is set to true, this
|
|
|
|
/// function will return types that have InternalLinkage. By default, these
|
|
|
|
/// types are not returned.
|
2014-11-07 21:32:08 +00:00
|
|
|
GlobalVariable *getGlobalVariable(StringRef Name) const {
|
|
|
|
return getGlobalVariable(Name, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
GlobalVariable *getGlobalVariable(StringRef Name, bool AllowInternal) const {
|
2013-07-25 02:50:08 +00:00
|
|
|
return const_cast<Module *>(this)->getGlobalVariable(Name, AllowInternal);
|
|
|
|
}
|
|
|
|
|
|
|
|
GlobalVariable *getGlobalVariable(StringRef Name, bool AllowInternal = false);
|
2003-12-31 08:42:27 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return the global variable in the module with the specified name, of
|
|
|
|
/// arbitrary type. This method returns null if a global with the specified
|
|
|
|
/// name is not found.
|
2013-07-25 02:50:08 +00:00
|
|
|
GlobalVariable *getNamedGlobal(StringRef Name) {
|
2007-02-05 20:47:22 +00:00
|
|
|
return getGlobalVariable(Name, true);
|
|
|
|
}
|
2013-07-25 02:50:08 +00:00
|
|
|
const GlobalVariable *getNamedGlobal(StringRef Name) const {
|
|
|
|
return const_cast<Module *>(this)->getNamedGlobal(Name);
|
|
|
|
}
|
2007-04-25 14:27:10 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Look up the specified global in the module symbol table.
|
2008-11-04 22:51:24 +00:00
|
|
|
/// 1. If it does not exist, add a declaration of the global and return it.
|
|
|
|
/// 2. Else, the global exists but has the wrong type: return the function
|
|
|
|
/// with a constantexpr cast to the right type.
|
2011-04-06 20:54:07 +00:00
|
|
|
/// 3. Finally, if the existing global is the correct declaration, return
|
2008-11-04 22:51:24 +00:00
|
|
|
/// the existing global.
|
2011-07-18 04:54:35 +00:00
|
|
|
Constant *getOrInsertGlobal(StringRef Name, Type *Ty);
|
2008-11-04 22:51:24 +00:00
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
/// @}
|
2008-04-16 20:45:31 +00:00
|
|
|
/// @name Global Alias Accessors
|
2007-04-25 14:27:10 +00:00
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return the global alias in the module with the specified name, of
|
|
|
|
/// arbitrary type. This method returns null if a global with the specified
|
|
|
|
/// name is not found.
|
2009-11-06 10:58:06 +00:00
|
|
|
GlobalAlias *getNamedAlias(StringRef Name) const;
|
2008-04-16 20:45:31 +00:00
|
|
|
|
2009-07-29 17:16:17 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Named Metadata Accessors
|
|
|
|
/// @{
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return the first NamedMDNode in the module with the specified name. This
|
|
|
|
/// method returns null if a NamedMDNode with the specified name is not found.
|
2010-06-22 01:19:38 +00:00
|
|
|
NamedMDNode *getNamedMetadata(const Twine &Name) const;
|
2009-07-29 17:16:17 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Return the named MDNode in the module with the specified name. This method
|
|
|
|
/// returns a new NamedMDNode if a NamedMDNode with the specified name is not
|
|
|
|
/// found.
|
2009-11-06 10:58:06 +00:00
|
|
|
NamedMDNode *getOrInsertNamedMetadata(StringRef Name);
|
2009-07-30 23:59:04 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Remove the given NamedMDNode from this module and delete it.
|
2010-07-21 23:38:33 +00:00
|
|
|
void eraseNamedMetadata(NamedMDNode *NMD);
|
|
|
|
|
2014-06-27 18:19:56 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Comdat Accessors
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
/// Return the Comdat in the module with the specified name. It is created
|
|
|
|
/// if it didn't already exist.
|
|
|
|
Comdat *getOrInsertComdat(StringRef Name);
|
|
|
|
|
2012-02-11 11:38:06 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Module Flags Accessors
|
|
|
|
/// @{
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Returns the module flags in the provided vector.
|
2012-02-15 22:34:20 +00:00
|
|
|
void getModuleFlagsMetadata(SmallVectorImpl<ModuleFlagEntry> &Flags) const;
|
|
|
|
|
2013-07-16 23:21:16 +00:00
|
|
|
/// Return the corresponding value if Key appears in module flags, otherwise
|
|
|
|
/// return null.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
Metadata *getModuleFlag(StringRef Key) const;
|
2013-07-16 23:21:16 +00:00
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Returns the NamedMDNode in the module that represents module-level flags.
|
|
|
|
/// This method returns null if there are no module-level flags.
|
2012-02-11 11:38:06 +00:00
|
|
|
NamedMDNode *getModuleFlagsMetadata() const;
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Returns the NamedMDNode in the module that represents module-level flags.
|
|
|
|
/// If module-level flags aren't found, it creates the named metadata that
|
|
|
|
/// contains them.
|
2012-02-11 11:38:06 +00:00
|
|
|
NamedMDNode *getOrInsertModuleFlagsMetadata();
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Add a module-level flag to the module-level flags metadata. It will create
|
|
|
|
/// the module-level flags named metadata if it doesn't already exist.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val);
|
|
|
|
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Constant *Val);
|
2012-02-16 10:28:10 +00:00
|
|
|
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, uint32_t Val);
|
2012-02-11 11:38:06 +00:00
|
|
|
void addModuleFlag(MDNode *Node);
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Materialization
|
|
|
|
/// @{
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Sets the GVMaterializer to GVM. This module must not yet have a
|
|
|
|
/// Materializer. To reset the materializer for a module that already has one,
|
|
|
|
/// call MaterializeAllPermanently first. Destroying this module will destroy
|
|
|
|
/// its materializer without materializing any more GlobalValues. Without
|
|
|
|
/// destroying the Module, there is no way to detach or destroy a materializer
|
|
|
|
/// without materializing all the GVs it controls, to avoid leaving orphan
|
|
|
|
/// unmaterialized GVs.
|
2010-01-27 20:34:15 +00:00
|
|
|
void setMaterializer(GVMaterializer *GVM);
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Retrieves the GVMaterializer, if any, for this Module.
|
2010-01-27 20:34:15 +00:00
|
|
|
GVMaterializer *getMaterializer() const { return Materializer.get(); }
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Returns true if this GV was loaded from this Module's GVMaterializer and
|
|
|
|
/// the GVMaterializer knows how to dematerialize the GV.
|
2010-01-27 20:34:15 +00:00
|
|
|
bool isDematerializable(const GlobalValue *GV) const;
|
|
|
|
|
2014-05-07 16:43:23 +00:00
|
|
|
/// Make sure the GlobalValue is fully read. If the module is corrupt, this
|
|
|
|
/// returns true and fills in the optional string with information about the
|
|
|
|
/// problem. If successful, this returns false.
|
2014-10-24 22:50:48 +00:00
|
|
|
std::error_code materialize(GlobalValue *GV);
|
2014-05-07 16:43:23 +00:00
|
|
|
/// If the GlobalValue is read in, and if the GVMaterializer supports it,
|
|
|
|
/// release the memory for the function, and set it up to be materialized
|
2014-12-05 16:02:06 +00:00
|
|
|
/// lazily. If !isDematerializable(), this method is a no-op.
|
2015-05-15 18:20:14 +00:00
|
|
|
void dematerialize(GlobalValue *GV);
|
2010-01-27 20:34:15 +00:00
|
|
|
|
2014-01-14 23:02:01 +00:00
|
|
|
/// Make sure all GlobalValues in this Module are fully read.
|
2014-06-12 21:46:39 +00:00
|
|
|
std::error_code materializeAll();
|
2010-01-27 20:34:15 +00:00
|
|
|
|
2014-01-14 23:51:27 +00:00
|
|
|
/// Make sure all GlobalValues in this Module are fully read and clear the
|
|
|
|
/// Materializer. If the module is corrupt, this DOES NOT clear the old
|
|
|
|
/// Materializer.
|
2014-08-26 21:49:01 +00:00
|
|
|
std::error_code materializeAllPermanently();
|
2010-01-27 20:34:15 +00:00
|
|
|
|
2015-03-13 21:54:20 +00:00
|
|
|
std::error_code materializeMetadata();
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Direct access to the globals list, functions list, and symbol table
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get the Module's list of global variables (constant).
|
|
|
|
const GlobalListType &getGlobalList() const { return GlobalList; }
|
|
|
|
/// Get the Module's list of global variables.
|
|
|
|
GlobalListType &getGlobalList() { return GlobalList; }
|
2015-06-12 08:19:32 +00:00
|
|
|
static GlobalListType Module::*getSublistAccess(GlobalVariable*) {
|
2009-03-07 10:00:35 +00:00
|
|
|
return &Module::GlobalList;
|
|
|
|
}
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get the Module's list of functions (constant).
|
|
|
|
const FunctionListType &getFunctionList() const { return FunctionList; }
|
|
|
|
/// Get the Module's list of functions.
|
|
|
|
FunctionListType &getFunctionList() { return FunctionList; }
|
2015-06-12 08:19:32 +00:00
|
|
|
static FunctionListType Module::*getSublistAccess(Function*) {
|
2009-03-07 10:00:35 +00:00
|
|
|
return &Module::FunctionList;
|
|
|
|
}
|
2007-04-25 14:27:10 +00:00
|
|
|
/// Get the Module's list of aliases (constant).
|
|
|
|
const AliasListType &getAliasList() const { return AliasList; }
|
|
|
|
/// Get the Module's list of aliases.
|
|
|
|
AliasListType &getAliasList() { return AliasList; }
|
2015-06-12 08:19:32 +00:00
|
|
|
static AliasListType Module::*getSublistAccess(GlobalAlias*) {
|
2009-03-07 10:00:35 +00:00
|
|
|
return &Module::AliasList;
|
|
|
|
}
|
2012-05-16 12:25:43 +00:00
|
|
|
/// Get the Module's list of named metadata (constant).
|
|
|
|
const NamedMDListType &getNamedMDList() const { return NamedMDList; }
|
|
|
|
/// Get the Module's list of named metadata.
|
|
|
|
NamedMDListType &getNamedMDList() { return NamedMDList; }
|
2015-06-12 08:19:32 +00:00
|
|
|
static NamedMDListType Module::*getSublistAccess(NamedMDNode*) {
|
2012-05-16 12:25:43 +00:00
|
|
|
return &Module::NamedMDList;
|
|
|
|
}
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get the symbol table of global variable and function identifiers
|
2007-02-05 20:47:22 +00:00
|
|
|
const ValueSymbolTable &getValueSymbolTable() const { return *ValSymTab; }
|
2006-05-16 06:27:31 +00:00
|
|
|
/// Get the Module's symbol table of global variable and function identifiers.
|
2007-02-05 20:47:22 +00:00
|
|
|
ValueSymbolTable &getValueSymbolTable() { return *ValSymTab; }
|
2014-06-27 18:19:56 +00:00
|
|
|
/// Get the Module's symbol table for COMDATs (constant).
|
|
|
|
const ComdatSymTabType &getComdatSymbolTable() const { return ComdatSymTab; }
|
|
|
|
/// Get the Module's symbol table for COMDATs.
|
|
|
|
ComdatSymTabType &getComdatSymbolTable() { return ComdatSymTab; }
|
2006-05-16 06:27:31 +00:00
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Global Variable Iteration
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2005-05-16 01:49:23 +00:00
|
|
|
global_iterator global_begin() { return GlobalList.begin(); }
|
|
|
|
const_global_iterator global_begin() const { return GlobalList.begin(); }
|
|
|
|
global_iterator global_end () { return GlobalList.end(); }
|
|
|
|
const_global_iterator global_end () const { return GlobalList.end(); }
|
|
|
|
bool global_empty() const { return GlobalList.empty(); }
|
2001-09-10 07:58:01 +00:00
|
|
|
|
2014-03-09 12:20:30 +00:00
|
|
|
iterator_range<global_iterator> globals() {
|
|
|
|
return iterator_range<global_iterator>(global_begin(), global_end());
|
|
|
|
}
|
|
|
|
iterator_range<const_global_iterator> globals() const {
|
|
|
|
return iterator_range<const_global_iterator>(global_begin(), global_end());
|
|
|
|
}
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Function Iteration
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2006-01-24 04:13:11 +00:00
|
|
|
iterator begin() { return FunctionList.begin(); }
|
|
|
|
const_iterator begin() const { return FunctionList.begin(); }
|
|
|
|
iterator end () { return FunctionList.end(); }
|
|
|
|
const_iterator end () const { return FunctionList.end(); }
|
2014-07-28 21:09:32 +00:00
|
|
|
reverse_iterator rbegin() { return FunctionList.rbegin(); }
|
|
|
|
const_reverse_iterator rbegin() const{ return FunctionList.rbegin(); }
|
|
|
|
reverse_iterator rend() { return FunctionList.rend(); }
|
|
|
|
const_reverse_iterator rend() const { return FunctionList.rend(); }
|
2007-04-25 14:27:10 +00:00
|
|
|
size_t size() const { return FunctionList.size(); }
|
2006-01-24 04:13:11 +00:00
|
|
|
bool empty() const { return FunctionList.empty(); }
|
|
|
|
|
2014-11-07 21:32:08 +00:00
|
|
|
iterator_range<iterator> functions() {
|
|
|
|
return iterator_range<iterator>(begin(), end());
|
|
|
|
}
|
|
|
|
iterator_range<const_iterator> functions() const {
|
|
|
|
return iterator_range<const_iterator>(begin(), end());
|
|
|
|
}
|
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Alias Iteration
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
alias_iterator alias_begin() { return AliasList.begin(); }
|
|
|
|
const_alias_iterator alias_begin() const { return AliasList.begin(); }
|
|
|
|
alias_iterator alias_end () { return AliasList.end(); }
|
|
|
|
const_alias_iterator alias_end () const { return AliasList.end(); }
|
|
|
|
size_t alias_size () const { return AliasList.size(); }
|
|
|
|
bool alias_empty() const { return AliasList.empty(); }
|
|
|
|
|
2014-03-09 12:20:30 +00:00
|
|
|
iterator_range<alias_iterator> aliases() {
|
|
|
|
return iterator_range<alias_iterator>(alias_begin(), alias_end());
|
|
|
|
}
|
|
|
|
iterator_range<const_alias_iterator> aliases() const {
|
|
|
|
return iterator_range<const_alias_iterator>(alias_begin(), alias_end());
|
|
|
|
}
|
2009-07-29 17:16:17 +00:00
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Named Metadata Iteration
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
|
|
|
named_metadata_iterator named_metadata_begin() { return NamedMDList.begin(); }
|
|
|
|
const_named_metadata_iterator named_metadata_begin() const {
|
|
|
|
return NamedMDList.begin();
|
|
|
|
}
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2009-12-29 08:06:56 +00:00
|
|
|
named_metadata_iterator named_metadata_end() { return NamedMDList.end(); }
|
|
|
|
const_named_metadata_iterator named_metadata_end() const {
|
|
|
|
return NamedMDList.end();
|
|
|
|
}
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2009-12-29 08:06:56 +00:00
|
|
|
size_t named_metadata_size() const { return NamedMDList.size(); }
|
|
|
|
bool named_metadata_empty() const { return NamedMDList.empty(); }
|
2009-07-29 17:16:17 +00:00
|
|
|
|
2014-03-09 12:20:30 +00:00
|
|
|
iterator_range<named_metadata_iterator> named_metadata() {
|
|
|
|
return iterator_range<named_metadata_iterator>(named_metadata_begin(),
|
|
|
|
named_metadata_end());
|
|
|
|
}
|
|
|
|
iterator_range<const_named_metadata_iterator> named_metadata() const {
|
|
|
|
return iterator_range<const_named_metadata_iterator>(named_metadata_begin(),
|
|
|
|
named_metadata_end());
|
|
|
|
}
|
2009-07-29 17:16:17 +00:00
|
|
|
|
2015-01-20 19:24:59 +00:00
|
|
|
/// Destroy ConstantArrays in LLVMContext if they are not used.
|
|
|
|
/// ConstantArrays constructed during linking can cause quadratic memory
|
|
|
|
/// explosion. Releasing all unused constants can cause a 20% LTO compile-time
|
|
|
|
/// slowdown for a large application.
|
|
|
|
///
|
|
|
|
/// NOTE: Constants are currently owned by LLVMContext. This can then only
|
|
|
|
/// be called where all uses of the LLVMContext are understood.
|
|
|
|
void dropTriviallyDeadConstantArrays();
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Utility functions for printing and dumping Module objects
|
|
|
|
/// @{
|
2009-12-29 08:06:56 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
/// Print the module to an output stream with an optional
|
2015-04-15 02:12:41 +00:00
|
|
|
/// AssemblyAnnotationWriter. If \c ShouldPreserveUseListOrder, then include
|
|
|
|
/// uselistorder directives so that use-lists can be recreated when reading
|
|
|
|
/// the assembly.
|
|
|
|
void print(raw_ostream &OS, AssemblyAnnotationWriter *AAW,
|
|
|
|
bool ShouldPreserveUseListOrder = false) const;
|
2010-06-25 21:02:24 +00:00
|
|
|
|
2008-08-23 22:23:09 +00:00
|
|
|
/// Dump the module to stderr (for debugging).
|
2002-08-17 23:32:42 +00:00
|
|
|
void dump() const;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// This function causes all the subinstructions to "let go" of all references
|
2008-04-16 20:45:31 +00:00
|
|
|
/// that they are maintaining. This allows one to 'delete' a whole class at
|
|
|
|
/// a time, even though there may be circular references... first all
|
|
|
|
/// references are dropped, and all use counts go to zero. Then everything
|
|
|
|
/// is delete'd for real. Note that no operations are valid on an object
|
2006-05-16 06:27:31 +00:00
|
|
|
/// that has "dropped all references", except operator delete.
|
2001-06-06 20:29:01 +00:00
|
|
|
void dropAllReferences();
|
2014-04-17 22:33:50 +00:00
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Utility functions for querying Debug information.
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
/// \brief Returns the Dwarf Version by checking module flags.
|
|
|
|
unsigned getDwarfVersion() const;
|
|
|
|
|
2006-05-16 06:27:31 +00:00
|
|
|
/// @}
|
2014-11-07 04:46:10 +00:00
|
|
|
/// @name Utility functions for querying and setting PIC level
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
/// \brief Returns the PIC level (small or large model)
|
|
|
|
PICLevel::Level getPICLevel() const;
|
|
|
|
|
|
|
|
/// \brief Set the PIC level (small or large model)
|
|
|
|
void setPICLevel(PICLevel::Level PL);
|
|
|
|
/// @}
|
2001-06-06 20:29:01 +00:00
|
|
|
};
|
|
|
|
|
2009-08-23 04:52:46 +00:00
|
|
|
/// An raw_ostream inserter for modules.
|
2008-08-23 22:23:09 +00:00
|
|
|
inline raw_ostream &operator<<(raw_ostream &O, const Module &M) {
|
2014-04-09 06:08:46 +00:00
|
|
|
M.print(O, nullptr);
|
2002-07-03 16:52:15 +00:00
|
|
|
return O;
|
|
|
|
}
|
2007-04-25 14:27:10 +00:00
|
|
|
|
2013-05-01 20:59:00 +00:00
|
|
|
// Create wrappers for C Binding types (see CBindingWrapping.h).
|
|
|
|
DEFINE_SIMPLE_CONVERSION_FUNCTIONS(Module, LLVMModuleRef)
|
|
|
|
|
|
|
|
/* LLVMModuleProviderRef exists for historical reasons, but now just holds a
|
|
|
|
* Module.
|
|
|
|
*/
|
|
|
|
inline Module *unwrap(LLVMModuleProviderRef MP) {
|
|
|
|
return reinterpret_cast<Module*>(MP);
|
|
|
|
}
|
|
|
|
|
2015-06-23 09:49:53 +00:00
|
|
|
} // End llvm namespace
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
#endif
|