2012-02-25 07:20:06 +00:00
|
|
|
//===-- Verifier.cpp - Implement the Module Verifier -----------------------==//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2002-03-29 19:06:18 +00:00
|
|
|
// This file defines the function verifier interface, that can be used for some
|
2001-06-06 20:29:01 +00:00
|
|
|
// sanity checking of input to the system.
|
|
|
|
//
|
2004-06-24 21:47:35 +00:00
|
|
|
// Note that this does not provide full `Java style' security and verifications,
|
|
|
|
// instead it just tries to ensure that code is well-formed.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2004-06-24 21:47:35 +00:00
|
|
|
// * Both of a binary operator's parameters are of the same type
|
2002-04-24 19:12:21 +00:00
|
|
|
// * Verify that the indices of mem access instructions match other operands
|
2004-06-24 21:47:35 +00:00
|
|
|
// * Verify that arithmetic and other things are only performed on first-class
|
2002-08-02 17:37:08 +00:00
|
|
|
// types. Verify that shifts & logicals only happen on integrals f.e.
|
2004-06-24 21:47:35 +00:00
|
|
|
// * All of the constants in a switch statement are of the correct type
|
2002-08-02 17:37:08 +00:00
|
|
|
// * The code is in valid SSA form
|
2004-06-24 21:47:35 +00:00
|
|
|
// * It should be illegal to put a label into any other type (like a structure)
|
2001-06-06 20:29:01 +00:00
|
|
|
// or to return one. [except constant arrays!]
|
2008-03-28 06:46:51 +00:00
|
|
|
// * Only phi nodes can be self referential: 'add i32 %0, %0 ; <int>:0' is bad
|
2002-02-20 17:55:43 +00:00
|
|
|
// * PHI nodes must have an entry for each predecessor, with no extras.
|
2002-06-25 15:56:27 +00:00
|
|
|
// * PHI nodes must be the first thing in a basic block, all grouped together
|
2002-10-06 21:00:31 +00:00
|
|
|
// * PHI nodes must have at least one entry
|
2002-06-25 15:56:27 +00:00
|
|
|
// * All basic blocks should only end with terminator insts, not contain them
|
2002-03-29 19:06:18 +00:00
|
|
|
// * The entry node to a function must not have predecessors
|
2003-10-10 17:54:14 +00:00
|
|
|
// * All Instructions must be embedded into a basic block
|
2004-06-24 21:47:35 +00:00
|
|
|
// * Functions cannot take a void-typed parameter
|
2002-04-13 22:48:46 +00:00
|
|
|
// * Verify that a function's argument list agrees with it's declared type.
|
2002-03-15 20:25:09 +00:00
|
|
|
// * It is illegal to specify a name for a void value.
|
2003-10-10 17:54:14 +00:00
|
|
|
// * It is illegal to have a internal global value with no initializer
|
2002-04-12 18:20:49 +00:00
|
|
|
// * It is illegal to have a ret instruction that returns a value that does not
|
|
|
|
// agree with the function return value type.
|
2002-05-08 19:49:50 +00:00
|
|
|
// * Function call argument types match the function prototype
|
2011-08-12 20:24:12 +00:00
|
|
|
// * A landing pad is defined by a landingpad instruction, and can be jumped to
|
|
|
|
// only by the unwind edge of an invoke instruction.
|
|
|
|
// * A landingpad instruction must be the first non-PHI instruction in the
|
|
|
|
// block.
|
|
|
|
// * All landingpad instructions must use the same personality function with
|
|
|
|
// the same function.
|
2002-04-24 19:12:21 +00:00
|
|
|
// * All other things that are tested by asserts spread about the code...
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-01-13 09:26:24 +00:00
|
|
|
#include "llvm/IR/Verifier.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/SetVector.h"
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2014-03-04 11:45:46 +00:00
|
|
|
#include "llvm/IR/CFG.h"
|
2014-03-04 11:01:28 +00:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/CallingConv.h"
|
2014-03-04 12:24:34 +00:00
|
|
|
#include "llvm/IR/ConstantRange.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Constants.h"
|
2013-07-31 17:49:08 +00:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-03-06 00:46:21 +00:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-01-13 09:26:24 +00:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/InlineAsm.h"
|
2014-04-15 16:27:38 +00:00
|
|
|
#include "llvm/IR/InstIterator.h"
|
2014-03-06 03:23:41 +00:00
|
|
|
#include "llvm/IR/InstVisitor.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
#include "llvm/IR/Metadata.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
2014-01-20 11:34:08 +00:00
|
|
|
#include "llvm/IR/PassManager.h"
|
2014-12-03 19:53:15 +00:00
|
|
|
#include "llvm/IR/Statepoint.h"
|
2008-03-12 17:45:29 +00:00
|
|
|
#include "llvm/Pass.h"
|
2013-07-19 00:31:03 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-08 18:01:40 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-02-28 21:05:51 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2002-02-20 17:55:43 +00:00
|
|
|
#include <algorithm>
|
2006-03-31 07:22:05 +00:00
|
|
|
#include <cstdarg>
|
2003-11-21 20:23:48 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2015-03-17 17:28:41 +00:00
|
|
|
static cl::opt<bool> VerifyDebugInfo("verify-debug-info", cl::init(true));
|
2013-07-19 00:31:03 +00:00
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
namespace {
|
2014-04-15 16:27:32 +00:00
|
|
|
struct VerifierSupport {
|
2014-01-19 02:22:18 +00:00
|
|
|
raw_ostream &OS;
|
|
|
|
const Module *M;
|
2014-04-15 16:27:32 +00:00
|
|
|
|
|
|
|
/// \brief Track the brokenness of the module while recursively visiting.
|
|
|
|
bool Broken;
|
|
|
|
|
|
|
|
explicit VerifierSupport(raw_ostream &OS)
|
2015-03-31 02:37:13 +00:00
|
|
|
: OS(OS), M(nullptr), Broken(false) {}
|
2014-04-15 16:27:32 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
private:
|
|
|
|
void Write(const Value *V) {
|
2014-04-15 16:27:32 +00:00
|
|
|
if (!V)
|
|
|
|
return;
|
|
|
|
if (isa<Instruction>(V)) {
|
|
|
|
OS << *V << '\n';
|
|
|
|
} else {
|
|
|
|
V->printAsOperand(OS, true, M);
|
|
|
|
OS << '\n';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
void Write(const Metadata *MD) {
|
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
|
|
|
if (!MD)
|
|
|
|
return;
|
IR: Make Metadata::print() reliable and useful
Replumb the `AsmWriter` so that `Metadata::print()` is generally useful.
(Similarly change `Metadata::printAsOperand()`.)
- `SlotTracker` now has a mode where all metadata will be correctly
numbered when initializing a `Module`. Normally, `Metadata` only
referenced from within `Function`s gets numbered when the `Function`
is incorporated.
- `Metadata::print()` and `Metadata::printAsOperand()` (and
`Metadata::dump()`) now take an optional `Module` argument. When
provided, `SlotTracker` is initialized with the new mode, and the
numbering will be complete and consistent for all calls to `print()`.
- `Value::print()` uses the new `SlotTracker` mode when printing
intrinsics with `MDNode` operands, `MetadataAsValue` operands, or the
bodies of functions. Thus, metadata numbering will be consistent
between calls to `Metadata::print()` and `Value::print()`.
- `Metadata::print()` (and `Metadata::dump()`) now print the full
definition of `MDNode`s:
!5 = !{!6, !"abc", !7}
This matches behaviour for `Value::print()`, which includes the name
of instructions.
- Updated call sites in `Verifier` to call `print()` instead of
`printAsOperand()`.
All this, so that `Verifier` can print out useful failure messages that
involve `Metadata` for PR22777.
Note that `Metadata::printAsOperand()` previously took an optional
`bool` and `Module` operand. The former was cargo-culted from
`Value::printAsOperand()` and wasn't doing anything useful. The latter
didn't give consistent results (without the new `SlotTracker` mode).
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232275 91177308-0d34-0410-b5e6-96231b3b80d8
2015-03-14 20:19:36 +00:00
|
|
|
MD->print(OS, M);
|
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
|
|
|
OS << '\n';
|
|
|
|
}
|
|
|
|
|
2015-03-24 17:18:03 +00:00
|
|
|
void Write(const NamedMDNode *NMD) {
|
|
|
|
if (!NMD)
|
|
|
|
return;
|
|
|
|
NMD->print(OS);
|
|
|
|
OS << '\n';
|
|
|
|
}
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
void Write(Type *T) {
|
2014-04-15 16:27:32 +00:00
|
|
|
if (!T)
|
|
|
|
return;
|
|
|
|
OS << ' ' << *T;
|
|
|
|
}
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
void Write(const Comdat *C) {
|
2014-06-27 18:19:56 +00:00
|
|
|
if (!C)
|
|
|
|
return;
|
|
|
|
OS << *C;
|
|
|
|
}
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
template <typename T1, typename... Ts>
|
|
|
|
void WriteTs(const T1 &V1, const Ts &... Vs) {
|
|
|
|
Write(V1);
|
|
|
|
WriteTs(Vs...);
|
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
|
|
|
}
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
template <typename... Ts> void WriteTs() {}
|
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
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
public:
|
2015-03-16 17:49:03 +00:00
|
|
|
/// \brief A check failed, so printout out the condition and the message.
|
|
|
|
///
|
|
|
|
/// This provides a nice place to put a breakpoint if you want to see why
|
|
|
|
/// something is not correct.
|
2015-03-14 16:47:37 +00:00
|
|
|
void CheckFailed(const Twine &Message) {
|
2015-03-07 21:15:40 +00:00
|
|
|
OS << Message << '\n';
|
2015-03-31 02:37:13 +00:00
|
|
|
Broken = true;
|
2014-06-27 18:19:56 +00:00
|
|
|
}
|
2015-03-14 16:47:37 +00:00
|
|
|
|
2015-03-16 17:49:03 +00:00
|
|
|
/// \brief A check failed (with values to print).
|
|
|
|
///
|
|
|
|
/// This calls the Message-only version so that the above is easier to set a
|
|
|
|
/// breakpoint on.
|
2015-03-14 16:47:37 +00:00
|
|
|
template <typename T1, typename... Ts>
|
|
|
|
void CheckFailed(const Twine &Message, const T1 &V1, const Ts &... Vs) {
|
|
|
|
CheckFailed(Message);
|
|
|
|
WriteTs(V1, Vs...);
|
|
|
|
}
|
2014-04-15 16:27:32 +00:00
|
|
|
};
|
2015-03-07 21:15:40 +00:00
|
|
|
|
2014-04-15 16:27:32 +00:00
|
|
|
class Verifier : public InstVisitor<Verifier>, VerifierSupport {
|
|
|
|
friend class InstVisitor<Verifier>;
|
|
|
|
|
2014-01-17 11:09:34 +00:00
|
|
|
LLVMContext *Context;
|
|
|
|
DominatorTree DT;
|
|
|
|
|
|
|
|
/// \brief When verifying a basic block, keep track of all of the
|
|
|
|
/// instructions we have seen so far.
|
|
|
|
///
|
|
|
|
/// This allows us to do efficient dominance checks for the case when an
|
|
|
|
/// instruction has an operand that is an instruction in the same block.
|
|
|
|
SmallPtrSet<Instruction *, 16> InstsInThisBlock;
|
|
|
|
|
|
|
|
/// \brief Keep track of the metadata nodes that have been checked already.
|
2015-02-09 21:30:05 +00:00
|
|
|
SmallPtrSet<const Metadata *, 32> MDNodes;
|
2014-01-17 11:09:34 +00:00
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
/// \brief Track string-based type references.
|
|
|
|
SmallDenseMap<const MDString *, const MDNode *, 32> TypeRefs;
|
|
|
|
|
2014-01-17 11:09:34 +00:00
|
|
|
/// \brief The personality function referenced by the LandingPadInsts.
|
|
|
|
/// All LandingPadInsts within the same function must use the same
|
|
|
|
/// personality function.
|
|
|
|
const Value *PersonalityFn;
|
|
|
|
|
2015-03-05 18:26:34 +00:00
|
|
|
/// \brief Whether we've seen a call to @llvm.frameescape in this function
|
2015-01-13 00:48:10 +00:00
|
|
|
/// already.
|
2015-03-05 18:26:34 +00:00
|
|
|
bool SawFrameEscape;
|
|
|
|
|
|
|
|
/// Stores the count of how many objects were passed to llvm.frameescape for a
|
|
|
|
/// given function and the largest index passed to llvm.framerecover.
|
|
|
|
DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
|
2015-01-13 00:48:10 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
public:
|
2015-03-15 00:46:57 +00:00
|
|
|
explicit Verifier(raw_ostream &OS)
|
2015-01-13 00:48:10 +00:00
|
|
|
: VerifierSupport(OS), Context(nullptr), PersonalityFn(nullptr),
|
2015-03-05 18:26:34 +00:00
|
|
|
SawFrameEscape(false) {}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
bool verify(const Function &F) {
|
|
|
|
M = F.getParent();
|
|
|
|
Context = &M->getContext();
|
2014-01-17 11:09:34 +00:00
|
|
|
|
|
|
|
// First ensure the function is well-enough formed to compute dominance
|
|
|
|
// information.
|
2014-01-19 02:22:18 +00:00
|
|
|
if (F.empty()) {
|
|
|
|
OS << "Function '" << F.getName()
|
|
|
|
<< "' does not contain an entry block!\n";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
for (Function::const_iterator I = F.begin(), E = F.end(); I != E; ++I) {
|
2014-01-17 11:09:34 +00:00
|
|
|
if (I->empty() || !I->back().isTerminator()) {
|
2014-01-19 02:22:18 +00:00
|
|
|
OS << "Basic Block in function '" << F.getName()
|
|
|
|
<< "' does not have terminator!\n";
|
|
|
|
I->printAsOperand(OS, true);
|
|
|
|
OS << "\n";
|
|
|
|
return false;
|
2014-01-17 10:56:02 +00:00
|
|
|
}
|
2014-01-17 11:09:34 +00:00
|
|
|
}
|
2007-04-20 23:59:29 +00:00
|
|
|
|
2014-01-17 11:09:34 +00:00
|
|
|
// Now directly compute a dominance tree. We don't rely on the pass
|
|
|
|
// manager to provide this as it isolates us from a potentially
|
|
|
|
// out-of-date dominator tree and makes it significantly more complex to
|
|
|
|
// run this code outside of a pass manager.
|
2014-01-19 02:22:18 +00:00
|
|
|
// FIXME: It's really gross that we have to cast away constness here.
|
|
|
|
DT.recalculate(const_cast<Function &>(F));
|
2013-11-17 18:48:57 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
Broken = false;
|
|
|
|
// FIXME: We strip const here because the inst visitor strips const.
|
|
|
|
visit(const_cast<Function &>(F));
|
2014-01-17 11:09:34 +00:00
|
|
|
InstsInThisBlock.clear();
|
2014-04-09 06:08:46 +00:00
|
|
|
PersonalityFn = nullptr;
|
2015-03-05 18:26:34 +00:00
|
|
|
SawFrameEscape = false;
|
2002-02-20 17:55:43 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
return !Broken;
|
2014-01-17 11:09:34 +00:00
|
|
|
}
|
2004-06-03 06:38:43 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
bool verify(const Module &M) {
|
|
|
|
this->M = &M;
|
|
|
|
Context = &M.getContext();
|
|
|
|
Broken = false;
|
|
|
|
|
2014-01-17 11:09:34 +00:00
|
|
|
// Scan through, checking all of the external function's linkage now...
|
2014-01-19 02:22:18 +00:00
|
|
|
for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
2014-01-17 11:09:34 +00:00
|
|
|
visitGlobalValue(*I);
|
2002-10-06 22:47:32 +00:00
|
|
|
|
2014-01-17 11:09:34 +00:00
|
|
|
// Check to make sure function prototypes are okay.
|
|
|
|
if (I->isDeclaration())
|
|
|
|
visitFunction(*I);
|
|
|
|
}
|
2007-04-25 14:27:10 +00:00
|
|
|
|
2015-03-05 18:26:34 +00:00
|
|
|
// Now that we've visited every function, verify that we never asked to
|
|
|
|
// recover a frame index that wasn't escaped.
|
|
|
|
verifyFrameRecoverIndices();
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
for (Module::const_global_iterator I = M.global_begin(), E = M.global_end();
|
2014-01-17 11:09:34 +00:00
|
|
|
I != E; ++I)
|
|
|
|
visitGlobalVariable(*I);
|
2010-04-29 16:10:30 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end();
|
|
|
|
I != E; ++I)
|
2014-01-17 11:09:34 +00:00
|
|
|
visitGlobalAlias(*I);
|
2013-01-15 01:22:53 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
for (Module::const_named_metadata_iterator I = M.named_metadata_begin(),
|
|
|
|
E = M.named_metadata_end();
|
2014-01-17 11:09:34 +00:00
|
|
|
I != E; ++I)
|
|
|
|
visitNamedMDNode(*I);
|
2013-07-19 00:31:03 +00:00
|
|
|
|
2014-06-27 18:19:56 +00:00
|
|
|
for (const StringMapEntry<Comdat> &SMEC : M.getComdatSymbolTable())
|
|
|
|
visitComdat(SMEC.getValue());
|
|
|
|
|
2014-01-17 11:09:34 +00:00
|
|
|
visitModuleFlags(M);
|
|
|
|
visitModuleIdents(M);
|
2002-04-24 19:12:21 +00:00
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
// Verify type referneces last.
|
|
|
|
verifyTypeRefs();
|
Verifier: Remove the separate DebugInfoVerifier class
Remove the separate `DebugInfoVerifier` class, as a partial step toward
better integrating debug info verification with the `Verifier`.
Right now, verification of debug info is kind of a mess.
- There are `DIDescriptor::Verify()` checks live in `DebugInfo.cpp`.
These return `bool`, and there's no way to see (except by opening a
debugger) why they fail.
- We rely on `DebugInfoFinder` to traverse the debug info graph and
dig up nodes. However, the regular `Verifier` visits many of these
nodes when it calls into debug info intrinsic operands. Visiting
twice and running different checks is kind of absurd.
- Moreover, `DebugInfoFinder` asserts on failed type resolution -- the
verifier should never assert!
By integrating the two verifiers, I'm aiming at solving these problems
(work to be done, obviously). Verification can be localized to the
`Verifier`; we can use a naive `MDNode` operand traversal to find all
the nodes; we can verify type references instead of asserting on
failure.
There are `assert()`s sprinkled throughout the optimizer and dwarf
backend on `DIDescriptor::Verify()` checks. This is a hangover from
when the debug info verifier was off, so I plan to remove them as I go
(once I confirm that the checks are done at verification time).
Note: to keep the behaviour of only running the debug info verifier when
-verify succeeds, I've added an `EverBroken` flag. Once the
`DebugInfoFinder` assertions are gone and the two traversals have been
merged, I expect to be able to remove this.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232790 91177308-0d34-0410-b5e6-96231b3b80d8
2015-03-20 00:48:23 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
return !Broken;
|
2014-01-17 11:09:34 +00:00
|
|
|
}
|
2003-11-21 17:35:51 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
private:
|
2014-01-17 11:09:34 +00:00
|
|
|
// Verification methods...
|
2014-01-19 02:22:18 +00:00
|
|
|
void visitGlobalValue(const GlobalValue &GV);
|
|
|
|
void visitGlobalVariable(const GlobalVariable &GV);
|
|
|
|
void visitGlobalAlias(const GlobalAlias &GA);
|
2014-06-03 02:41:57 +00:00
|
|
|
void visitAliaseeSubExpr(const GlobalAlias &A, const Constant &C);
|
2014-08-21 05:55:13 +00:00
|
|
|
void visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias *> &Visited,
|
2014-06-03 02:41:57 +00:00
|
|
|
const GlobalAlias &A, const Constant &C);
|
2014-01-19 02:22:18 +00:00
|
|
|
void visitNamedMDNode(const NamedMDNode &NMD);
|
2015-02-09 21:30:05 +00:00
|
|
|
void visitMDNode(const MDNode &MD);
|
|
|
|
void visitMetadataAsValue(const MetadataAsValue &MD, Function *F);
|
|
|
|
void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F);
|
2014-06-27 18:19:56 +00:00
|
|
|
void visitComdat(const Comdat &C);
|
2014-01-19 02:22:18 +00:00
|
|
|
void visitModuleIdents(const Module &M);
|
|
|
|
void visitModuleFlags(const Module &M);
|
|
|
|
void visitModuleFlag(const MDNode *Op,
|
|
|
|
DenseMap<const MDString *, const MDNode *> &SeenIDs,
|
|
|
|
SmallVectorImpl<const MDNode *> &Requirements);
|
|
|
|
void visitFunction(const Function &F);
|
2014-01-17 11:09:34 +00:00
|
|
|
void visitBasicBlock(BasicBlock &BB);
|
2014-10-20 23:52:07 +00:00
|
|
|
void visitRangeMetadata(Instruction& I, MDNode* Range, Type* Ty);
|
|
|
|
|
2015-03-30 16:19:15 +00:00
|
|
|
template <class Ty> bool isValidMetadataArray(const MDTuple &N);
|
2015-02-10 01:09:50 +00:00
|
|
|
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) void visit##CLASS(const CLASS &N);
|
|
|
|
#include "llvm/IR/Metadata.def"
|
2015-03-27 23:05:04 +00:00
|
|
|
void visitMDScope(const MDScope &N);
|
|
|
|
void visitMDDerivedTypeBase(const MDDerivedTypeBase &N);
|
2015-03-27 17:29:58 +00:00
|
|
|
void visitMDVariable(const MDVariable &N);
|
2015-03-30 16:37:48 +00:00
|
|
|
void visitMDLexicalBlockBase(const MDLexicalBlockBase &N);
|
2015-03-30 17:21:38 +00:00
|
|
|
void visitMDTemplateParameter(const MDTemplateParameter &N);
|
2014-01-17 11:09:34 +00:00
|
|
|
|
2015-04-06 17:04:58 +00:00
|
|
|
void visitTemplateParams(const MDNode &N, const Metadata &RawParams);
|
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
/// \brief Check for a valid string-based type reference.
|
|
|
|
///
|
|
|
|
/// Checks if \c MD is a string-based type reference. If it is, keeps track
|
|
|
|
/// of it (and its user, \c N) for error messages later.
|
|
|
|
bool isValidUUID(const MDNode &N, const Metadata *MD);
|
|
|
|
|
|
|
|
/// \brief Check for a valid type reference.
|
|
|
|
///
|
|
|
|
/// Checks for subclasses of \a MDType, or \a isValidUUID().
|
|
|
|
bool isTypeRef(const MDNode &N, const Metadata *MD);
|
|
|
|
|
|
|
|
/// \brief Check for a valid scope reference.
|
|
|
|
///
|
|
|
|
/// Checks for subclasses of \a MDScope, or \a isValidUUID().
|
|
|
|
bool isScopeRef(const MDNode &N, const Metadata *MD);
|
|
|
|
|
|
|
|
/// \brief Check for a valid debug info reference.
|
|
|
|
///
|
|
|
|
/// Checks for subclasses of \a DebugNode, or \a isValidUUID().
|
|
|
|
bool isDIRef(const MDNode &N, const Metadata *MD);
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
// InstVisitor overrides...
|
|
|
|
using InstVisitor<Verifier>::visit;
|
2014-01-17 11:09:34 +00:00
|
|
|
void visit(Instruction &I);
|
|
|
|
|
|
|
|
void visitTruncInst(TruncInst &I);
|
|
|
|
void visitZExtInst(ZExtInst &I);
|
|
|
|
void visitSExtInst(SExtInst &I);
|
|
|
|
void visitFPTruncInst(FPTruncInst &I);
|
|
|
|
void visitFPExtInst(FPExtInst &I);
|
|
|
|
void visitFPToUIInst(FPToUIInst &I);
|
|
|
|
void visitFPToSIInst(FPToSIInst &I);
|
|
|
|
void visitUIToFPInst(UIToFPInst &I);
|
|
|
|
void visitSIToFPInst(SIToFPInst &I);
|
|
|
|
void visitIntToPtrInst(IntToPtrInst &I);
|
|
|
|
void visitPtrToIntInst(PtrToIntInst &I);
|
|
|
|
void visitBitCastInst(BitCastInst &I);
|
|
|
|
void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
|
|
|
|
void visitPHINode(PHINode &PN);
|
|
|
|
void visitBinaryOperator(BinaryOperator &B);
|
|
|
|
void visitICmpInst(ICmpInst &IC);
|
|
|
|
void visitFCmpInst(FCmpInst &FC);
|
|
|
|
void visitExtractElementInst(ExtractElementInst &EI);
|
|
|
|
void visitInsertElementInst(InsertElementInst &EI);
|
|
|
|
void visitShuffleVectorInst(ShuffleVectorInst &EI);
|
|
|
|
void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); }
|
|
|
|
void visitCallInst(CallInst &CI);
|
|
|
|
void visitInvokeInst(InvokeInst &II);
|
|
|
|
void visitGetElementPtrInst(GetElementPtrInst &GEP);
|
|
|
|
void visitLoadInst(LoadInst &LI);
|
|
|
|
void visitStoreInst(StoreInst &SI);
|
|
|
|
void verifyDominatesUse(Instruction &I, unsigned i);
|
|
|
|
void visitInstruction(Instruction &I);
|
|
|
|
void visitTerminatorInst(TerminatorInst &I);
|
|
|
|
void visitBranchInst(BranchInst &BI);
|
|
|
|
void visitReturnInst(ReturnInst &RI);
|
|
|
|
void visitSwitchInst(SwitchInst &SI);
|
|
|
|
void visitIndirectBrInst(IndirectBrInst &BI);
|
|
|
|
void visitSelectInst(SelectInst &SI);
|
|
|
|
void visitUserOp1(Instruction &I);
|
|
|
|
void visitUserOp2(Instruction &I) { visitUserOp1(I); }
|
|
|
|
void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI);
|
2015-03-15 01:21:30 +00:00
|
|
|
template <class DbgIntrinsicTy>
|
|
|
|
void visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII);
|
2014-01-17 11:09:34 +00:00
|
|
|
void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
|
|
|
|
void visitAtomicRMWInst(AtomicRMWInst &RMWI);
|
|
|
|
void visitFenceInst(FenceInst &FI);
|
|
|
|
void visitAllocaInst(AllocaInst &AI);
|
|
|
|
void visitExtractValueInst(ExtractValueInst &EVI);
|
|
|
|
void visitInsertValueInst(InsertValueInst &IVI);
|
|
|
|
void visitLandingPadInst(LandingPadInst &LPI);
|
|
|
|
|
|
|
|
void VerifyCallSite(CallSite CS);
|
2014-04-24 20:14:34 +00:00
|
|
|
void verifyMustTailCall(CallInst &CI);
|
2014-01-17 11:09:34 +00:00
|
|
|
bool PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT,
|
|
|
|
unsigned ArgNo, std::string &Suffix);
|
|
|
|
bool VerifyIntrinsicType(Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos,
|
|
|
|
SmallVectorImpl<Type *> &ArgTys);
|
|
|
|
bool VerifyIntrinsicIsVarArg(bool isVarArg,
|
|
|
|
ArrayRef<Intrinsic::IITDescriptor> &Infos);
|
|
|
|
bool VerifyAttributeCount(AttributeSet Attrs, unsigned Params);
|
|
|
|
void VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx, bool isFunction,
|
|
|
|
const Value *V);
|
|
|
|
void VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
|
|
|
|
bool isReturnValue, const Value *V);
|
|
|
|
void VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
|
|
|
|
const Value *V);
|
|
|
|
|
|
|
|
void VerifyConstantExprBitcastType(const ConstantExpr *CE);
|
2015-02-03 23:18:47 +00:00
|
|
|
void VerifyStatepoint(ImmutableCallSite CS);
|
2015-03-05 18:26:34 +00:00
|
|
|
void verifyFrameRecoverIndices();
|
2014-04-15 16:27:38 +00:00
|
|
|
|
Verifier: Remove the separate DebugInfoVerifier class
Remove the separate `DebugInfoVerifier` class, as a partial step toward
better integrating debug info verification with the `Verifier`.
Right now, verification of debug info is kind of a mess.
- There are `DIDescriptor::Verify()` checks live in `DebugInfo.cpp`.
These return `bool`, and there's no way to see (except by opening a
debugger) why they fail.
- We rely on `DebugInfoFinder` to traverse the debug info graph and
dig up nodes. However, the regular `Verifier` visits many of these
nodes when it calls into debug info intrinsic operands. Visiting
twice and running different checks is kind of absurd.
- Moreover, `DebugInfoFinder` asserts on failed type resolution -- the
verifier should never assert!
By integrating the two verifiers, I'm aiming at solving these problems
(work to be done, obviously). Verification can be localized to the
`Verifier`; we can use a naive `MDNode` operand traversal to find all
the nodes; we can verify type references instead of asserting on
failure.
There are `assert()`s sprinkled throughout the optimizer and dwarf
backend on `DIDescriptor::Verify()` checks. This is a hangover from
when the debug info verifier was off, so I plan to remove them as I go
(once I confirm that the checks are done at verification time).
Note: to keep the behaviour of only running the debug info verifier when
-verify succeeds, I've added an `EverBroken` flag. Once the
`DebugInfoFinder` assertions are gone and the two traversals have been
merged, I expect to be able to remove this.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232790 91177308-0d34-0410-b5e6-96231b3b80d8
2015-03-20 00:48:23 +00:00
|
|
|
// Module-level debug info verification...
|
2015-03-31 02:27:32 +00:00
|
|
|
void verifyTypeRefs();
|
|
|
|
void visitUnresolvedTypeRef(const MDString *S, const MDNode *N);
|
2014-01-17 11:09:34 +00:00
|
|
|
};
|
2003-11-21 20:23:48 +00:00
|
|
|
} // End anonymous namespace
|
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// Assert - We know that cond should be true, if not print an error message.
|
2015-03-07 21:15:40 +00:00
|
|
|
#define Assert(C, ...) \
|
|
|
|
do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (0)
|
2002-02-20 17:55:43 +00:00
|
|
|
|
2008-08-28 04:02:44 +00:00
|
|
|
void Verifier::visit(Instruction &I) {
|
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I.getOperand(i) != nullptr, "Operand is null", &I);
|
2008-08-28 04:02:44 +00:00
|
|
|
InstVisitor<Verifier>::visit(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitGlobalValue(const GlobalValue &GV) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GV.isDeclaration() || GV.hasExternalLinkage() ||
|
|
|
|
GV.hasExternalWeakLinkage(),
|
|
|
|
"Global is external, but doesn't have external or weak linkage!", &GV);
|
2006-09-14 18:23:27 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GV.getAlignment() <= Value::MaximumAlignment,
|
|
|
|
"huge alignment values are unsupported", &GV);
|
|
|
|
Assert(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
|
|
|
|
"Only global variables can have appending linkage!", &GV);
|
2003-04-16 20:42:40 +00:00
|
|
|
|
|
|
|
if (GV.hasAppendingLinkage()) {
|
2014-01-19 02:22:18 +00:00
|
|
|
const GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GVar && GVar->getType()->getElementType()->isArrayTy(),
|
|
|
|
"Only global arrays can have appending linkage!", GVar);
|
2003-04-16 20:42:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitGlobalVariable(const GlobalVariable &GV) {
|
2007-09-19 17:14:45 +00:00
|
|
|
if (GV.hasInitializer()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GV.getInitializer()->getType() == GV.getType()->getElementType(),
|
|
|
|
"Global variable initializer type does not match global "
|
|
|
|
"variable type!",
|
|
|
|
&GV);
|
2009-05-30 05:06:04 +00:00
|
|
|
|
2009-08-05 05:41:44 +00:00
|
|
|
// If the global has common linkage, it must have a zero initializer and
|
|
|
|
// cannot be constant.
|
|
|
|
if (GV.hasCommonLinkage()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GV.getInitializer()->isNullValue(),
|
|
|
|
"'common' global must have a zero initializer!", &GV);
|
|
|
|
Assert(!GV.isConstant(), "'common' global may not be marked constant!",
|
|
|
|
&GV);
|
|
|
|
Assert(!GV.hasComdat(), "'common' global may not be in a Comdat!", &GV);
|
2009-08-05 05:41:44 +00:00
|
|
|
}
|
2007-09-19 17:14:45 +00:00
|
|
|
} else {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GV.hasExternalLinkage() || GV.hasExternalWeakLinkage(),
|
|
|
|
"invalid linkage type for global declaration", &GV);
|
2007-09-19 17:14:45 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2011-04-08 07:30:21 +00:00
|
|
|
if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
|
|
|
|
GV.getName() == "llvm.global_dtors")) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
|
|
|
|
"invalid linkage for intrinsic global variable", &GV);
|
2011-04-08 07:30:21 +00:00
|
|
|
// Don't worry about emitting an error for it not being an array,
|
|
|
|
// visitGlobalValue will complain on appending non-array.
|
2014-05-16 20:39:27 +00:00
|
|
|
if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getType()->getElementType())) {
|
2011-07-18 04:54:35 +00:00
|
|
|
StructType *STy = dyn_cast<StructType>(ATy->getElementType());
|
|
|
|
PointerType *FuncPtrTy =
|
2012-10-24 17:25:11 +00:00
|
|
|
FunctionType::get(Type::getVoidTy(*Context), false)->getPointerTo();
|
2014-05-16 20:39:27 +00:00
|
|
|
// FIXME: Reject the 2-field form in LLVM 4.0.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(STy &&
|
|
|
|
(STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
|
|
|
|
STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
|
|
|
|
STy->getTypeAtIndex(1) == FuncPtrTy,
|
|
|
|
"wrong type for intrinsic global variable", &GV);
|
2014-05-16 20:39:27 +00:00
|
|
|
if (STy->getNumElements() == 3) {
|
|
|
|
Type *ETy = STy->getTypeAtIndex(2);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ETy->isPointerTy() &&
|
|
|
|
cast<PointerType>(ETy)->getElementType()->isIntegerTy(8),
|
|
|
|
"wrong type for intrinsic global variable", &GV);
|
2014-05-16 20:39:27 +00:00
|
|
|
}
|
2011-04-08 07:30:21 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-22 15:16:51 +00:00
|
|
|
if (GV.hasName() && (GV.getName() == "llvm.used" ||
|
2013-07-19 18:44:51 +00:00
|
|
|
GV.getName() == "llvm.compiler.used")) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
|
|
|
|
"invalid linkage for intrinsic global variable", &GV);
|
2013-04-22 14:58:02 +00:00
|
|
|
Type *GVType = GV.getType()->getElementType();
|
|
|
|
if (ArrayType *ATy = dyn_cast<ArrayType>(GVType)) {
|
|
|
|
PointerType *PTy = dyn_cast<PointerType>(ATy->getElementType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PTy, "wrong type for intrinsic global variable", &GV);
|
2013-04-22 14:58:02 +00:00
|
|
|
if (GV.hasInitializer()) {
|
2014-01-19 02:22:18 +00:00
|
|
|
const Constant *Init = GV.getInitializer();
|
|
|
|
const ConstantArray *InitArray = dyn_cast<ConstantArray>(Init);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(InitArray, "wrong initalizer for intrinsic global variable",
|
|
|
|
Init);
|
2013-04-22 14:58:02 +00:00
|
|
|
for (unsigned i = 0, e = InitArray->getNumOperands(); i != e; ++i) {
|
2013-05-27 22:47:09 +00:00
|
|
|
Value *V = Init->getOperand(i)->stripPointerCastsNoFollowAliases();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<GlobalVariable>(V) || isa<Function>(V) ||
|
|
|
|
isa<GlobalAlias>(V),
|
|
|
|
"invalid llvm.used member", V);
|
|
|
|
Assert(V->hasName(), "members of llvm.used must be named", V);
|
2013-04-22 14:58:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GV.hasDLLImportStorageClass() ||
|
|
|
|
(GV.isDeclaration() && GV.hasExternalLinkage()) ||
|
|
|
|
GV.hasAvailableExternallyLinkage(),
|
|
|
|
"Global is marked as dllimport, but not external", &GV);
|
2014-01-14 15:22:47 +00:00
|
|
|
|
2013-07-31 17:49:08 +00:00
|
|
|
if (!GV.hasInitializer()) {
|
|
|
|
visitGlobalValue(GV);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Walk any aggregate initializers looking for bitcasts between address spaces
|
|
|
|
SmallPtrSet<const Value *, 4> Visited;
|
|
|
|
SmallVector<const Value *, 4> WorkStack;
|
|
|
|
WorkStack.push_back(cast<Value>(GV.getInitializer()));
|
|
|
|
|
|
|
|
while (!WorkStack.empty()) {
|
|
|
|
const Value *V = WorkStack.pop_back_val();
|
2014-11-19 07:49:26 +00:00
|
|
|
if (!Visited.insert(V).second)
|
2013-07-31 17:49:08 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (const User *U = dyn_cast<User>(V)) {
|
2015-02-17 15:29:18 +00:00
|
|
|
WorkStack.append(U->op_begin(), U->op_end());
|
2013-07-31 17:49:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
|
|
|
|
VerifyConstantExprBitcastType(CE);
|
|
|
|
if (Broken)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-15 20:23:49 +00:00
|
|
|
visitGlobalValue(GV);
|
|
|
|
}
|
|
|
|
|
2014-06-03 02:41:57 +00:00
|
|
|
void Verifier::visitAliaseeSubExpr(const GlobalAlias &GA, const Constant &C) {
|
|
|
|
SmallPtrSet<const GlobalAlias*, 4> Visited;
|
|
|
|
Visited.insert(&GA);
|
|
|
|
visitAliaseeSubExpr(Visited, GA, C);
|
|
|
|
}
|
|
|
|
|
2014-08-21 05:55:13 +00:00
|
|
|
void Verifier::visitAliaseeSubExpr(SmallPtrSetImpl<const GlobalAlias*> &Visited,
|
2014-06-03 02:41:57 +00:00
|
|
|
const GlobalAlias &GA, const Constant &C) {
|
|
|
|
if (const auto *GV = dyn_cast<GlobalValue>(&C)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GV->isDeclaration(), "Alias must point to a definition", &GA);
|
2014-06-03 02:41:57 +00:00
|
|
|
|
|
|
|
if (const auto *GA2 = dyn_cast<GlobalAlias>(GV)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Visited.insert(GA2).second, "Aliases cannot form a cycle", &GA);
|
2014-06-03 02:41:57 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GA2->mayBeOverridden(), "Alias cannot point to a weak alias",
|
|
|
|
&GA);
|
2014-06-12 01:46:54 +00:00
|
|
|
} else {
|
|
|
|
// Only continue verifying subexpressions of GlobalAliases.
|
|
|
|
// Do not recurse into global initializers.
|
|
|
|
return;
|
2014-06-03 02:41:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const auto *CE = dyn_cast<ConstantExpr>(&C))
|
|
|
|
VerifyConstantExprBitcastType(CE);
|
|
|
|
|
|
|
|
for (const Use &U : C.operands()) {
|
|
|
|
Value *V = &*U;
|
|
|
|
if (const auto *GA2 = dyn_cast<GlobalAlias>(V))
|
|
|
|
visitAliaseeSubExpr(Visited, GA, *GA2->getAliasee());
|
|
|
|
else if (const auto *C2 = dyn_cast<Constant>(V))
|
|
|
|
visitAliaseeSubExpr(Visited, GA, *C2);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitGlobalAlias(const GlobalAlias &GA) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GA.getName().empty(), "Alias name cannot be empty!", &GA);
|
|
|
|
Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),
|
|
|
|
"Alias should have private, internal, linkonce, weak, linkonce_odr, "
|
|
|
|
"weak_odr, or external linkage!",
|
|
|
|
&GA);
|
2014-01-19 02:22:18 +00:00
|
|
|
const Constant *Aliasee = GA.getAliasee();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Aliasee, "Aliasee cannot be NULL!", &GA);
|
|
|
|
Assert(GA.getType() == Aliasee->getType(),
|
|
|
|
"Alias and aliasee types should match!", &GA);
|
2014-03-12 18:08:14 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<GlobalValue>(Aliasee) || isa<ConstantExpr>(Aliasee),
|
|
|
|
"Aliasee should be either GlobalValue or ConstantExpr", &GA);
|
2013-07-20 17:46:05 +00:00
|
|
|
|
2014-06-03 02:41:57 +00:00
|
|
|
visitAliaseeSubExpr(GA, *Aliasee);
|
2008-03-22 08:36:14 +00:00
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
visitGlobalValue(GA);
|
|
|
|
}
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitNamedMDNode(const NamedMDNode &NMD) {
|
2010-04-29 16:10:30 +00:00
|
|
|
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) {
|
2014-11-11 21:30:22 +00:00
|
|
|
MDNode *MD = NMD.getOperand(i);
|
2010-04-29 16:10:30 +00:00
|
|
|
|
2015-03-24 17:18:03 +00:00
|
|
|
if (NMD.getName() == "llvm.dbg.cu") {
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(MD && isa<MDCompileUnit>(MD), "invalid compile unit", &NMD, MD);
|
2015-03-24 17:18:03 +00:00
|
|
|
}
|
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
if (!MD)
|
|
|
|
continue;
|
|
|
|
|
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
|
|
|
visitMDNode(*MD);
|
2010-04-29 16:10:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-09 21:30:05 +00:00
|
|
|
void Verifier::visitMDNode(const MDNode &MD) {
|
2010-04-29 16:10:30 +00:00
|
|
|
// Only visit each node once. Metadata can be mutually recursive, so this
|
|
|
|
// avoids infinite recursion here, as well as being an optimization.
|
2014-11-19 07:49:26 +00:00
|
|
|
if (!MDNodes.insert(&MD).second)
|
2010-04-29 16:10:30 +00:00
|
|
|
return;
|
|
|
|
|
2015-02-10 01:09:50 +00:00
|
|
|
switch (MD.getMetadataID()) {
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Invalid MDNode subclass");
|
|
|
|
case Metadata::MDTupleKind:
|
|
|
|
break;
|
|
|
|
#define HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS) \
|
|
|
|
case Metadata::CLASS##Kind: \
|
|
|
|
visit##CLASS(cast<CLASS>(MD)); \
|
|
|
|
break;
|
|
|
|
#include "llvm/IR/Metadata.def"
|
|
|
|
}
|
|
|
|
|
2010-04-29 16:10:30 +00:00
|
|
|
for (unsigned i = 0, e = MD.getNumOperands(); i != e; ++i) {
|
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 *Op = MD.getOperand(i);
|
2010-04-29 16:10:30 +00:00
|
|
|
if (!Op)
|
|
|
|
continue;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!isa<LocalAsMetadata>(Op), "Invalid operand for global metadata!",
|
|
|
|
&MD, Op);
|
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
|
|
|
if (auto *N = dyn_cast<MDNode>(Op)) {
|
|
|
|
visitMDNode(*N);
|
2010-04-29 16:10:30 +00:00
|
|
|
continue;
|
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
|
|
|
}
|
|
|
|
if (auto *V = dyn_cast<ValueAsMetadata>(Op)) {
|
|
|
|
visitValueAsMetadata(*V, nullptr);
|
2010-04-29 16:10:30 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
|
|
|
|
// Check these last, so we diagnose problems in operands first.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!MD.isTemporary(), "Expected no forward declarations!", &MD);
|
|
|
|
Assert(MD.isResolved(), "All nodes should be resolved!", &MD);
|
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
|
|
|
}
|
|
|
|
|
2015-02-09 21:30:05 +00:00
|
|
|
void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(MD.getValue(), "Expected valid value", &MD);
|
|
|
|
Assert(!MD.getValue()->getType()->isMetadataTy(),
|
|
|
|
"Unexpected metadata round-trip through values", &MD, MD.getValue());
|
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
|
|
|
|
|
|
|
auto *L = dyn_cast<LocalAsMetadata>(&MD);
|
|
|
|
if (!L)
|
|
|
|
return;
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(F, "function-local metadata used outside a function", L);
|
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
|
|
|
|
|
|
|
// If this was an instruction, bb, or argument, verify that it is in the
|
|
|
|
// function that we expect.
|
|
|
|
Function *ActualF = nullptr;
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(L->getValue())) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I->getParent(), "function-local metadata not in basic block", L, I);
|
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
|
|
|
ActualF = I->getParent()->getParent();
|
|
|
|
} else if (BasicBlock *BB = dyn_cast<BasicBlock>(L->getValue()))
|
|
|
|
ActualF = BB->getParent();
|
|
|
|
else if (Argument *A = dyn_cast<Argument>(L->getValue()))
|
|
|
|
ActualF = A->getParent();
|
|
|
|
assert(ActualF && "Unimplemented function local metadata case!");
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ActualF == F, "function-local metadata used in wrong function", L);
|
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
|
|
|
}
|
|
|
|
|
2015-02-09 21:30:05 +00:00
|
|
|
void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
|
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 *MD = MDV.getMetadata();
|
|
|
|
if (auto *N = dyn_cast<MDNode>(MD)) {
|
|
|
|
visitMDNode(*N);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Only visit each node once. Metadata can be mutually recursive, so this
|
|
|
|
// avoids infinite recursion here, as well as being an optimization.
|
|
|
|
if (!MDNodes.insert(MD).second)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (auto *V = dyn_cast<ValueAsMetadata>(MD))
|
|
|
|
visitValueAsMetadata(*V, F);
|
2010-04-29 16:10:30 +00:00
|
|
|
}
|
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
bool Verifier::isValidUUID(const MDNode &N, const Metadata *MD) {
|
|
|
|
auto *S = dyn_cast<MDString>(MD);
|
|
|
|
if (!S)
|
|
|
|
return false;
|
|
|
|
if (S->getString().empty())
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// Keep track of names of types referenced via UUID so we can check that they
|
|
|
|
// actually exist.
|
|
|
|
TypeRefs.insert(std::make_pair(S, &N));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-03-27 17:29:58 +00:00
|
|
|
/// \brief Check if a value can be a reference to a type.
|
2015-03-31 02:27:32 +00:00
|
|
|
bool Verifier::isTypeRef(const MDNode &N, const Metadata *MD) {
|
|
|
|
return !MD || isValidUUID(N, MD) || isa<MDType>(MD);
|
2015-03-27 17:29:58 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 23:05:04 +00:00
|
|
|
/// \brief Check if a value can be a ScopeRef.
|
2015-03-31 02:27:32 +00:00
|
|
|
bool Verifier::isScopeRef(const MDNode &N, const Metadata *MD) {
|
|
|
|
return !MD || isValidUUID(N, MD) || isa<MDScope>(MD);
|
2015-03-27 23:05:04 +00:00
|
|
|
}
|
|
|
|
|
2015-03-30 17:21:38 +00:00
|
|
|
/// \brief Check if a value can be a debug info ref.
|
2015-03-31 02:27:32 +00:00
|
|
|
bool Verifier::isDIRef(const MDNode &N, const Metadata *MD) {
|
|
|
|
return !MD || isValidUUID(N, MD) || isa<DebugNode>(MD);
|
2015-03-30 17:21:38 +00:00
|
|
|
}
|
|
|
|
|
2015-03-30 16:19:15 +00:00
|
|
|
template <class Ty>
|
|
|
|
bool isValidMetadataArrayImpl(const MDTuple &N, bool AllowNull) {
|
|
|
|
for (Metadata *MD : N.operands()) {
|
|
|
|
if (MD) {
|
|
|
|
if (!isa<Ty>(MD))
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
if (!AllowNull)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class Ty>
|
|
|
|
bool isValidMetadataArray(const MDTuple &N) {
|
|
|
|
return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ false);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class Ty>
|
|
|
|
bool isValidMetadataNullArray(const MDTuple &N) {
|
|
|
|
return isValidMetadataArrayImpl<Ty>(N, /* AllowNull */ true);
|
|
|
|
}
|
|
|
|
|
2015-02-10 01:32:56 +00:00
|
|
|
void Verifier::visitMDLocation(const MDLocation &N) {
|
2015-03-26 22:05:04 +00:00
|
|
|
Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()),
|
|
|
|
"location requires a valid scope", &N, N.getRawScope());
|
|
|
|
if (auto *IA = N.getRawInlinedAt())
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<MDLocation>(IA), "inlined-at should be a location", &N, IA);
|
2015-02-10 01:32:56 +00:00
|
|
|
}
|
|
|
|
|
2015-02-10 01:40:40 +00:00
|
|
|
void Verifier::visitGenericDebugNode(const GenericDebugNode &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag(), "invalid tag", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 23:05:04 +00:00
|
|
|
void Verifier::visitMDScope(const MDScope &N) {
|
|
|
|
if (auto *F = N.getRawFile())
|
|
|
|
Assert(isa<MDFile>(F), "invalid file", &N, F);
|
|
|
|
}
|
|
|
|
|
2015-02-10 01:40:40 +00:00
|
|
|
void Verifier::visitMDSubrange(const MDSubrange &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_subrange_type, "invalid tag", &N);
|
2015-03-27 23:05:04 +00:00
|
|
|
Assert(N.getCount() >= -1, "invalid subrange count", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDEnumerator(const MDEnumerator &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_enumerator, "invalid tag", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDBasicType(const MDBasicType &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_base_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_unspecified_type,
|
|
|
|
"invalid tag", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 23:05:04 +00:00
|
|
|
void Verifier::visitMDDerivedTypeBase(const MDDerivedTypeBase &N) {
|
|
|
|
// Common scope checks.
|
|
|
|
visitMDScope(N);
|
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isScopeRef(N, N.getScope()), "invalid scope", &N, N.getScope());
|
|
|
|
Assert(isTypeRef(N, N.getBaseType()), "invalid base type", &N,
|
|
|
|
N.getBaseType());
|
2015-03-31 00:47:15 +00:00
|
|
|
|
|
|
|
// FIXME: Sink this into the subclass verifies.
|
|
|
|
if (!N.getFile() || N.getFile()->getFilename().empty()) {
|
|
|
|
// Check whether the filename is allowed to be empty.
|
|
|
|
uint16_t Tag = N.getTag();
|
|
|
|
Assert(
|
|
|
|
Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
|
|
|
|
Tag == dwarf::DW_TAG_pointer_type ||
|
|
|
|
Tag == dwarf::DW_TAG_ptr_to_member_type ||
|
|
|
|
Tag == dwarf::DW_TAG_reference_type ||
|
|
|
|
Tag == dwarf::DW_TAG_rvalue_reference_type ||
|
|
|
|
Tag == dwarf::DW_TAG_restrict_type ||
|
|
|
|
Tag == dwarf::DW_TAG_array_type ||
|
|
|
|
Tag == dwarf::DW_TAG_enumeration_type ||
|
|
|
|
Tag == dwarf::DW_TAG_subroutine_type ||
|
|
|
|
Tag == dwarf::DW_TAG_inheritance || Tag == dwarf::DW_TAG_friend ||
|
|
|
|
Tag == dwarf::DW_TAG_structure_type ||
|
|
|
|
Tag == dwarf::DW_TAG_member || Tag == dwarf::DW_TAG_typedef,
|
|
|
|
"derived/composite type requires a filename", &N, N.getFile());
|
|
|
|
}
|
2015-03-27 23:05:04 +00:00
|
|
|
}
|
|
|
|
|
2015-02-10 01:40:40 +00:00
|
|
|
void Verifier::visitMDDerivedType(const MDDerivedType &N) {
|
2015-03-27 23:05:04 +00:00
|
|
|
// Common derived type checks.
|
|
|
|
visitMDDerivedTypeBase(N);
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_typedef ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_pointer_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_ptr_to_member_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_reference_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_rvalue_reference_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_const_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_volatile_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_restrict_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_member ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_inheritance ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_friend,
|
|
|
|
"invalid tag", &N);
|
2015-03-31 00:47:15 +00:00
|
|
|
if (N.getTag() == dwarf::DW_TAG_ptr_to_member_type) {
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isTypeRef(N, N.getExtraData()), "invalid pointer to member type", &N,
|
|
|
|
N.getExtraData());
|
2015-03-31 00:47:15 +00:00
|
|
|
}
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
2015-03-31 01:28:58 +00:00
|
|
|
static bool hasConflictingReferenceFlags(unsigned Flags) {
|
|
|
|
return (Flags & DebugNode::FlagLValueReference) &&
|
|
|
|
(Flags & DebugNode::FlagRValueReference);
|
|
|
|
}
|
|
|
|
|
2015-04-06 17:04:58 +00:00
|
|
|
void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
|
|
|
|
auto *Params = dyn_cast<MDTuple>(&RawParams);
|
|
|
|
Assert(Params, "invalid template params", &N, &RawParams);
|
|
|
|
for (Metadata *Op : Params->operands()) {
|
|
|
|
Assert(Op && isa<MDTemplateParameter>(Op), "invalid template parameter", &N,
|
|
|
|
Params, Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-10 01:40:40 +00:00
|
|
|
void Verifier::visitMDCompositeType(const MDCompositeType &N) {
|
2015-03-27 23:05:04 +00:00
|
|
|
// Common derived type checks.
|
|
|
|
visitMDDerivedTypeBase(N);
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_array_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_structure_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_union_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_enumeration_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_subroutine_type ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_class_type,
|
|
|
|
"invalid tag", &N);
|
2015-03-27 23:05:04 +00:00
|
|
|
|
|
|
|
Assert(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
|
|
|
|
"invalid composite elements", &N, N.getRawElements());
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isTypeRef(N, N.getRawVTableHolder()), "invalid vtable holder", &N,
|
2015-03-27 23:05:04 +00:00
|
|
|
N.getRawVTableHolder());
|
|
|
|
Assert(!N.getRawElements() || isa<MDTuple>(N.getRawElements()),
|
|
|
|
"invalid composite elements", &N, N.getRawElements());
|
2015-03-31 01:28:58 +00:00
|
|
|
Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags",
|
|
|
|
&N);
|
2015-04-06 17:04:58 +00:00
|
|
|
if (auto *Params = N.getRawTemplateParams())
|
|
|
|
visitTemplateParams(N, *Params);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDSubroutineType(const MDSubroutineType &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_subroutine_type, "invalid tag", &N);
|
2015-03-28 02:43:53 +00:00
|
|
|
if (auto *Types = N.getRawTypeArray()) {
|
|
|
|
Assert(isa<MDTuple>(Types), "invalid composite elements", &N, Types);
|
|
|
|
for (Metadata *Ty : N.getTypeArray()->operands()) {
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isTypeRef(N, Ty), "invalid subroutine type ref", &N, Types, Ty);
|
2015-03-28 02:43:53 +00:00
|
|
|
}
|
2015-03-27 23:05:04 +00:00
|
|
|
}
|
2015-03-31 01:28:58 +00:00
|
|
|
Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags",
|
|
|
|
&N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDFile(const MDFile &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_file_type, "invalid tag", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDCompileUnit(const MDCompileUnit &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
|
2015-03-27 23:05:04 +00:00
|
|
|
|
2015-03-31 00:47:15 +00:00
|
|
|
// Don't bother verifying the compilation directory or producer string
|
|
|
|
// as those could be empty.
|
|
|
|
Assert(N.getRawFile() && isa<MDFile>(N.getRawFile()),
|
|
|
|
"invalid file", &N, N.getRawFile());
|
|
|
|
Assert(!N.getFile()->getFilename().empty(), "invalid filename", &N,
|
|
|
|
N.getFile());
|
|
|
|
|
2015-03-27 23:05:04 +00:00
|
|
|
if (auto *Array = N.getRawEnumTypes()) {
|
|
|
|
Assert(isa<MDTuple>(Array), "invalid enum list", &N, Array);
|
|
|
|
for (Metadata *Op : N.getEnumTypes()->operands()) {
|
|
|
|
auto *Enum = dyn_cast_or_null<MDCompositeType>(Op);
|
|
|
|
Assert(Enum && Enum->getTag() == dwarf::DW_TAG_enumeration_type,
|
|
|
|
"invalid enum type", &N, N.getEnumTypes(), Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (auto *Array = N.getRawRetainedTypes()) {
|
|
|
|
Assert(isa<MDTuple>(Array), "invalid retained type list", &N, Array);
|
|
|
|
for (Metadata *Op : N.getRetainedTypes()->operands()) {
|
|
|
|
Assert(Op && isa<MDType>(Op), "invalid retained type", &N, Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (auto *Array = N.getRawSubprograms()) {
|
|
|
|
Assert(isa<MDTuple>(Array), "invalid subprogram list", &N, Array);
|
|
|
|
for (Metadata *Op : N.getSubprograms()->operands()) {
|
|
|
|
Assert(Op && isa<MDSubprogram>(Op), "invalid subprogram ref", &N, Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (auto *Array = N.getRawGlobalVariables()) {
|
|
|
|
Assert(isa<MDTuple>(Array), "invalid global variable list", &N, Array);
|
|
|
|
for (Metadata *Op : N.getGlobalVariables()->operands()) {
|
|
|
|
Assert(Op && isa<MDGlobalVariable>(Op), "invalid global variable ref", &N,
|
|
|
|
Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (auto *Array = N.getRawImportedEntities()) {
|
|
|
|
Assert(isa<MDTuple>(Array), "invalid imported entity list", &N, Array);
|
|
|
|
for (Metadata *Op : N.getImportedEntities()->operands()) {
|
|
|
|
Assert(Op && isa<MDImportedEntity>(Op), "invalid imported entity ref", &N,
|
|
|
|
Op);
|
|
|
|
}
|
|
|
|
}
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDSubprogram(const MDSubprogram &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isScopeRef(N, N.getRawScope()), "invalid scope", &N, N.getRawScope());
|
2015-03-30 16:19:15 +00:00
|
|
|
if (auto *T = N.getRawType())
|
|
|
|
Assert(isa<MDSubroutineType>(T), "invalid subroutine type", &N, T);
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isTypeRef(N, N.getRawContainingType()), "invalid containing type", &N,
|
2015-03-30 16:19:15 +00:00
|
|
|
N.getRawContainingType());
|
|
|
|
if (auto *RawF = N.getRawFunction()) {
|
|
|
|
auto *FMD = dyn_cast<ConstantAsMetadata>(RawF);
|
|
|
|
auto *F = FMD ? FMD->getValue() : nullptr;
|
|
|
|
auto *FT = F ? dyn_cast<PointerType>(F->getType()) : nullptr;
|
2015-03-30 17:04:06 +00:00
|
|
|
Assert(F && FT && isa<FunctionType>(FT->getElementType()),
|
|
|
|
"invalid function", &N, F, FT);
|
2015-03-30 16:19:15 +00:00
|
|
|
}
|
2015-04-06 17:04:58 +00:00
|
|
|
if (auto *Params = N.getRawTemplateParams())
|
|
|
|
visitTemplateParams(N, *Params);
|
2015-03-30 16:19:15 +00:00
|
|
|
if (auto *S = N.getRawDeclaration()) {
|
|
|
|
Assert(isa<MDSubprogram>(S) && !cast<MDSubprogram>(S)->isDefinition(),
|
|
|
|
"invalid subprogram declaration", &N, S);
|
|
|
|
}
|
2015-04-06 17:04:58 +00:00
|
|
|
if (auto *RawVars = N.getRawVariables()) {
|
|
|
|
auto *Vars = dyn_cast<MDTuple>(RawVars);
|
|
|
|
Assert(Vars, "invalid variable list", &N, RawVars);
|
2015-03-30 16:19:15 +00:00
|
|
|
for (Metadata *Op : Vars->operands()) {
|
|
|
|
Assert(Op && isa<MDLocalVariable>(Op), "invalid local variable", &N, Vars,
|
|
|
|
Op);
|
|
|
|
}
|
|
|
|
}
|
2015-03-31 01:28:58 +00:00
|
|
|
Assert(!hasConflictingReferenceFlags(N.getFlags()), "invalid reference flags",
|
|
|
|
&N);
|
2015-03-31 02:09:55 +00:00
|
|
|
|
|
|
|
if (!N.getFunction())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// FIXME: Should this be looking through bitcasts?
|
|
|
|
auto *F = dyn_cast<Function>(N.getFunction()->getValue());
|
|
|
|
if (!F)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Check that all !dbg attachments lead to back to N (or, at least, another
|
|
|
|
// subprogram that describes the same function).
|
|
|
|
//
|
|
|
|
// FIXME: Check this incrementally while visiting !dbg attachments.
|
|
|
|
// FIXME: Only check when N is the canonical subprogram for F.
|
|
|
|
SmallPtrSet<const MDNode *, 32> Seen;
|
|
|
|
for (auto &BB : *F)
|
|
|
|
for (auto &I : BB) {
|
|
|
|
// Be careful about using MDLocation here since we might be dealing with
|
|
|
|
// broken code (this is the Verifier after all).
|
|
|
|
MDLocation *DL =
|
|
|
|
dyn_cast_or_null<MDLocation>(I.getDebugLoc().getAsMDNode());
|
|
|
|
if (!DL)
|
|
|
|
continue;
|
|
|
|
if (!Seen.insert(DL).second)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MDLocalScope *Scope = DL->getInlinedAtScope();
|
|
|
|
if (Scope && !Seen.insert(Scope).second)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
MDSubprogram *SP = Scope ? Scope->getSubprogram() : nullptr;
|
|
|
|
if (SP && !Seen.insert(SP).second)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// FIXME: Once N is canonical, check "SP == &N".
|
|
|
|
Assert(DISubprogram(SP).describes(F),
|
|
|
|
"!dbg attachment points at wrong subprogram for function", &N, F,
|
|
|
|
&I, DL, Scope, SP);
|
|
|
|
}
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
2015-03-30 16:37:48 +00:00
|
|
|
void Verifier::visitMDLexicalBlockBase(const MDLexicalBlockBase &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_lexical_block, "invalid tag", &N);
|
2015-03-30 16:37:48 +00:00
|
|
|
Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()),
|
|
|
|
"invalid local scope", &N, N.getRawScope());
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDLexicalBlock(const MDLexicalBlock &N) {
|
|
|
|
visitMDLexicalBlockBase(N);
|
|
|
|
|
|
|
|
Assert(N.getLine() || !N.getColumn(),
|
|
|
|
"cannot have column info without line info", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDLexicalBlockFile(const MDLexicalBlockFile &N) {
|
2015-03-30 16:37:48 +00:00
|
|
|
visitMDLexicalBlockBase(N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDNamespace(const MDNamespace &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_namespace, "invalid tag", &N);
|
2015-03-30 17:21:38 +00:00
|
|
|
if (auto *S = N.getRawScope())
|
|
|
|
Assert(isa<MDScope>(S), "invalid scope ref", &N, S);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDTemplateParameter(const MDTemplateParameter &N) {
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isTypeRef(N, N.getType()), "invalid type ref", &N, N.getType());
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDTemplateTypeParameter(const MDTemplateTypeParameter &N) {
|
2015-03-30 17:21:38 +00:00
|
|
|
visitMDTemplateParameter(N);
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_template_type_parameter, "invalid tag",
|
|
|
|
&N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDTemplateValueParameter(
|
|
|
|
const MDTemplateValueParameter &N) {
|
2015-03-30 17:21:38 +00:00
|
|
|
visitMDTemplateParameter(N);
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_template_value_parameter ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_GNU_template_template_param ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_GNU_template_parameter_pack,
|
|
|
|
"invalid tag", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
2015-03-27 17:29:58 +00:00
|
|
|
void Verifier::visitMDVariable(const MDVariable &N) {
|
|
|
|
if (auto *S = N.getRawScope())
|
|
|
|
Assert(isa<MDScope>(S), "invalid scope", &N, S);
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isTypeRef(N, N.getRawType()), "invalid type ref", &N, N.getRawType());
|
2015-03-27 17:29:58 +00:00
|
|
|
if (auto *F = N.getRawFile())
|
|
|
|
Assert(isa<MDFile>(F), "invalid file", &N, F);
|
|
|
|
}
|
|
|
|
|
2015-02-10 01:40:40 +00:00
|
|
|
void Verifier::visitMDGlobalVariable(const MDGlobalVariable &N) {
|
2015-03-27 17:29:58 +00:00
|
|
|
// Checks common to all variables.
|
|
|
|
visitMDVariable(N);
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
|
2015-03-31 01:28:22 +00:00
|
|
|
Assert(!N.getName().empty(), "missing global variable name", &N);
|
2015-03-27 17:29:58 +00:00
|
|
|
if (auto *V = N.getRawVariable()) {
|
|
|
|
Assert(isa<ConstantAsMetadata>(V) &&
|
|
|
|
!isa<Function>(cast<ConstantAsMetadata>(V)->getValue()),
|
|
|
|
"invalid global varaible ref", &N, V);
|
|
|
|
}
|
|
|
|
if (auto *Member = N.getRawStaticDataMemberDeclaration()) {
|
|
|
|
Assert(isa<MDDerivedType>(Member), "invalid static data member declaration",
|
|
|
|
&N, Member);
|
|
|
|
}
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDLocalVariable(const MDLocalVariable &N) {
|
2015-03-27 17:29:58 +00:00
|
|
|
// Checks common to all variables.
|
|
|
|
visitMDVariable(N);
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_auto_variable ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_arg_variable,
|
|
|
|
"invalid tag", &N);
|
2015-03-27 17:29:58 +00:00
|
|
|
Assert(N.getRawScope() && isa<MDLocalScope>(N.getRawScope()),
|
|
|
|
"local variable requires a valid scope", &N, N.getRawScope());
|
|
|
|
if (auto *IA = N.getRawInlinedAt())
|
|
|
|
Assert(isa<MDLocation>(IA), "local variable requires a valid scope", &N,
|
|
|
|
IA);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDExpression(const MDExpression &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.isValid(), "invalid expression", &N);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDObjCProperty(const MDObjCProperty &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_APPLE_property, "invalid tag", &N);
|
2015-03-30 17:21:38 +00:00
|
|
|
if (auto *T = N.getRawType())
|
|
|
|
Assert(isa<MDType>(T), "invalid type ref", &N, T);
|
|
|
|
if (auto *F = N.getRawFile())
|
|
|
|
Assert(isa<MDFile>(F), "invalid file", &N, F);
|
2015-02-10 01:40:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDImportedEntity(const MDImportedEntity &N) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N.getTag() == dwarf::DW_TAG_imported_module ||
|
|
|
|
N.getTag() == dwarf::DW_TAG_imported_declaration,
|
|
|
|
"invalid tag", &N);
|
2015-03-30 17:21:38 +00:00
|
|
|
if (auto *S = N.getRawScope())
|
|
|
|
Assert(isa<MDScope>(S), "invalid scope for imported entity", &N, S);
|
2015-03-31 02:27:32 +00:00
|
|
|
Assert(isDIRef(N, N.getEntity()), "invalid imported entity", &N,
|
|
|
|
N.getEntity());
|
2015-02-10 01:09:50 +00:00
|
|
|
}
|
|
|
|
|
2014-06-27 18:19:56 +00:00
|
|
|
void Verifier::visitComdat(const Comdat &C) {
|
2014-07-13 04:56:11 +00:00
|
|
|
// The Module is invalid if the GlobalValue has private linkage. Entities
|
|
|
|
// with private linkage don't have entries in the symbol table.
|
2015-02-20 19:58:48 +00:00
|
|
|
if (const GlobalValue *GV = M->getNamedValue(C.getName()))
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!GV->hasPrivateLinkage(), "comdat global value has private linkage",
|
|
|
|
GV);
|
2014-06-27 18:19:56 +00:00
|
|
|
}
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitModuleIdents(const Module &M) {
|
2013-10-16 01:49:05 +00:00
|
|
|
const NamedMDNode *Idents = M.getNamedMetadata("llvm.ident");
|
|
|
|
if (!Idents)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// llvm.ident takes a list of metadata entry. Each entry has only one string.
|
|
|
|
// Scan each llvm.ident entry and make sure that this requirement is met.
|
|
|
|
for (unsigned i = 0, e = Idents->getNumOperands(); i != e; ++i) {
|
2014-11-11 21:30:22 +00:00
|
|
|
const MDNode *N = Idents->getOperand(i);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N->getNumOperands() == 1,
|
|
|
|
"incorrect number of operands in llvm.ident metadata", N);
|
|
|
|
Assert(dyn_cast_or_null<MDString>(N->getOperand(0)),
|
|
|
|
("invalid value for llvm.ident metadata entry operand"
|
|
|
|
"(the operand should be a string)"),
|
|
|
|
N->getOperand(0));
|
2013-10-16 01:49:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitModuleFlags(const Module &M) {
|
2013-01-15 01:22:53 +00:00
|
|
|
const NamedMDNode *Flags = M.getModuleFlagsMetadata();
|
|
|
|
if (!Flags) return;
|
|
|
|
|
2013-01-15 20:52:06 +00:00
|
|
|
// Scan each flag, and track the flags and requirements.
|
2014-01-19 02:22:18 +00:00
|
|
|
DenseMap<const MDString*, const MDNode*> SeenIDs;
|
|
|
|
SmallVector<const MDNode*, 16> Requirements;
|
2013-01-15 01:22:53 +00:00
|
|
|
for (unsigned I = 0, E = Flags->getNumOperands(); I != E; ++I) {
|
2014-11-11 21:30:22 +00:00
|
|
|
visitModuleFlag(Flags->getOperand(I), SeenIDs, Requirements);
|
2013-01-15 20:52:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Validate that the requirements in the module are valid.
|
|
|
|
for (unsigned I = 0, E = Requirements.size(); I != E; ++I) {
|
2014-01-19 02:22:18 +00:00
|
|
|
const MDNode *Requirement = Requirements[I];
|
|
|
|
const MDString *Flag = cast<MDString>(Requirement->getOperand(0));
|
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
|
|
|
const Metadata *ReqValue = Requirement->getOperand(1);
|
2013-01-15 20:52:06 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
const MDNode *Op = SeenIDs.lookup(Flag);
|
2013-01-15 20:52:06 +00:00
|
|
|
if (!Op) {
|
|
|
|
CheckFailed("invalid requirement on flag, flag is not present in module",
|
|
|
|
Flag);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Op->getOperand(2) != ReqValue) {
|
|
|
|
CheckFailed(("invalid requirement on flag, "
|
|
|
|
"flag does not have the required value"),
|
|
|
|
Flag);
|
|
|
|
continue;
|
|
|
|
}
|
2013-01-15 01:22:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
void
|
|
|
|
Verifier::visitModuleFlag(const MDNode *Op,
|
|
|
|
DenseMap<const MDString *, const MDNode *> &SeenIDs,
|
|
|
|
SmallVectorImpl<const MDNode *> &Requirements) {
|
2013-01-15 01:22:53 +00:00
|
|
|
// Each module flag should have three arguments, the merge behavior (a
|
|
|
|
// constant int), the flag ID (an MDString), and the value.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Op->getNumOperands() == 3,
|
|
|
|
"incorrect number of operands in module flag", Op);
|
2014-09-08 19:16:28 +00:00
|
|
|
Module::ModFlagBehavior MFB;
|
|
|
|
if (!Module::isValidModFlagBehavior(Op->getOperand(0), MFB)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
2015-02-11 09:13:06 +00:00
|
|
|
mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0)),
|
2014-09-08 19:16:28 +00:00
|
|
|
"invalid behavior operand in module flag (expected constant integer)",
|
|
|
|
Op->getOperand(0));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(false,
|
|
|
|
"invalid behavior operand in module flag (unexpected constant)",
|
|
|
|
Op->getOperand(0));
|
2014-09-08 19:16:28 +00:00
|
|
|
}
|
2015-02-16 08:14:22 +00:00
|
|
|
MDString *ID = dyn_cast_or_null<MDString>(Op->getOperand(1));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ID, "invalid ID operand in module flag (expected metadata string)",
|
|
|
|
Op->getOperand(1));
|
2013-01-15 01:22:53 +00:00
|
|
|
|
2013-01-16 21:38:56 +00:00
|
|
|
// Sanity check the values for behaviors with additional requirements.
|
2014-09-08 19:16:28 +00:00
|
|
|
switch (MFB) {
|
2013-01-16 21:38:56 +00:00
|
|
|
case Module::Error:
|
|
|
|
case Module::Warning:
|
|
|
|
case Module::Override:
|
|
|
|
// These behavior types accept any value.
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Module::Require: {
|
2013-01-15 01:22:53 +00:00
|
|
|
// The value should itself be an MDNode with two operands, a flag ID (an
|
|
|
|
// MDString), and a value.
|
|
|
|
MDNode *Value = dyn_cast<MDNode>(Op->getOperand(2));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Value && Value->getNumOperands() == 2,
|
|
|
|
"invalid value for 'require' module flag (expected metadata pair)",
|
|
|
|
Op->getOperand(2));
|
|
|
|
Assert(isa<MDString>(Value->getOperand(0)),
|
|
|
|
("invalid value for 'require' module flag "
|
|
|
|
"(first value operand should be a string)"),
|
|
|
|
Value->getOperand(0));
|
2013-01-15 20:52:06 +00:00
|
|
|
|
|
|
|
// Append it to the list of requirements, to check once all module flags are
|
|
|
|
// scanned.
|
|
|
|
Requirements.push_back(Value);
|
2013-01-16 21:38:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Module::Append:
|
|
|
|
case Module::AppendUnique: {
|
|
|
|
// These behavior types require the operand be an MDNode.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<MDNode>(Op->getOperand(2)),
|
|
|
|
"invalid value for 'append'-type module flag "
|
|
|
|
"(expected a metadata node)",
|
|
|
|
Op->getOperand(2));
|
2013-01-16 21:38:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Unless this is a "requires" flag, check the ID is unique.
|
2014-09-08 19:16:28 +00:00
|
|
|
if (MFB != Module::Require) {
|
2013-01-16 21:38:56 +00:00
|
|
|
bool Inserted = SeenIDs.insert(std::make_pair(ID, Op)).second;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Inserted,
|
|
|
|
"module flag identifiers must be unique (or of 'require' type)", ID);
|
2013-01-15 01:22:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
void Verifier::VerifyAttributeTypes(AttributeSet Attrs, unsigned Idx,
|
2013-07-06 00:29:58 +00:00
|
|
|
bool isFunction, const Value *V) {
|
2013-04-18 20:15:25 +00:00
|
|
|
unsigned Slot = ~0U;
|
|
|
|
for (unsigned I = 0, E = Attrs.getNumSlots(); I != E; ++I)
|
|
|
|
if (Attrs.getSlotIndex(I) == Idx) {
|
|
|
|
Slot = I;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(Slot != ~0U && "Attribute set inconsistency!");
|
|
|
|
|
|
|
|
for (AttributeSet::iterator I = Attrs.begin(Slot), E = Attrs.end(Slot);
|
|
|
|
I != E; ++I) {
|
|
|
|
if (I->isStringAttribute())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (I->getKindAsEnum() == Attribute::NoReturn ||
|
|
|
|
I->getKindAsEnum() == Attribute::NoUnwind ||
|
|
|
|
I->getKindAsEnum() == Attribute::NoInline ||
|
|
|
|
I->getKindAsEnum() == Attribute::AlwaysInline ||
|
|
|
|
I->getKindAsEnum() == Attribute::OptimizeForSize ||
|
|
|
|
I->getKindAsEnum() == Attribute::StackProtect ||
|
|
|
|
I->getKindAsEnum() == Attribute::StackProtectReq ||
|
|
|
|
I->getKindAsEnum() == Attribute::StackProtectStrong ||
|
|
|
|
I->getKindAsEnum() == Attribute::NoRedZone ||
|
|
|
|
I->getKindAsEnum() == Attribute::NoImplicitFloat ||
|
|
|
|
I->getKindAsEnum() == Attribute::Naked ||
|
|
|
|
I->getKindAsEnum() == Attribute::InlineHint ||
|
|
|
|
I->getKindAsEnum() == Attribute::StackAlignment ||
|
|
|
|
I->getKindAsEnum() == Attribute::UWTable ||
|
|
|
|
I->getKindAsEnum() == Attribute::NonLazyBind ||
|
|
|
|
I->getKindAsEnum() == Attribute::ReturnsTwice ||
|
|
|
|
I->getKindAsEnum() == Attribute::SanitizeAddress ||
|
|
|
|
I->getKindAsEnum() == Attribute::SanitizeThread ||
|
|
|
|
I->getKindAsEnum() == Attribute::SanitizeMemory ||
|
|
|
|
I->getKindAsEnum() == Attribute::MinSize ||
|
|
|
|
I->getKindAsEnum() == Attribute::NoDuplicate ||
|
2013-06-27 00:25:01 +00:00
|
|
|
I->getKindAsEnum() == Attribute::Builtin ||
|
2013-05-24 12:26:52 +00:00
|
|
|
I->getKindAsEnum() == Attribute::NoBuiltin ||
|
2013-08-23 11:53:55 +00:00
|
|
|
I->getKindAsEnum() == Attribute::Cold ||
|
2014-06-05 19:29:43 +00:00
|
|
|
I->getKindAsEnum() == Attribute::OptimizeNone ||
|
|
|
|
I->getKindAsEnum() == Attribute::JumpTable) {
|
2013-07-02 03:28:10 +00:00
|
|
|
if (!isFunction) {
|
2013-07-06 00:29:58 +00:00
|
|
|
CheckFailed("Attribute '" + I->getAsString() +
|
|
|
|
"' only applies to functions!", V);
|
|
|
|
return;
|
2013-07-02 03:28:10 +00:00
|
|
|
}
|
2013-07-06 00:29:58 +00:00
|
|
|
} else if (I->getKindAsEnum() == Attribute::ReadOnly ||
|
|
|
|
I->getKindAsEnum() == Attribute::ReadNone) {
|
|
|
|
if (Idx == 0) {
|
2013-06-18 21:27:00 +00:00
|
|
|
CheckFailed("Attribute '" + I->getAsString() +
|
2013-07-06 00:29:58 +00:00
|
|
|
"' does not apply to function returns");
|
2013-04-18 20:15:25 +00:00
|
|
|
return;
|
2013-07-06 00:29:58 +00:00
|
|
|
}
|
|
|
|
} else if (isFunction) {
|
|
|
|
CheckFailed("Attribute '" + I->getAsString() +
|
|
|
|
"' does not apply to functions!", V);
|
|
|
|
return;
|
2013-04-18 20:15:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-11 08:11:03 +00:00
|
|
|
// VerifyParameterAttrs - Check the given attributes for an argument or return
|
2008-01-12 16:42:01 +00:00
|
|
|
// value of the specified type. The value V is printed in error messages.
|
2013-04-18 20:15:25 +00:00
|
|
|
void Verifier::VerifyParameterAttrs(AttributeSet Attrs, unsigned Idx, Type *Ty,
|
2009-06-11 08:11:03 +00:00
|
|
|
bool isReturnValue, const Value *V) {
|
2013-01-21 23:03:18 +00:00
|
|
|
if (!Attrs.hasAttributes(Idx))
|
2008-01-12 16:42:01 +00:00
|
|
|
return;
|
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
VerifyAttributeTypes(Attrs, Idx, false, V);
|
2009-06-11 08:11:03 +00:00
|
|
|
|
2012-10-09 09:51:10 +00:00
|
|
|
if (isReturnValue)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
|
|
|
|
!Attrs.hasAttribute(Idx, Attribute::Nest) &&
|
|
|
|
!Attrs.hasAttribute(Idx, Attribute::StructRet) &&
|
|
|
|
!Attrs.hasAttribute(Idx, Attribute::NoCapture) &&
|
|
|
|
!Attrs.hasAttribute(Idx, Attribute::Returned) &&
|
|
|
|
!Attrs.hasAttribute(Idx, Attribute::InAlloca),
|
|
|
|
"Attributes 'byval', 'inalloca', 'nest', 'sret', 'nocapture', and "
|
|
|
|
"'returned' do not apply to return values!",
|
|
|
|
V);
|
2013-12-19 02:14:12 +00:00
|
|
|
|
|
|
|
// Check for mutually incompatible attributes. Only inreg is compatible with
|
|
|
|
// sret.
|
|
|
|
unsigned AttrCount = 0;
|
|
|
|
AttrCount += Attrs.hasAttribute(Idx, Attribute::ByVal);
|
|
|
|
AttrCount += Attrs.hasAttribute(Idx, Attribute::InAlloca);
|
|
|
|
AttrCount += Attrs.hasAttribute(Idx, Attribute::StructRet) ||
|
|
|
|
Attrs.hasAttribute(Idx, Attribute::InReg);
|
|
|
|
AttrCount += Attrs.hasAttribute(Idx, Attribute::Nest);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(AttrCount <= 1, "Attributes 'byval', 'inalloca', 'inreg', 'nest', "
|
|
|
|
"and 'sret' are incompatible!",
|
|
|
|
V);
|
|
|
|
|
|
|
|
Assert(!(Attrs.hasAttribute(Idx, Attribute::InAlloca) &&
|
|
|
|
Attrs.hasAttribute(Idx, Attribute::ReadOnly)),
|
|
|
|
"Attributes "
|
|
|
|
"'inalloca and readonly' are incompatible!",
|
|
|
|
V);
|
|
|
|
|
|
|
|
Assert(!(Attrs.hasAttribute(Idx, Attribute::StructRet) &&
|
|
|
|
Attrs.hasAttribute(Idx, Attribute::Returned)),
|
|
|
|
"Attributes "
|
|
|
|
"'sret and returned' are incompatible!",
|
|
|
|
V);
|
|
|
|
|
|
|
|
Assert(!(Attrs.hasAttribute(Idx, Attribute::ZExt) &&
|
|
|
|
Attrs.hasAttribute(Idx, Attribute::SExt)),
|
|
|
|
"Attributes "
|
|
|
|
"'zeroext and signext' are incompatible!",
|
|
|
|
V);
|
|
|
|
|
|
|
|
Assert(!(Attrs.hasAttribute(Idx, Attribute::ReadNone) &&
|
|
|
|
Attrs.hasAttribute(Idx, Attribute::ReadOnly)),
|
|
|
|
"Attributes "
|
|
|
|
"'readnone and readonly' are incompatible!",
|
|
|
|
V);
|
|
|
|
|
|
|
|
Assert(!(Attrs.hasAttribute(Idx, Attribute::NoInline) &&
|
|
|
|
Attrs.hasAttribute(Idx, Attribute::AlwaysInline)),
|
|
|
|
"Attributes "
|
|
|
|
"'noinline and alwaysinline' are incompatible!",
|
|
|
|
V);
|
|
|
|
|
|
|
|
Assert(!AttrBuilder(Attrs, Idx)
|
|
|
|
.hasAttributes(AttributeFuncs::typeIncompatible(Ty, Idx), Idx),
|
|
|
|
"Wrong types for attribute: " +
|
|
|
|
AttributeFuncs::typeIncompatible(Ty, Idx).getAsString(Idx),
|
|
|
|
V);
|
2008-08-27 14:48:06 +00:00
|
|
|
|
2013-12-19 02:14:12 +00:00
|
|
|
if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
|
2015-03-13 06:41:26 +00:00
|
|
|
SmallPtrSet<const Type*, 4> Visited;
|
|
|
|
if (!PTy->getElementType()->isSized(&Visited)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal) &&
|
|
|
|
!Attrs.hasAttribute(Idx, Attribute::InAlloca),
|
|
|
|
"Attributes 'byval' and 'inalloca' do not support unsized types!",
|
|
|
|
V);
|
2013-12-19 02:14:12 +00:00
|
|
|
}
|
|
|
|
} else {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(Idx, Attribute::ByVal),
|
|
|
|
"Attribute 'byval' only applies to parameters with pointer type!",
|
|
|
|
V);
|
2013-12-19 02:14:12 +00:00
|
|
|
}
|
2008-01-12 16:42:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// VerifyFunctionAttrs - Check parameter attributes against a function type.
|
2007-12-21 19:19:01 +00:00
|
|
|
// The value V is printed in error messages.
|
2013-04-18 20:15:25 +00:00
|
|
|
void Verifier::VerifyFunctionAttrs(FunctionType *FT, AttributeSet Attrs,
|
2008-01-12 16:42:01 +00:00
|
|
|
const Value *V) {
|
2008-03-12 17:45:29 +00:00
|
|
|
if (Attrs.isEmpty())
|
2007-12-21 19:19:01 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
bool SawNest = false;
|
2013-04-20 05:14:40 +00:00
|
|
|
bool SawReturned = false;
|
2014-05-09 22:32:13 +00:00
|
|
|
bool SawSRet = false;
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
|
2013-04-18 20:15:25 +00:00
|
|
|
unsigned Idx = Attrs.getSlotIndex(i);
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty;
|
2013-04-18 20:15:25 +00:00
|
|
|
if (Idx == 0)
|
2008-03-12 17:45:29 +00:00
|
|
|
Ty = FT->getReturnType();
|
2013-04-18 20:15:25 +00:00
|
|
|
else if (Idx-1 < FT->getNumParams())
|
|
|
|
Ty = FT->getParamType(Idx-1);
|
2008-03-12 17:45:29 +00:00
|
|
|
else
|
2009-06-11 08:11:03 +00:00
|
|
|
break; // VarArgs attributes, verified elsewhere.
|
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
VerifyParameterAttrs(Attrs, Idx, Ty, Idx == 0, V);
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2013-04-20 05:14:40 +00:00
|
|
|
if (Idx == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::Nest)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!SawNest, "More than one parameter has attribute nest!", V);
|
2007-12-21 19:19:01 +00:00
|
|
|
SawNest = true;
|
|
|
|
}
|
|
|
|
|
2013-04-20 05:14:40 +00:00
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::Returned)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!SawReturned, "More than one parameter has attribute returned!",
|
|
|
|
V);
|
|
|
|
Assert(Ty->canLosslesslyBitCastTo(FT->getReturnType()),
|
|
|
|
"Incompatible "
|
|
|
|
"argument and return types for 'returned' attribute",
|
|
|
|
V);
|
2013-04-20 05:14:40 +00:00
|
|
|
SawReturned = true;
|
|
|
|
}
|
|
|
|
|
2014-05-09 22:32:13 +00:00
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::StructRet)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!SawSRet, "Cannot have multiple 'sret' parameters!", V);
|
|
|
|
Assert(Idx == 1 || Idx == 2,
|
|
|
|
"Attribute 'sret' is not on first or second parameter!", V);
|
2014-05-09 22:32:13 +00:00
|
|
|
SawSRet = true;
|
|
|
|
}
|
2014-01-16 22:59:24 +00:00
|
|
|
|
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::InAlloca)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Idx == FT->getNumParams(), "inalloca isn't on the last parameter!",
|
|
|
|
V);
|
2014-01-16 22:59:24 +00:00
|
|
|
}
|
2007-12-21 19:19:01 +00:00
|
|
|
}
|
2008-10-01 23:41:25 +00:00
|
|
|
|
2013-01-18 21:11:39 +00:00
|
|
|
if (!Attrs.hasAttributes(AttributeSet::FunctionIndex))
|
|
|
|
return;
|
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
VerifyAttributeTypes(Attrs, AttributeSet::FunctionIndex, true, V);
|
2013-01-18 21:11:39 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
|
|
|
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadNone) &&
|
|
|
|
Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::ReadOnly)),
|
|
|
|
"Attributes 'readnone and readonly' are incompatible!", V);
|
2013-01-18 21:11:39 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
|
|
|
!(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline) &&
|
|
|
|
Attrs.hasAttribute(AttributeSet::FunctionIndex,
|
|
|
|
Attribute::AlwaysInline)),
|
|
|
|
"Attributes 'noinline and alwaysinline' are incompatible!", V);
|
2013-08-23 11:53:55 +00:00
|
|
|
|
|
|
|
if (Attrs.hasAttribute(AttributeSet::FunctionIndex,
|
|
|
|
Attribute::OptimizeNone)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::NoInline),
|
|
|
|
"Attribute 'optnone' requires 'noinline'!", V);
|
2013-08-23 11:53:55 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex,
|
|
|
|
Attribute::OptimizeForSize),
|
|
|
|
"Attributes 'optsize and optnone' are incompatible!", V);
|
2013-08-23 11:53:55 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::MinSize),
|
|
|
|
"Attributes 'minsize and optnone' are incompatible!", V);
|
2013-08-23 11:53:55 +00:00
|
|
|
}
|
2014-06-05 19:29:43 +00:00
|
|
|
|
|
|
|
if (Attrs.hasAttribute(AttributeSet::FunctionIndex,
|
|
|
|
Attribute::JumpTable)) {
|
|
|
|
const GlobalValue *GV = cast<GlobalValue>(V);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GV->hasUnnamedAddr(),
|
|
|
|
"Attribute 'jumptable' requires 'unnamed_addr'", V);
|
2014-06-05 19:29:43 +00:00
|
|
|
}
|
2007-12-21 19:19:01 +00:00
|
|
|
}
|
|
|
|
|
2014-12-16 19:29:29 +00:00
|
|
|
void Verifier::VerifyConstantExprBitcastType(const ConstantExpr *CE) {
|
|
|
|
if (CE->getOpcode() != Instruction::BitCast)
|
2013-07-31 17:49:08 +00:00
|
|
|
return;
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
|
|
|
|
CE->getType()),
|
|
|
|
"Invalid bitcast", CE);
|
2013-07-31 17:49:08 +00:00
|
|
|
}
|
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) {
|
2013-01-30 06:54:41 +00:00
|
|
|
if (Attrs.getNumSlots() == 0)
|
2008-09-23 22:35:17 +00:00
|
|
|
return true;
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2008-09-23 22:35:17 +00:00
|
|
|
unsigned LastSlot = Attrs.getNumSlots() - 1;
|
2013-01-25 21:30:53 +00:00
|
|
|
unsigned LastIndex = Attrs.getSlotIndex(LastSlot);
|
2008-09-23 22:35:17 +00:00
|
|
|
if (LastIndex <= Params
|
2013-01-25 21:30:53 +00:00
|
|
|
|| (LastIndex == AttributeSet::FunctionIndex
|
|
|
|
&& (LastSlot == 0 || Attrs.getSlotIndex(LastSlot - 1) <= Params)))
|
2008-09-23 22:35:17 +00:00
|
|
|
return true;
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2008-09-23 22:35:17 +00:00
|
|
|
return false;
|
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2015-01-30 23:28:05 +00:00
|
|
|
/// \brief Verify that statepoint intrinsic is well formed.
|
2015-02-03 23:18:47 +00:00
|
|
|
void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
|
|
|
|
assert(CS.getCalledFunction() &&
|
|
|
|
CS.getCalledFunction()->getIntrinsicID() ==
|
|
|
|
Intrinsic::experimental_gc_statepoint);
|
2015-01-30 23:28:05 +00:00
|
|
|
|
2015-02-03 23:18:47 +00:00
|
|
|
const Instruction &CI = *CS.getInstruction();
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory(),
|
|
|
|
"gc.statepoint must read and write memory to preserve "
|
|
|
|
"reordering restrictions required by safepoint semantics",
|
|
|
|
&CI);
|
|
|
|
|
2015-02-03 23:18:47 +00:00
|
|
|
const Value *Target = CS.getArgument(0);
|
2015-01-30 23:28:05 +00:00
|
|
|
const PointerType *PT = dyn_cast<PointerType>(Target->getType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PT && PT->getElementType()->isFunctionTy(),
|
|
|
|
"gc.statepoint callee must be of function pointer type", &CI, Target);
|
2015-01-30 23:28:05 +00:00
|
|
|
FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
|
|
|
|
|
2015-02-03 23:18:47 +00:00
|
|
|
const Value *NumCallArgsV = CS.getArgument(1);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(NumCallArgsV),
|
|
|
|
"gc.statepoint number of arguments to underlying call "
|
|
|
|
"must be constant integer",
|
|
|
|
&CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(NumCallArgs >= 0,
|
|
|
|
"gc.statepoint number of arguments to underlying call "
|
|
|
|
"must be positive",
|
|
|
|
&CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
const int NumParams = (int)TargetFuncType->getNumParams();
|
|
|
|
if (TargetFuncType->isVarArg()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(NumCallArgs >= NumParams,
|
|
|
|
"gc.statepoint mismatch in number of vararg call args", &CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
|
|
|
|
// TODO: Remove this limitation
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(TargetFuncType->getReturnType()->isVoidTy(),
|
|
|
|
"gc.statepoint doesn't support wrapping non-void "
|
|
|
|
"vararg functions yet",
|
|
|
|
&CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
} else
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(NumCallArgs == NumParams,
|
|
|
|
"gc.statepoint mismatch in number of call args", &CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
|
2015-02-03 23:18:47 +00:00
|
|
|
const Value *Unused = CS.getArgument(2);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(Unused) && cast<ConstantInt>(Unused)->isNullValue(),
|
|
|
|
"gc.statepoint parameter #3 must be zero", &CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
|
|
|
|
// Verify that the types of the call parameter arguments match
|
|
|
|
// the type of the wrapped callee.
|
|
|
|
for (int i = 0; i < NumParams; i++) {
|
|
|
|
Type *ParamType = TargetFuncType->getParamType(i);
|
2015-02-03 23:18:47 +00:00
|
|
|
Type *ArgType = CS.getArgument(3+i)->getType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ArgType == ParamType,
|
|
|
|
"gc.statepoint call argument does not match wrapped "
|
|
|
|
"function type",
|
|
|
|
&CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
}
|
|
|
|
const int EndCallArgsInx = 2+NumCallArgs;
|
2015-02-03 23:18:47 +00:00
|
|
|
const Value *NumDeoptArgsV = CS.getArgument(EndCallArgsInx+1);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(NumDeoptArgsV),
|
|
|
|
"gc.statepoint number of deoptimization arguments "
|
|
|
|
"must be constant integer",
|
|
|
|
&CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments "
|
|
|
|
"must be positive",
|
|
|
|
&CI);
|
|
|
|
|
|
|
|
Assert(4 + NumCallArgs + NumDeoptArgs <= (int)CS.arg_size(),
|
|
|
|
"gc.statepoint too few arguments according to length fields", &CI);
|
2015-01-30 23:28:05 +00:00
|
|
|
|
|
|
|
// Check that the only uses of this gc.statepoint are gc.result or
|
|
|
|
// gc.relocate calls which are tied to this statepoint and thus part
|
|
|
|
// of the same statepoint sequence
|
2015-02-03 23:18:47 +00:00
|
|
|
for (const User *U : CI.users()) {
|
2015-01-30 23:28:05 +00:00
|
|
|
const CallInst *Call = dyn_cast<const CallInst>(U);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Call, "illegal use of statepoint token", &CI, U);
|
2015-01-30 23:28:05 +00:00
|
|
|
if (!Call) continue;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isGCRelocate(Call) || isGCResult(Call),
|
|
|
|
"gc.result or gc.relocate are the only value uses"
|
|
|
|
"of a gc.statepoint",
|
|
|
|
&CI, U);
|
2015-01-30 23:28:05 +00:00
|
|
|
if (isGCResult(Call)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Call->getArgOperand(0) == &CI,
|
|
|
|
"gc.result connected to wrong gc.statepoint", &CI, Call);
|
2015-01-30 23:28:05 +00:00
|
|
|
} else if (isGCRelocate(Call)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Call->getArgOperand(0) == &CI,
|
|
|
|
"gc.relocate connected to wrong gc.statepoint", &CI, Call);
|
2015-01-30 23:28:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note: It is legal for a single derived pointer to be listed multiple
|
|
|
|
// times. It's non-optimal, but it is legal. It can also happen after
|
|
|
|
// insertion if we strip a bitcast away.
|
|
|
|
// Note: It is really tempting to check that each base is relocated and
|
|
|
|
// that a derived pointer is never reused as a base pointer. This turns
|
|
|
|
// out to be problematic since optimizations run after safepoint insertion
|
|
|
|
// can recognize equality properties that the insertion logic doesn't know
|
|
|
|
// about. See example statepoint.ll in the verifier subdirectory
|
|
|
|
}
|
|
|
|
|
2015-03-05 18:26:34 +00:00
|
|
|
void Verifier::verifyFrameRecoverIndices() {
|
|
|
|
for (auto &Counts : FrameEscapeInfo) {
|
|
|
|
Function *F = Counts.first;
|
|
|
|
unsigned EscapedObjectCount = Counts.second.first;
|
|
|
|
unsigned MaxRecoveredIndex = Counts.second.second;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(MaxRecoveredIndex <= EscapedObjectCount,
|
|
|
|
"all indices passed to llvm.framerecover must be less than the "
|
|
|
|
"number of arguments passed ot llvm.frameescape in the parent "
|
|
|
|
"function",
|
|
|
|
F);
|
2015-03-05 18:26:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// visitFunction - Verify that a function is ok.
|
2002-02-20 17:55:43 +00:00
|
|
|
//
|
2014-01-19 02:22:18 +00:00
|
|
|
void Verifier::visitFunction(const Function &F) {
|
2005-05-08 22:27:09 +00:00
|
|
|
// Check function arguments.
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FT = F.getFunctionType();
|
2007-08-18 06:13:19 +00:00
|
|
|
unsigned NumArgs = F.arg_size();
|
2002-04-13 22:48:46 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Context == &F.getContext(),
|
|
|
|
"Function context does not match Module context!", &F);
|
2010-02-15 21:52:04 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
|
|
|
|
Assert(FT->getNumParams() == NumArgs,
|
|
|
|
"# formal arguments must match # of arguments for function type!", &F,
|
|
|
|
FT);
|
|
|
|
Assert(F.getReturnType()->isFirstClassType() ||
|
|
|
|
F.getReturnType()->isVoidTy() || F.getReturnType()->isStructTy(),
|
|
|
|
"Functions cannot return aggregate values!", &F);
|
2002-04-13 22:48:46 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
|
|
|
|
"Invalid struct return type!", &F);
|
2008-03-03 21:46:28 +00:00
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
AttributeSet Attrs = F.getAttributes();
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(VerifyAttributeCount(Attrs, FT->getNumParams()),
|
|
|
|
"Attribute after last parameter!", &F);
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
// Check function attributes.
|
2008-01-12 16:42:01 +00:00
|
|
|
VerifyFunctionAttrs(FT, Attrs, &F);
|
2007-07-27 15:09:54 +00:00
|
|
|
|
2013-06-27 00:25:01 +00:00
|
|
|
// On function declarations/definitions, we do not support the builtin
|
|
|
|
// attribute. We do not check this in VerifyFunctionAttrs since that is
|
|
|
|
// checking for Attributes that can/can not ever be on functions.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(AttributeSet::FunctionIndex, Attribute::Builtin),
|
|
|
|
"Attribute 'builtin' can only be applied to a callsite.", &F);
|
2013-06-27 00:25:01 +00:00
|
|
|
|
2006-05-19 21:25:17 +00:00
|
|
|
// Check that this function meets the restrictions on this calling convention.
|
2014-08-29 21:25:28 +00:00
|
|
|
// Sometimes varargs is used for perfectly forwarding thunks, so some of these
|
|
|
|
// restrictions can be lifted.
|
2006-05-19 21:25:17 +00:00
|
|
|
switch (F.getCallingConv()) {
|
|
|
|
default:
|
|
|
|
case CallingConv::C:
|
|
|
|
break;
|
|
|
|
case CallingConv::Fast:
|
|
|
|
case CallingConv::Cold:
|
2012-10-24 14:46:16 +00:00
|
|
|
case CallingConv::Intel_OCL_BI:
|
2010-09-25 07:46:17 +00:00
|
|
|
case CallingConv::PTX_Kernel:
|
|
|
|
case CallingConv::PTX_Device:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!F.isVarArg(), "Calling convention does not support varargs or "
|
|
|
|
"perfect forwarding!",
|
|
|
|
&F);
|
2006-05-19 21:25:17 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2009-05-30 05:06:04 +00:00
|
|
|
bool isLLVMdotName = F.getName().size() >= 5 &&
|
|
|
|
F.getName().substr(0, 5) == "llvm.";
|
|
|
|
|
2002-04-13 22:48:46 +00:00
|
|
|
// Check that the argument values match the function type for this function...
|
2002-10-13 20:57:00 +00:00
|
|
|
unsigned i = 0;
|
2014-01-19 02:22:18 +00:00
|
|
|
for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E;
|
|
|
|
++I, ++i) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I->getType() == FT->getParamType(i),
|
|
|
|
"Argument value does not match function argument type!", I,
|
|
|
|
FT->getParamType(i));
|
|
|
|
Assert(I->getType()->isFirstClassType(),
|
|
|
|
"Function arguments must have first-class types!", I);
|
2009-05-30 05:06:04 +00:00
|
|
|
if (!isLLVMdotName)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!I->getType()->isMetadataTy(),
|
|
|
|
"Function takes metadata but isn't an intrinsic", I, &F);
|
2008-08-27 14:44:57 +00:00
|
|
|
}
|
2002-10-13 20:57:00 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
if (F.isMaterializable()) {
|
|
|
|
// Function has a body somewhere we can't see.
|
|
|
|
} else if (F.isDeclaration()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(F.hasExternalLinkage() || F.hasExternalWeakLinkage(),
|
|
|
|
"invalid linkage type for function declaration", &F);
|
2007-09-19 17:14:45 +00:00
|
|
|
} else {
|
2006-12-13 04:45:46 +00:00
|
|
|
// Verify that this function (which has a body) is not named "llvm.*". It
|
|
|
|
// is not legal to define intrinsics.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2002-10-13 20:57:00 +00:00
|
|
|
// Check the entry node
|
2014-01-19 02:22:18 +00:00
|
|
|
const BasicBlock *Entry = &F.getEntryBlock();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(pred_empty(Entry),
|
|
|
|
"Entry block to function must not have predecessors!", Entry);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2009-11-01 04:08:01 +00:00
|
|
|
// The address of the entry block cannot be taken, unless it is dead.
|
|
|
|
if (Entry->hasAddressTaken()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!BlockAddress::lookup(Entry)->isConstantUsed(),
|
|
|
|
"blockaddress may not be used with the entry block!", Entry);
|
2009-11-01 04:08:01 +00:00
|
|
|
}
|
2002-04-13 22:48:46 +00:00
|
|
|
}
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2009-09-11 17:05:29 +00:00
|
|
|
// If this function is actually an intrinsic, verify that it is only used in
|
|
|
|
// direct call/invokes, never having its "address taken".
|
|
|
|
if (F.getIntrinsicID()) {
|
2010-03-24 13:21:49 +00:00
|
|
|
const User *U;
|
|
|
|
if (F.hasAddressTaken(&U))
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(0, "Invalid user of intrinsic instruction!", U);
|
2009-09-11 17:05:29 +00:00
|
|
|
}
|
2014-01-14 15:22:47 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!F.hasDLLImportStorageClass() ||
|
|
|
|
(F.isDeclaration() && F.hasExternalLinkage()) ||
|
|
|
|
F.hasAvailableExternallyLinkage(),
|
|
|
|
"Function is marked as dllimport, but not external.", &F);
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// verifyBasicBlock - Verify that a basic block is well formed...
|
|
|
|
//
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitBasicBlock(BasicBlock &BB) {
|
2004-09-29 20:07:45 +00:00
|
|
|
InstsInThisBlock.clear();
|
|
|
|
|
2004-12-04 02:30:42 +00:00
|
|
|
// Ensure that basic blocks have terminators!
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
|
2004-12-04 02:30:42 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Check constraints that this basic block imposes on all of the PHI nodes in
|
|
|
|
// it.
|
|
|
|
if (isa<PHINode>(BB.front())) {
|
2007-02-10 08:33:11 +00:00
|
|
|
SmallVector<BasicBlock*, 8> Preds(pred_begin(&BB), pred_end(&BB));
|
|
|
|
SmallVector<std::pair<BasicBlock*, Value*>, 8> Values;
|
2003-10-05 17:44:18 +00:00
|
|
|
std::sort(Preds.begin(), Preds.end());
|
2005-04-21 23:48:37 +00:00
|
|
|
PHINode *PN;
|
2004-06-05 17:44:48 +00:00
|
|
|
for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) {
|
2003-10-05 17:44:18 +00:00
|
|
|
// Ensure that PHI nodes have at least one entry!
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PN->getNumIncomingValues() != 0,
|
|
|
|
"PHI nodes must have at least one entry. If the block is dead, "
|
|
|
|
"the PHI should be removed!",
|
|
|
|
PN);
|
|
|
|
Assert(PN->getNumIncomingValues() == Preds.size(),
|
|
|
|
"PHINode should have one entry for each predecessor of its "
|
|
|
|
"parent basic block!",
|
|
|
|
PN);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Get and sort all incoming values in the PHI node...
|
2007-02-10 08:33:11 +00:00
|
|
|
Values.clear();
|
2003-10-05 17:44:18 +00:00
|
|
|
Values.reserve(PN->getNumIncomingValues());
|
|
|
|
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
|
|
|
|
Values.push_back(std::make_pair(PN->getIncomingBlock(i),
|
|
|
|
PN->getIncomingValue(i)));
|
|
|
|
std::sort(Values.begin(), Values.end());
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
for (unsigned i = 0, e = Values.size(); i != e; ++i) {
|
|
|
|
// Check to make sure that if there is more than one entry for a
|
|
|
|
// particular basic block in this PHI node, that the incoming values are
|
|
|
|
// all identical.
|
|
|
|
//
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(i == 0 || Values[i].first != Values[i - 1].first ||
|
|
|
|
Values[i].second == Values[i - 1].second,
|
|
|
|
"PHI node has multiple entries for the same basic block with "
|
|
|
|
"different incoming values!",
|
|
|
|
PN, Values[i].first, Values[i].second, Values[i - 1].second);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Check to make sure that the predecessors and PHI node entries are
|
|
|
|
// matched up.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Values[i].first == Preds[i],
|
|
|
|
"PHI node entries do not match predecessors!", PN,
|
|
|
|
Values[i].first, Preds[i]);
|
2003-10-05 17:44:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-11-21 00:39:43 +00:00
|
|
|
|
|
|
|
// Check that all instructions have their parent pointers set up correctly.
|
2014-11-21 01:19:09 +00:00
|
|
|
for (auto &I : BB)
|
|
|
|
{
|
2014-11-21 00:39:43 +00:00
|
|
|
Assert(I.getParent() == &BB, "Instruction has bogus parent pointer!");
|
2014-11-21 01:19:09 +00:00
|
|
|
}
|
2002-06-25 15:56:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitTerminatorInst(TerminatorInst &I) {
|
|
|
|
// Ensure that terminators only exist at the end of the basic block.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(&I == I.getParent()->getTerminator(),
|
|
|
|
"Terminator found in the middle of a basic block!", I.getParent());
|
2002-07-18 00:13:42 +00:00
|
|
|
visitInstruction(I);
|
2002-06-25 15:56:27 +00:00
|
|
|
}
|
|
|
|
|
2010-02-15 22:09:09 +00:00
|
|
|
void Verifier::visitBranchInst(BranchInst &BI) {
|
|
|
|
if (BI.isConditional()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BI.getCondition()->getType()->isIntegerTy(1),
|
|
|
|
"Branch condition is not 'i1' type!", &BI, BI.getCondition());
|
2010-02-15 22:09:09 +00:00
|
|
|
}
|
|
|
|
visitTerminatorInst(BI);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitReturnInst(ReturnInst &RI) {
|
|
|
|
Function *F = RI.getParent()->getParent();
|
2008-02-23 00:35:18 +00:00
|
|
|
unsigned N = RI.getNumOperands();
|
2013-07-20 17:46:00 +00:00
|
|
|
if (F->getReturnType()->isVoidTy())
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N == 0,
|
|
|
|
"Found return instr that returns non-void in Function of void "
|
|
|
|
"return type!",
|
|
|
|
&RI, F->getReturnType());
|
2011-04-04 07:44:02 +00:00
|
|
|
else
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
|
|
|
|
"Function return type does not match operand "
|
|
|
|
"type of return inst!",
|
|
|
|
&RI, F->getReturnType());
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2003-08-18 14:43:39 +00:00
|
|
|
// Check to make sure that the return value has necessary properties for
|
2002-06-25 15:56:27 +00:00
|
|
|
// terminators...
|
|
|
|
visitTerminatorInst(RI);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2004-05-21 16:47:21 +00:00
|
|
|
void Verifier::visitSwitchInst(SwitchInst &SI) {
|
|
|
|
// Check to make sure that all of the constants in the switch instruction
|
|
|
|
// have the same type as the switched-on value.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SwitchTy = SI.getCondition()->getType();
|
Revert patches to add case-range support for PR1255.
The work on this project was left in an unfinished and inconsistent state.
Hopefully someone will eventually get a chance to implement this feature, but
in the meantime, it is better to put things back the way the were. I have
left support in the bitcode reader to handle the case-range bitcode format,
so that we do not lose bitcode compatibility with the llvm 3.3 release.
This reverts the following commits: 155464, 156374, 156377, 156613, 156704,
156757, 156804 156808, 156985, 157046, 157112, 157183, 157315, 157384, 157575,
157576, 157586, 157612, 157810, 157814, 157815, 157880, 157881, 157882, 157884,
157887, 157901, 158979, 157987, 157989, 158986, 158997, 159076, 159101, 159100,
159200, 159201, 159207, 159527, 159532, 159540, 159583, 159618, 159658, 159659,
159660, 159661, 159703, 159704, 160076, 167356, 172025, 186736
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@190328 91177308-0d34-0410-b5e6-96231b3b80d8
2013-09-09 19:14:35 +00:00
|
|
|
SmallPtrSet<ConstantInt*, 32> Constants;
|
2012-03-11 06:09:17 +00:00
|
|
|
for (SwitchInst::CaseIt i = SI.case_begin(), e = SI.case_end(); i != e; ++i) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(i.getCaseValue()->getType() == SwitchTy,
|
|
|
|
"Switch constants must all be same type as switch value!", &SI);
|
|
|
|
Assert(Constants.insert(i.getCaseValue()).second,
|
|
|
|
"Duplicate integer as switch case", &SI, i.getCaseValue());
|
2012-05-21 10:44:40 +00:00
|
|
|
}
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2004-05-21 16:47:21 +00:00
|
|
|
visitTerminatorInst(SI);
|
|
|
|
}
|
|
|
|
|
2010-08-02 23:08:33 +00:00
|
|
|
void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BI.getAddress()->getType()->isPointerTy(),
|
|
|
|
"Indirectbr operand must have pointer type!", &BI);
|
2010-08-02 23:08:33 +00:00
|
|
|
for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BI.getDestination(i)->getType()->isLabelTy(),
|
|
|
|
"Indirectbr destinations must all have pointer type!", &BI);
|
2010-08-02 23:08:33 +00:00
|
|
|
|
|
|
|
visitTerminatorInst(BI);
|
|
|
|
}
|
|
|
|
|
2004-03-12 05:54:31 +00:00
|
|
|
void Verifier::visitSelectInst(SelectInst &SI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
|
|
|
|
SI.getOperand(2)),
|
|
|
|
"Invalid operands for select instruction!", &SI);
|
2008-12-29 00:12:50 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SI.getTrueValue()->getType() == SI.getType(),
|
|
|
|
"Select values must have same type as select instruction!", &SI);
|
2004-09-29 21:19:28 +00:00
|
|
|
visitInstruction(SI);
|
2004-03-12 05:54:31 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of
|
|
|
|
/// a pass, if any exist, it's an error.
|
|
|
|
///
|
2002-11-21 16:54:22 +00:00
|
|
|
void Verifier::visitUserOp1(Instruction &I) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(0, "User-defined operators should not live outside of a pass!", &I);
|
2002-11-21 16:54:22 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
void Verifier::visitTruncInst(TruncInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
|
|
|
|
Assert(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
|
|
|
"trunc source and destination must both be a vector or neither", &I);
|
|
|
|
Assert(SrcBitSize > DestBitSize, "DestTy too big for Trunc", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitZExtInst(ZExtInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
|
|
|
|
Assert(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
|
|
|
"zext source and destination must both be a vector or neither", &I);
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcBitSize < DestBitSize, "Type too small for ZExt", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitSExtInst(SExtInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
|
|
|
|
Assert(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
|
|
|
"sext source and destination must both be a vector or neither", &I);
|
|
|
|
Assert(SrcBitSize < DestBitSize, "Type too small for SExt", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPTruncInst(FPTruncInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->isFPOrFPVectorTy(), "FPTrunc only operates on FP", &I);
|
|
|
|
Assert(DestTy->isFPOrFPVectorTy(), "FPTrunc only produces an FP", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
|
|
|
"fptrunc source and destination must both be a vector or neither", &I);
|
|
|
|
Assert(SrcBitSize > DestBitSize, "DestTy too big for FPTrunc", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPExtInst(FPExtInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->isFPOrFPVectorTy(), "FPExt only operates on FP", &I);
|
|
|
|
Assert(DestTy->isFPOrFPVectorTy(), "FPExt only produces an FP", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
|
|
|
"fpext source and destination must both be a vector or neither", &I);
|
|
|
|
Assert(SrcBitSize < DestBitSize, "DestTy too small for FPExt", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitUIToFPInst(UIToFPInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcVec == DstVec,
|
|
|
|
"UIToFP source and dest must both be vector or scalar", &I);
|
|
|
|
Assert(SrcTy->isIntOrIntVectorTy(),
|
|
|
|
"UIToFP source must be integer or integer vector", &I);
|
|
|
|
Assert(DestTy->isFPOrFPVectorTy(), "UIToFP result must be FP or FP vector",
|
|
|
|
&I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
|
|
|
"UIToFP source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitSIToFPInst(SIToFPInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcVec == DstVec,
|
|
|
|
"SIToFP source and dest must both be vector or scalar", &I);
|
|
|
|
Assert(SrcTy->isIntOrIntVectorTy(),
|
|
|
|
"SIToFP source must be integer or integer vector", &I);
|
|
|
|
Assert(DestTy->isFPOrFPVectorTy(), "SIToFP result must be FP or FP vector",
|
|
|
|
&I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
|
|
|
"SIToFP source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPToUIInst(FPToUIInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcVec == DstVec,
|
|
|
|
"FPToUI source and dest must both be vector or scalar", &I);
|
|
|
|
Assert(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
|
|
|
|
&I);
|
|
|
|
Assert(DestTy->isIntOrIntVectorTy(),
|
|
|
|
"FPToUI result must be integer or integer vector", &I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
|
|
|
"FPToUI source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPToSIInst(FPToSIInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcVec == DstVec,
|
|
|
|
"FPToSI source and dest must both be vector or scalar", &I);
|
|
|
|
Assert(SrcTy->isFPOrFPVectorTy(), "FPToSI source must be FP or FP vector",
|
|
|
|
&I);
|
|
|
|
Assert(DestTy->isIntOrIntVectorTy(),
|
|
|
|
"FPToSI result must be integer or integer vector", &I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
|
|
|
"FPToSI source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->getScalarType()->isPointerTy(),
|
|
|
|
"PtrToInt source must be pointer", &I);
|
|
|
|
Assert(DestTy->getScalarType()->isIntegerTy(),
|
|
|
|
"PtrToInt result must be integral", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "PtrToInt type mismatch",
|
|
|
|
&I);
|
2011-12-05 06:29:09 +00:00
|
|
|
|
|
|
|
if (SrcTy->isVectorTy()) {
|
|
|
|
VectorType *VSrc = dyn_cast<VectorType>(SrcTy);
|
|
|
|
VectorType *VDest = dyn_cast<VectorType>(DestTy);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(VSrc->getNumElements() == VDest->getNumElements(),
|
|
|
|
"PtrToInt Vector width mismatch", &I);
|
2011-12-05 06:29:09 +00:00
|
|
|
}
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->getScalarType()->isIntegerTy(),
|
|
|
|
"IntToPtr source must be an integral", &I);
|
|
|
|
Assert(DestTy->getScalarType()->isPointerTy(),
|
|
|
|
"IntToPtr result must be a pointer", &I);
|
|
|
|
Assert(SrcTy->isVectorTy() == DestTy->isVectorTy(), "IntToPtr type mismatch",
|
|
|
|
&I);
|
2011-12-05 06:29:09 +00:00
|
|
|
if (SrcTy->isVectorTy()) {
|
|
|
|
VectorType *VSrc = dyn_cast<VectorType>(SrcTy);
|
|
|
|
VectorType *VDest = dyn_cast<VectorType>(DestTy);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(VSrc->getNumElements() == VDest->getNumElements(),
|
|
|
|
"IntToPtr Vector width mismatch", &I);
|
2011-12-05 06:29:09 +00:00
|
|
|
}
|
2006-11-27 01:05:10 +00:00
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitBitCastInst(BitCastInst &I) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
2014-12-16 19:29:29 +00:00
|
|
|
CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),
|
|
|
|
"Invalid bitcast", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
2013-11-15 01:34:59 +00:00
|
|
|
void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
|
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",
|
|
|
|
&I);
|
|
|
|
Assert(DestTy->isPtrOrPtrVectorTy(), "AddrSpaceCast result must be a pointer",
|
|
|
|
&I);
|
|
|
|
Assert(SrcTy->getPointerAddressSpace() != DestTy->getPointerAddressSpace(),
|
|
|
|
"AddrSpaceCast must be between different address spaces", &I);
|
2013-11-15 01:34:59 +00:00
|
|
|
if (SrcTy->isVectorTy())
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SrcTy->getVectorNumElements() == DestTy->getVectorNumElements(),
|
|
|
|
"AddrSpaceCast vector pointer number of elements mismatch", &I);
|
2013-11-15 01:34:59 +00:00
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// visitPHINode - Ensure that a PHI node is well formed.
|
|
|
|
///
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitPHINode(PHINode &PN) {
|
|
|
|
// Ensure that the PHI nodes are all grouped together at the top of the block.
|
|
|
|
// This can be tested by checking whether the instruction before this is
|
2003-10-10 17:54:14 +00:00
|
|
|
// either nonexistent (because this is begin()) or is a PHI node. If not,
|
2002-06-25 15:56:27 +00:00
|
|
|
// then there is some other instruction before a PHI.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(&PN == &PN.getParent()->front() ||
|
|
|
|
isa<PHINode>(--BasicBlock::iterator(&PN)),
|
|
|
|
"PHI nodes not grouped at top of basic block!", &PN, PN.getParent());
|
2002-06-25 15:56:27 +00:00
|
|
|
|
2009-09-08 01:23:52 +00:00
|
|
|
// Check that all of the values of the PHI node have the same type as the
|
|
|
|
// result, and that the incoming blocks are really basic blocks.
|
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PN.getType() == PN.getIncomingValue(i)->getType(),
|
|
|
|
"PHI node operands are not the same type as the result!", &PN);
|
2009-09-08 01:23:52 +00:00
|
|
|
}
|
2003-11-12 07:13:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// All other PHI node constraints are checked in the visitBasicBlock method.
|
2002-04-18 20:37:37 +00:00
|
|
|
|
|
|
|
visitInstruction(PN);
|
|
|
|
}
|
2002-03-15 20:25:09 +00:00
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
void Verifier::VerifyCallSite(CallSite CS) {
|
|
|
|
Instruction *I = CS.getInstruction();
|
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CS.getCalledValue()->getType()->isPointerTy(),
|
|
|
|
"Called function must be a pointer!", I);
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType());
|
2002-05-08 19:49:50 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(FPTy->getElementType()->isFunctionTy(),
|
|
|
|
"Called function is not pointer to function type!", I);
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FTy = cast<FunctionType>(FPTy->getElementType());
|
2002-05-08 19:49:50 +00:00
|
|
|
|
|
|
|
// Verify that the correct number of arguments are being passed
|
|
|
|
if (FTy->isVarArg())
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CS.arg_size() >= FTy->getNumParams(),
|
|
|
|
"Called function requires more parameters than were provided!", I);
|
2002-05-08 19:49:50 +00:00
|
|
|
else
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CS.arg_size() == FTy->getNumParams(),
|
|
|
|
"Incorrect number of arguments passed to called function!", I);
|
2002-05-08 19:49:50 +00:00
|
|
|
|
2010-05-10 20:58:42 +00:00
|
|
|
// Verify that all arguments to the call match the function type.
|
2002-05-08 19:49:50 +00:00
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CS.getArgument(i)->getType() == FTy->getParamType(i),
|
|
|
|
"Call parameter type does not match function signature!",
|
|
|
|
CS.getArgument(i), FTy->getParamType(i), I);
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2013-04-18 20:15:25 +00:00
|
|
|
AttributeSet Attrs = CS.getAttributes();
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(VerifyAttributeCount(Attrs, CS.arg_size()),
|
|
|
|
"Attribute after last parameter!", I);
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
// Verify call attributes.
|
2008-01-12 16:42:01 +00:00
|
|
|
VerifyFunctionAttrs(FTy, Attrs, I);
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2014-04-30 17:22:00 +00:00
|
|
|
// Conservatively check the inalloca argument.
|
|
|
|
// We have a bug if we can find that there is an underlying alloca without
|
|
|
|
// inalloca.
|
|
|
|
if (CS.hasInAllocaArgument()) {
|
|
|
|
Value *InAllocaArg = CS.getArgument(FTy->getNumParams() - 1);
|
|
|
|
if (auto AI = dyn_cast<AllocaInst>(InAllocaArg->stripInBoundsOffsets()))
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(AI->isUsedWithInAlloca(),
|
|
|
|
"inalloca argument for call has mismatched alloca", AI, I);
|
2014-04-30 17:22:00 +00:00
|
|
|
}
|
|
|
|
|
2013-04-20 05:14:40 +00:00
|
|
|
if (FTy->isVarArg()) {
|
|
|
|
// FIXME? is 'nest' even legal here?
|
|
|
|
bool SawNest = false;
|
|
|
|
bool SawReturned = false;
|
|
|
|
|
|
|
|
for (unsigned Idx = 1; Idx < 1 + FTy->getNumParams(); ++Idx) {
|
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::Nest))
|
|
|
|
SawNest = true;
|
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::Returned))
|
|
|
|
SawReturned = true;
|
|
|
|
}
|
|
|
|
|
2008-01-11 22:36:48 +00:00
|
|
|
// Check attributes on the varargs part.
|
|
|
|
for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) {
|
2013-07-20 17:46:00 +00:00
|
|
|
Type *Ty = CS.getArgument(Idx-1)->getType();
|
2013-04-20 05:14:40 +00:00
|
|
|
VerifyParameterAttrs(Attrs, Idx, Ty, false, I);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2013-04-20 05:14:40 +00:00
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::Nest)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!SawNest, "More than one parameter has attribute nest!", I);
|
2013-04-20 05:14:40 +00:00
|
|
|
SawNest = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::Returned)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!SawReturned, "More than one parameter has attribute returned!",
|
|
|
|
I);
|
|
|
|
Assert(Ty->canLosslesslyBitCastTo(FTy->getReturnType()),
|
|
|
|
"Incompatible argument and return types for 'returned' "
|
|
|
|
"attribute",
|
|
|
|
I);
|
2013-04-20 05:14:40 +00:00
|
|
|
SawReturned = true;
|
|
|
|
}
|
2008-01-12 16:42:01 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!Attrs.hasAttribute(Idx, Attribute::StructRet),
|
|
|
|
"Attribute 'sret' cannot be used for vararg call arguments!", I);
|
2014-01-16 22:59:24 +00:00
|
|
|
|
|
|
|
if (Attrs.hasAttribute(Idx, Attribute::InAlloca))
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Idx == CS.arg_size(), "inalloca isn't on the last argument!", I);
|
2008-01-11 22:36:48 +00:00
|
|
|
}
|
2013-04-20 05:14:40 +00:00
|
|
|
}
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2009-05-30 05:06:04 +00:00
|
|
|
// Verify that there's no metadata unless it's a direct call to an intrinsic.
|
2014-04-09 06:08:46 +00:00
|
|
|
if (CS.getCalledFunction() == nullptr ||
|
2010-05-10 20:58:42 +00:00
|
|
|
!CS.getCalledFunction()->getName().startswith("llvm.")) {
|
2009-05-30 05:06:04 +00:00
|
|
|
for (FunctionType::param_iterator PI = FTy->param_begin(),
|
|
|
|
PE = FTy->param_end(); PI != PE; ++PI)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!(*PI)->isMetadataTy(),
|
|
|
|
"Function has metadata parameter but isn't an intrinsic", I);
|
2009-05-30 05:06:04 +00:00
|
|
|
}
|
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
visitInstruction(*I);
|
|
|
|
}
|
|
|
|
|
2014-04-24 20:14:34 +00:00
|
|
|
/// Two types are "congruent" if they are identical, or if they are both pointer
|
|
|
|
/// types with different pointee types and the same address space.
|
|
|
|
static bool isTypeCongruent(Type *L, Type *R) {
|
|
|
|
if (L == R)
|
|
|
|
return true;
|
|
|
|
PointerType *PL = dyn_cast<PointerType>(L);
|
|
|
|
PointerType *PR = dyn_cast<PointerType>(R);
|
|
|
|
if (!PL || !PR)
|
|
|
|
return false;
|
|
|
|
return PL->getAddressSpace() == PR->getAddressSpace();
|
|
|
|
}
|
|
|
|
|
2014-05-15 23:58:57 +00:00
|
|
|
static AttrBuilder getParameterABIAttributes(int I, AttributeSet Attrs) {
|
|
|
|
static const Attribute::AttrKind ABIAttrs[] = {
|
|
|
|
Attribute::StructRet, Attribute::ByVal, Attribute::InAlloca,
|
|
|
|
Attribute::InReg, Attribute::Returned};
|
|
|
|
AttrBuilder Copy;
|
|
|
|
for (auto AK : ABIAttrs) {
|
|
|
|
if (Attrs.hasAttribute(I + 1, AK))
|
|
|
|
Copy.addAttribute(AK);
|
|
|
|
}
|
|
|
|
if (Attrs.hasAttribute(I + 1, Attribute::Alignment))
|
|
|
|
Copy.addAlignmentAttr(Attrs.getParamAlignment(I + 1));
|
|
|
|
return Copy;
|
|
|
|
}
|
|
|
|
|
2014-04-24 20:14:34 +00:00
|
|
|
void Verifier::verifyMustTailCall(CallInst &CI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
|
2014-04-24 20:14:34 +00:00
|
|
|
|
|
|
|
// - The caller and callee prototypes must match. Pointer types of
|
|
|
|
// parameters or return types may differ in pointee type, but not
|
|
|
|
// address space.
|
|
|
|
Function *F = CI.getParent()->getParent();
|
|
|
|
auto GetFnTy = [](Value *V) {
|
|
|
|
return cast<FunctionType>(
|
|
|
|
cast<PointerType>(V->getType())->getElementType());
|
|
|
|
};
|
|
|
|
FunctionType *CallerTy = GetFnTy(F);
|
|
|
|
FunctionType *CalleeTy = GetFnTy(CI.getCalledValue());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CallerTy->getNumParams() == CalleeTy->getNumParams(),
|
|
|
|
"cannot guarantee tail call due to mismatched parameter counts", &CI);
|
|
|
|
Assert(CallerTy->isVarArg() == CalleeTy->isVarArg(),
|
|
|
|
"cannot guarantee tail call due to mismatched varargs", &CI);
|
|
|
|
Assert(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
|
|
|
|
"cannot guarantee tail call due to mismatched return types", &CI);
|
2014-04-24 20:14:34 +00:00
|
|
|
for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
2014-04-24 20:14:34 +00:00
|
|
|
isTypeCongruent(CallerTy->getParamType(I), CalleeTy->getParamType(I)),
|
|
|
|
"cannot guarantee tail call due to mismatched parameter types", &CI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// - The calling conventions of the caller and callee must match.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(F->getCallingConv() == CI.getCallingConv(),
|
|
|
|
"cannot guarantee tail call due to mismatched calling conv", &CI);
|
2014-04-24 20:14:34 +00:00
|
|
|
|
|
|
|
// - All ABI-impacting function attributes, such as sret, byval, inreg,
|
|
|
|
// returned, and inalloca, must match.
|
|
|
|
AttributeSet CallerAttrs = F->getAttributes();
|
|
|
|
AttributeSet CalleeAttrs = CI.getAttributes();
|
|
|
|
for (int I = 0, E = CallerTy->getNumParams(); I != E; ++I) {
|
2014-05-15 23:58:57 +00:00
|
|
|
AttrBuilder CallerABIAttrs = getParameterABIAttributes(I, CallerAttrs);
|
|
|
|
AttrBuilder CalleeABIAttrs = getParameterABIAttributes(I, CalleeAttrs);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CallerABIAttrs == CalleeABIAttrs,
|
|
|
|
"cannot guarantee tail call due to mismatched ABI impacting "
|
|
|
|
"function attributes",
|
|
|
|
&CI, CI.getOperand(I));
|
2014-04-24 20:14:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// - The call must immediately precede a :ref:`ret <i_ret>` instruction,
|
|
|
|
// or a pointer bitcast followed by a ret instruction.
|
|
|
|
// - The ret instruction must return the (possibly bitcasted) value
|
|
|
|
// produced by the call or void.
|
|
|
|
Value *RetVal = &CI;
|
|
|
|
Instruction *Next = CI.getNextNode();
|
|
|
|
|
|
|
|
// Handle the optional bitcast.
|
|
|
|
if (BitCastInst *BI = dyn_cast_or_null<BitCastInst>(Next)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BI->getOperand(0) == RetVal,
|
|
|
|
"bitcast following musttail call must use the call", BI);
|
2014-04-24 20:14:34 +00:00
|
|
|
RetVal = BI;
|
|
|
|
Next = BI->getNextNode();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check the return.
|
|
|
|
ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Ret, "musttail call must be precede a ret with an optional bitcast",
|
|
|
|
&CI);
|
|
|
|
Assert(!Ret->getReturnValue() || Ret->getReturnValue() == RetVal,
|
|
|
|
"musttail call result must be returned", Ret);
|
2014-04-24 20:14:34 +00:00
|
|
|
}
|
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
void Verifier::visitCallInst(CallInst &CI) {
|
|
|
|
VerifyCallSite(&CI);
|
2002-07-18 00:13:42 +00:00
|
|
|
|
2014-04-24 20:14:34 +00:00
|
|
|
if (CI.isMustTailCall())
|
|
|
|
verifyMustTailCall(CI);
|
|
|
|
|
2009-02-05 01:49:45 +00:00
|
|
|
if (Function *F = CI.getCalledFunction())
|
2003-11-11 22:41:34 +00:00
|
|
|
if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
|
2003-05-08 03:47:33 +00:00
|
|
|
visitIntrinsicFunctionCall(ID, CI);
|
2007-12-21 19:19:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitInvokeInst(InvokeInst &II) {
|
|
|
|
VerifyCallSite(&II);
|
2011-09-21 22:57:02 +00:00
|
|
|
|
|
|
|
// Verify that there is a landingpad instruction as the first non-PHI
|
|
|
|
// instruction of the 'unwind' destination.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(II.getUnwindDest()->isLandingPad(),
|
|
|
|
"The unwind destination does not have a landingpad instruction!", &II);
|
2011-09-21 22:57:02 +00:00
|
|
|
|
2015-02-19 11:28:47 +00:00
|
|
|
if (Function *F = II.getCalledFunction())
|
|
|
|
// TODO: Ideally we should use visitIntrinsicFunction here. But it uses
|
|
|
|
// CallInst as an input parameter. It not woth updating this whole
|
|
|
|
// function only to support statepoint verification.
|
|
|
|
if (F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint)
|
|
|
|
VerifyStatepoint(ImmutableCallSite(&II));
|
|
|
|
|
2010-08-02 23:09:14 +00:00
|
|
|
visitTerminatorInst(II);
|
2002-04-18 22:11:52 +00:00
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// visitBinaryOperator - Check that both arguments to the binary operator are
|
|
|
|
/// of the same type!
|
|
|
|
///
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitBinaryOperator(BinaryOperator &B) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
|
|
|
|
"Both operands to a binary operator are not of the same type!", &B);
|
2002-09-09 20:26:04 +00:00
|
|
|
|
2007-02-02 02:16:23 +00:00
|
|
|
switch (B.getOpcode()) {
|
2009-06-05 16:10:00 +00:00
|
|
|
// Check that integer arithmetic operators are only used with
|
|
|
|
// integral operands.
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::URem:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(B.getType()->isIntOrIntVectorTy(),
|
|
|
|
"Integer arithmetic operators only work with integral types!", &B);
|
|
|
|
Assert(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Integer arithmetic operators must have same type "
|
|
|
|
"for operands and result!",
|
|
|
|
&B);
|
2009-06-05 16:10:00 +00:00
|
|
|
break;
|
|
|
|
// Check that floating-point arithmetic operators are only used with
|
|
|
|
// floating-point operands.
|
|
|
|
case Instruction::FAdd:
|
|
|
|
case Instruction::FSub:
|
|
|
|
case Instruction::FMul:
|
|
|
|
case Instruction::FDiv:
|
|
|
|
case Instruction::FRem:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(B.getType()->isFPOrFPVectorTy(),
|
|
|
|
"Floating-point arithmetic operators only work with "
|
|
|
|
"floating-point types!",
|
|
|
|
&B);
|
|
|
|
Assert(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Floating-point arithmetic operators must have same type "
|
|
|
|
"for operands and result!",
|
|
|
|
&B);
|
2009-06-05 16:10:00 +00:00
|
|
|
break;
|
2002-09-09 20:26:04 +00:00
|
|
|
// Check that logical operators are only used with integral operands.
|
2007-02-02 02:16:23 +00:00
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(B.getType()->isIntOrIntVectorTy(),
|
|
|
|
"Logical operators only work with integral types!", &B);
|
|
|
|
Assert(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Logical operators must have same type for operands and result!",
|
|
|
|
&B);
|
2007-02-02 02:16:23 +00:00
|
|
|
break;
|
|
|
|
case Instruction::Shl:
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(B.getType()->isIntOrIntVectorTy(),
|
|
|
|
"Shifts only work with integral types!", &B);
|
|
|
|
Assert(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Shift return type must be same as operands!", &B);
|
2007-02-02 02:16:23 +00:00
|
|
|
break;
|
2009-06-05 16:10:00 +00:00
|
|
|
default:
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unknown BinaryOperator opcode!");
|
2002-09-09 20:26:04 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
visitInstruction(B);
|
2002-02-20 17:55:43 +00:00
|
|
|
}
|
|
|
|
|
2010-08-22 23:45:14 +00:00
|
|
|
void Verifier::visitICmpInst(ICmpInst &IC) {
|
2006-11-20 01:22:35 +00:00
|
|
|
// Check that the operands are the same type
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Op0Ty = IC.getOperand(0)->getType();
|
|
|
|
Type *Op1Ty = IC.getOperand(1)->getType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Op0Ty == Op1Ty,
|
|
|
|
"Both operands to ICmp instruction are not of the same type!", &IC);
|
2006-11-20 01:22:35 +00:00
|
|
|
// Check that the operands are the right type
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Op0Ty->isIntOrIntVectorTy() || Op0Ty->getScalarType()->isPointerTy(),
|
|
|
|
"Invalid operand types for ICmp instruction", &IC);
|
2010-08-22 23:45:14 +00:00
|
|
|
// Check that the predicate is valid.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE &&
|
|
|
|
IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE,
|
|
|
|
"Invalid predicate in ICmp instruction!", &IC);
|
2009-05-30 05:06:04 +00:00
|
|
|
|
2006-11-20 01:22:35 +00:00
|
|
|
visitInstruction(IC);
|
|
|
|
}
|
|
|
|
|
2010-08-22 23:45:14 +00:00
|
|
|
void Verifier::visitFCmpInst(FCmpInst &FC) {
|
2006-11-20 01:22:35 +00:00
|
|
|
// Check that the operands are the same type
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Op0Ty = FC.getOperand(0)->getType();
|
|
|
|
Type *Op1Ty = FC.getOperand(1)->getType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Op0Ty == Op1Ty,
|
|
|
|
"Both operands to FCmp instruction are not of the same type!", &FC);
|
2006-11-20 01:22:35 +00:00
|
|
|
// Check that the operands are the right type
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Op0Ty->isFPOrFPVectorTy(),
|
|
|
|
"Invalid operand types for FCmp instruction", &FC);
|
2010-08-22 23:45:14 +00:00
|
|
|
// Check that the predicate is valid.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE &&
|
|
|
|
FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE,
|
|
|
|
"Invalid predicate in FCmp instruction!", &FC);
|
2010-08-22 23:45:14 +00:00
|
|
|
|
2006-11-20 01:22:35 +00:00
|
|
|
visitInstruction(FC);
|
|
|
|
}
|
|
|
|
|
2006-01-10 19:05:34 +00:00
|
|
|
void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
|
|
|
ExtractElementInst::isValidOperands(EI.getOperand(0), EI.getOperand(1)),
|
|
|
|
"Invalid extractelement operands!", &EI);
|
2006-01-10 19:05:34 +00:00
|
|
|
visitInstruction(EI);
|
|
|
|
}
|
|
|
|
|
2006-01-17 20:07:22 +00:00
|
|
|
void Verifier::visitInsertElementInst(InsertElementInst &IE) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(InsertElementInst::isValidOperands(IE.getOperand(0), IE.getOperand(1),
|
|
|
|
IE.getOperand(2)),
|
|
|
|
"Invalid insertelement operands!", &IE);
|
2006-01-17 20:07:22 +00:00
|
|
|
visitInstruction(IE);
|
|
|
|
}
|
|
|
|
|
2006-04-08 01:18:18 +00:00
|
|
|
void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
|
|
|
|
SV.getOperand(2)),
|
|
|
|
"Invalid shufflevector operands!", &SV);
|
2006-04-08 01:18:18 +00:00
|
|
|
visitInstruction(SV);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
2012-02-03 17:28:51 +00:00
|
|
|
Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
|
2011-12-05 06:29:09 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<PointerType>(TargetTy),
|
|
|
|
"GEP base pointer is not a vector or a vector of pointers", &GEP);
|
|
|
|
Assert(cast<PointerType>(TargetTy)->getElementType()->isSized(),
|
|
|
|
"GEP into unsized type!", &GEP);
|
|
|
|
Assert(GEP.getPointerOperandType()->isVectorTy() ==
|
|
|
|
GEP.getType()->isVectorTy(),
|
|
|
|
"Vector GEP must return a vector value", &GEP);
|
2011-12-05 06:29:09 +00:00
|
|
|
|
2007-02-10 08:30:29 +00:00
|
|
|
SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy =
|
2015-03-30 21:41:43 +00:00
|
|
|
GetElementPtrInst::getIndexedType(GEP.getSourceElementType(), Idxs);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ElTy, "Invalid indices for GEP pointer type!", &GEP);
|
2011-12-05 06:29:09 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GEP.getType()->getScalarType()->isPointerTy() &&
|
|
|
|
cast<PointerType>(GEP.getType()->getScalarType())
|
|
|
|
->getElementType() == ElTy,
|
|
|
|
"GEP is not of right type for indices!", &GEP, ElTy);
|
2012-11-13 12:59:33 +00:00
|
|
|
|
|
|
|
if (GEP.getPointerOperandType()->isVectorTy()) {
|
|
|
|
// Additional checks for vector GEPs.
|
|
|
|
unsigned GepWidth = GEP.getPointerOperandType()->getVectorNumElements();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GepWidth == GEP.getType()->getVectorNumElements(),
|
|
|
|
"Vector GEP result width doesn't match operand's", &GEP);
|
2012-11-13 12:59:33 +00:00
|
|
|
for (unsigned i = 0, e = Idxs.size(); i != e; ++i) {
|
|
|
|
Type *IndexTy = Idxs[i]->getType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(IndexTy->isVectorTy(), "Vector GEP must have vector indices!",
|
|
|
|
&GEP);
|
2012-11-13 12:59:33 +00:00
|
|
|
unsigned IndexWidth = IndexTy->getVectorNumElements();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(IndexWidth == GepWidth, "Invalid GEP index vector width", &GEP);
|
2012-11-13 12:59:33 +00:00
|
|
|
}
|
2011-12-05 06:29:09 +00:00
|
|
|
}
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(GEP);
|
|
|
|
}
|
|
|
|
|
2012-05-31 16:04:26 +00:00
|
|
|
static bool isContiguous(const ConstantRange &A, const ConstantRange &B) {
|
|
|
|
return A.getUpper() == B.getLower() || A.getLower() == B.getUpper();
|
|
|
|
}
|
|
|
|
|
2014-10-20 23:52:07 +00:00
|
|
|
void Verifier::visitRangeMetadata(Instruction& I,
|
|
|
|
MDNode* Range, Type* Ty) {
|
|
|
|
assert(Range &&
|
|
|
|
Range == I.getMetadata(LLVMContext::MD_range) &&
|
|
|
|
"precondition violation");
|
|
|
|
|
|
|
|
unsigned NumOperands = Range->getNumOperands();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(NumOperands % 2 == 0, "Unfinished range!", Range);
|
2014-10-20 23:52:07 +00:00
|
|
|
unsigned NumRanges = NumOperands / 2;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(NumRanges >= 1, "It should have at least one range!", Range);
|
|
|
|
|
2014-10-20 23:52:07 +00:00
|
|
|
ConstantRange LastRange(1); // Dummy initial value
|
|
|
|
for (unsigned i = 0; i < NumRanges; ++i) {
|
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
|
|
|
ConstantInt *Low =
|
|
|
|
mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Low, "The lower limit must be an integer!", Low);
|
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
|
|
|
ConstantInt *High =
|
|
|
|
mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(High, "The upper limit must be an integer!", High);
|
|
|
|
Assert(High->getType() == Low->getType() && High->getType() == Ty,
|
|
|
|
"Range types must match instruction type!", &I);
|
|
|
|
|
2014-10-20 23:52:07 +00:00
|
|
|
APInt HighV = High->getValue();
|
|
|
|
APInt LowV = Low->getValue();
|
|
|
|
ConstantRange CurRange(LowV, HighV);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!CurRange.isEmptySet() && !CurRange.isFullSet(),
|
|
|
|
"Range must not be empty!", Range);
|
2014-10-20 23:52:07 +00:00
|
|
|
if (i != 0) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CurRange.intersectWith(LastRange).isEmptySet(),
|
|
|
|
"Intervals are overlapping", Range);
|
|
|
|
Assert(LowV.sgt(LastRange.getLower()), "Intervals are not in order",
|
|
|
|
Range);
|
|
|
|
Assert(!isContiguous(CurRange, LastRange), "Intervals are contiguous",
|
|
|
|
Range);
|
2014-10-20 23:52:07 +00:00
|
|
|
}
|
|
|
|
LastRange = ConstantRange(LowV, HighV);
|
|
|
|
}
|
|
|
|
if (NumRanges > 2) {
|
|
|
|
APInt FirstLow =
|
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
|
|
|
mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue();
|
2014-10-20 23:52:07 +00:00
|
|
|
APInt FirstHigh =
|
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
|
|
|
mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
|
2014-10-20 23:52:07 +00:00
|
|
|
ConstantRange FirstRange(FirstLow, FirstHigh);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(FirstRange.intersectWith(LastRange).isEmptySet(),
|
|
|
|
"Intervals are overlapping", Range);
|
|
|
|
Assert(!isContiguous(FirstRange, LastRange), "Intervals are contiguous",
|
|
|
|
Range);
|
2014-10-20 23:52:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitLoadInst(LoadInst &LI) {
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PTy, "Load operand must be a pointer.", &LI);
|
2015-04-06 20:59:48 +00:00
|
|
|
Type *ElTy = LI.getType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LI.getAlignment() <= Value::MaximumAlignment,
|
|
|
|
"huge alignment values are unsupported", &LI);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (LI.isAtomic()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease,
|
|
|
|
"Load cannot have Release ordering", &LI);
|
|
|
|
Assert(LI.getAlignment() != 0,
|
|
|
|
"Atomic load must specify explicit alignment", &LI);
|
2012-08-17 23:24:29 +00:00
|
|
|
if (!ElTy->isPointerTy()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ElTy->isIntegerTy(), "atomic load operand must have integer type!",
|
|
|
|
&LI, ElTy);
|
2012-08-17 23:24:29 +00:00
|
|
|
unsigned Size = ElTy->getPrimitiveSizeInBits();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Size >= 8 && !(Size & (Size - 1)),
|
|
|
|
"atomic load operand must be power-of-two byte-sized integer", &LI,
|
|
|
|
ElTy);
|
2012-08-17 23:24:29 +00:00
|
|
|
}
|
2011-08-09 23:02:53 +00:00
|
|
|
} else {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LI.getSynchScope() == CrossThread,
|
|
|
|
"Non-atomic load cannot have SynchronizationScope specified", &LI);
|
2011-08-09 23:02:53 +00:00
|
|
|
}
|
2012-03-24 00:14:51 +00:00
|
|
|
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(LI);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitStoreInst(StoreInst &SI) {
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PTy, "Store operand must be a pointer.", &SI);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy = PTy->getElementType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ElTy == SI.getOperand(0)->getType(),
|
|
|
|
"Stored value type does not match pointer operand type!", &SI, ElTy);
|
|
|
|
Assert(SI.getAlignment() <= Value::MaximumAlignment,
|
|
|
|
"huge alignment values are unsupported", &SI);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (SI.isAtomic()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease,
|
|
|
|
"Store cannot have Acquire ordering", &SI);
|
|
|
|
Assert(SI.getAlignment() != 0,
|
|
|
|
"Atomic store must specify explicit alignment", &SI);
|
2012-08-17 23:24:29 +00:00
|
|
|
if (!ElTy->isPointerTy()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ElTy->isIntegerTy(),
|
|
|
|
"atomic store operand must have integer type!", &SI, ElTy);
|
2012-08-17 23:24:29 +00:00
|
|
|
unsigned Size = ElTy->getPrimitiveSizeInBits();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Size >= 8 && !(Size & (Size - 1)),
|
|
|
|
"atomic store operand must be power-of-two byte-sized integer",
|
|
|
|
&SI, ElTy);
|
2012-08-17 23:24:29 +00:00
|
|
|
}
|
2011-08-09 23:02:53 +00:00
|
|
|
} else {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(SI.getSynchScope() == CrossThread,
|
|
|
|
"Non-atomic store cannot have SynchronizationScope specified", &SI);
|
2011-08-09 23:02:53 +00:00
|
|
|
}
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(SI);
|
|
|
|
}
|
|
|
|
|
2009-10-23 21:09:37 +00:00
|
|
|
void Verifier::visitAllocaInst(AllocaInst &AI) {
|
2013-12-07 00:13:34 +00:00
|
|
|
SmallPtrSet<const Type*, 4> Visited;
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = AI.getType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PTy->getAddressSpace() == 0,
|
|
|
|
"Allocation instruction pointer not in the generic address space!",
|
|
|
|
&AI);
|
|
|
|
Assert(PTy->getElementType()->isSized(&Visited),
|
|
|
|
"Cannot allocate unsized type", &AI);
|
|
|
|
Assert(AI.getArraySize()->getType()->isIntegerTy(),
|
|
|
|
"Alloca array size must have integer type", &AI);
|
|
|
|
Assert(AI.getAlignment() <= Value::MaximumAlignment,
|
|
|
|
"huge alignment values are unsupported", &AI);
|
2013-12-19 02:14:12 +00:00
|
|
|
|
2007-12-17 01:00:21 +00:00
|
|
|
visitInstruction(AI);
|
|
|
|
}
|
|
|
|
|
2011-07-28 21:48:00 +00:00
|
|
|
void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
|
2014-03-11 10:48:52 +00:00
|
|
|
|
|
|
|
// FIXME: more conditions???
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CXI.getSuccessOrdering() != NotAtomic,
|
|
|
|
"cmpxchg instructions must be atomic.", &CXI);
|
|
|
|
Assert(CXI.getFailureOrdering() != NotAtomic,
|
|
|
|
"cmpxchg instructions must be atomic.", &CXI);
|
|
|
|
Assert(CXI.getSuccessOrdering() != Unordered,
|
|
|
|
"cmpxchg instructions cannot be unordered.", &CXI);
|
|
|
|
Assert(CXI.getFailureOrdering() != Unordered,
|
|
|
|
"cmpxchg instructions cannot be unordered.", &CXI);
|
|
|
|
Assert(CXI.getSuccessOrdering() >= CXI.getFailureOrdering(),
|
|
|
|
"cmpxchg instructions be at least as constrained on success as fail",
|
|
|
|
&CXI);
|
|
|
|
Assert(CXI.getFailureOrdering() != Release &&
|
|
|
|
CXI.getFailureOrdering() != AcquireRelease,
|
|
|
|
"cmpxchg failure ordering cannot include release semantics", &CXI);
|
2014-03-11 10:48:52 +00:00
|
|
|
|
2011-07-28 21:48:00 +00:00
|
|
|
PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PTy, "First cmpxchg operand must be a pointer.", &CXI);
|
2011-07-28 21:48:00 +00:00
|
|
|
Type *ElTy = PTy->getElementType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ElTy->isIntegerTy(), "cmpxchg operand must have integer type!", &CXI,
|
|
|
|
ElTy);
|
2012-08-17 23:24:29 +00:00
|
|
|
unsigned Size = ElTy->getPrimitiveSizeInBits();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Size >= 8 && !(Size & (Size - 1)),
|
|
|
|
"cmpxchg operand must be power-of-two byte-sized integer", &CXI, ElTy);
|
|
|
|
Assert(ElTy == CXI.getOperand(1)->getType(),
|
|
|
|
"Expected value type does not match pointer operand type!", &CXI,
|
|
|
|
ElTy);
|
|
|
|
Assert(ElTy == CXI.getOperand(2)->getType(),
|
|
|
|
"Stored value type does not match pointer operand type!", &CXI, ElTy);
|
2011-07-28 21:48:00 +00:00
|
|
|
visitInstruction(CXI);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(RMWI.getOrdering() != NotAtomic,
|
|
|
|
"atomicrmw instructions must be atomic.", &RMWI);
|
|
|
|
Assert(RMWI.getOrdering() != Unordered,
|
|
|
|
"atomicrmw instructions cannot be unordered.", &RMWI);
|
2011-07-28 21:48:00 +00:00
|
|
|
PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(PTy, "First atomicrmw operand must be a pointer.", &RMWI);
|
2011-07-28 21:48:00 +00:00
|
|
|
Type *ElTy = PTy->getElementType();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ElTy->isIntegerTy(), "atomicrmw operand must have integer type!",
|
|
|
|
&RMWI, ElTy);
|
2012-08-17 23:24:29 +00:00
|
|
|
unsigned Size = ElTy->getPrimitiveSizeInBits();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Size >= 8 && !(Size & (Size - 1)),
|
|
|
|
"atomicrmw operand must be power-of-two byte-sized integer", &RMWI,
|
|
|
|
ElTy);
|
|
|
|
Assert(ElTy == RMWI.getOperand(1)->getType(),
|
|
|
|
"Argument value type does not match pointer operand type!", &RMWI,
|
|
|
|
ElTy);
|
|
|
|
Assert(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() &&
|
|
|
|
RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP,
|
|
|
|
"Invalid binary operation!", &RMWI);
|
2011-07-28 21:48:00 +00:00
|
|
|
visitInstruction(RMWI);
|
|
|
|
}
|
|
|
|
|
2011-07-25 23:16:38 +00:00
|
|
|
void Verifier::visitFenceInst(FenceInst &FI) {
|
|
|
|
const AtomicOrdering Ordering = FI.getOrdering();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Ordering == Acquire || Ordering == Release ||
|
|
|
|
Ordering == AcquireRelease || Ordering == SequentiallyConsistent,
|
|
|
|
"fence instructions may only have "
|
|
|
|
"acquire, release, acq_rel, or seq_cst ordering.",
|
|
|
|
&FI);
|
2011-07-25 23:16:38 +00:00
|
|
|
visitInstruction(FI);
|
|
|
|
}
|
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
|
|
|
|
EVI.getIndices()) == EVI.getType(),
|
|
|
|
"Invalid ExtractValueInst operands!", &EVI);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
visitInstruction(EVI);
|
2008-02-19 22:15:16 +00:00
|
|
|
}
|
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
|
|
|
|
IVI.getIndices()) ==
|
|
|
|
IVI.getOperand(1)->getType(),
|
|
|
|
"Invalid InsertValueInst operands!", &IVI);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
visitInstruction(IVI);
|
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
|
|
|
|
BasicBlock *BB = LPI.getParent();
|
|
|
|
|
|
|
|
// The landingpad instruction is ill-formed if it doesn't have any clauses and
|
|
|
|
// isn't a cleanup.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LPI.getNumClauses() > 0 || LPI.isCleanup(),
|
|
|
|
"LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
|
2011-08-12 20:24:12 +00:00
|
|
|
|
|
|
|
// The landingpad instruction defines its parent as a landing pad block. The
|
|
|
|
// landing pad block may be branched to only by the unwind edge of an invoke.
|
2014-07-21 17:06:51 +00:00
|
|
|
for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
|
|
|
|
const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(II && II->getUnwindDest() == BB && II->getNormalDest() != BB,
|
|
|
|
"Block containing LandingPadInst must be jumped to "
|
|
|
|
"only by the unwind edge of an invoke.",
|
|
|
|
&LPI);
|
2011-08-12 20:24:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// The landingpad instruction must be the first non-PHI instruction in the
|
|
|
|
// block.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LPI.getParent()->getLandingPadInst() == &LPI,
|
|
|
|
"LandingPadInst not the first non-PHI instruction in the block.",
|
|
|
|
&LPI);
|
2011-08-12 20:24:12 +00:00
|
|
|
|
|
|
|
// The personality functions for all landingpad instructions within the same
|
|
|
|
// function should match.
|
|
|
|
if (PersonalityFn)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LPI.getPersonalityFn() == PersonalityFn,
|
|
|
|
"Personality function doesn't match others in function", &LPI);
|
2011-08-12 20:24:12 +00:00
|
|
|
PersonalityFn = LPI.getPersonalityFn();
|
|
|
|
|
2011-09-27 16:43:19 +00:00
|
|
|
// All operands must be constants.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<Constant>(PersonalityFn), "Personality function is not constant!",
|
|
|
|
&LPI);
|
2011-09-27 16:43:19 +00:00
|
|
|
for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
|
2014-06-04 18:51:31 +00:00
|
|
|
Constant *Clause = LPI.getClause(i);
|
2011-09-27 19:34:22 +00:00
|
|
|
if (LPI.isCatch(i)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<PointerType>(Clause->getType()),
|
|
|
|
"Catch operand does not have pointer type!", &LPI);
|
2011-09-27 19:34:22 +00:00
|
|
|
} else {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(LPI.isFilter(i), "Clause is neither catch nor filter!", &LPI);
|
|
|
|
Assert(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
|
|
|
|
"Filter operand is not an array of constants!", &LPI);
|
2011-09-27 19:34:22 +00:00
|
|
|
}
|
2011-09-27 16:43:19 +00:00
|
|
|
}
|
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
visitInstruction(LPI);
|
|
|
|
}
|
|
|
|
|
2012-02-26 02:23:37 +00:00
|
|
|
void Verifier::verifyDominatesUse(Instruction &I, unsigned i) {
|
|
|
|
Instruction *Op = cast<Instruction>(I.getOperand(i));
|
2012-08-17 18:21:28 +00:00
|
|
|
// If the we have an invalid invoke, don't try to compute the dominance.
|
|
|
|
// We already reject it in the invoke specific checks and the dominance
|
|
|
|
// computation doesn't handle multiple edges.
|
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) {
|
|
|
|
if (II->getNormalDest() == II->getUnwindDest())
|
|
|
|
return;
|
|
|
|
}
|
2012-02-26 02:23:37 +00:00
|
|
|
|
2012-06-01 21:56:26 +00:00
|
|
|
const Use &U = I.getOperandUse(i);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(InstsInThisBlock.count(Op) || DT.dominates(Op, U),
|
|
|
|
"Instruction does not dominate all uses!", Op, &I);
|
2012-02-26 02:23:37 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// verifyInstruction - Verify that an instruction is well formed.
|
|
|
|
///
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitInstruction(Instruction &I) {
|
2005-04-21 23:48:37 +00:00
|
|
|
BasicBlock *BB = I.getParent();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BB, "Instruction not embedded in basic block!", &I);
|
2002-04-18 20:37:37 +00:00
|
|
|
|
|
|
|
if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential
|
2014-03-09 04:57:09 +00:00
|
|
|
for (User *U : I.users()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
|
|
|
|
"Only PHI nodes may reference their own value!", &I);
|
2014-03-09 04:57:09 +00:00
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2002-07-18 00:13:42 +00:00
|
|
|
// Check that void typed values don't have names
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!I.getType()->isVoidTy() || !I.hasName(),
|
|
|
|
"Instruction has a name, but provides a void value!", &I);
|
2002-07-18 00:13:42 +00:00
|
|
|
|
2004-03-29 00:29:36 +00:00
|
|
|
// Check that the return value of the instruction is either void or a legal
|
|
|
|
// value type.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
|
|
|
|
"Instruction returns a non-scalar type!", &I);
|
2004-03-29 00:29:36 +00:00
|
|
|
|
2009-09-27 23:27:42 +00:00
|
|
|
// Check that the instruction doesn't produce metadata. Calls are already
|
|
|
|
// checked against the callee type.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
|
|
|
|
"Invalid use of metadata!", &I);
|
2009-05-30 05:06:04 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Check that all uses of the instruction, if they are instructions
|
|
|
|
// themselves, actually have parent basic blocks. If the use is not an
|
|
|
|
// instruction, it is an error!
|
2014-03-09 03:16:01 +00:00
|
|
|
for (Use &U : I.uses()) {
|
|
|
|
if (Instruction *Used = dyn_cast<Instruction>(U.getUser()))
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Used->getParent() != nullptr,
|
|
|
|
"Instruction referencing"
|
|
|
|
" instruction not embedded in a basic block!",
|
|
|
|
&I, Used);
|
2009-09-08 02:02:39 +00:00
|
|
|
else {
|
2014-03-09 03:16:01 +00:00
|
|
|
CheckFailed("Use of instruction is not an instruction!", U);
|
2009-09-08 02:02:39 +00:00
|
|
|
return;
|
|
|
|
}
|
2002-07-18 00:13:42 +00:00
|
|
|
}
|
2003-05-08 03:47:33 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
|
2006-07-11 20:29:49 +00:00
|
|
|
|
|
|
|
// Check to make sure that only first-class-values are operands to
|
|
|
|
// instructions.
|
2008-02-21 01:54:02 +00:00
|
|
|
if (!I.getOperand(i)->getType()->isFirstClassType()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(0, "Instruction operands must be first-class values!", &I);
|
2008-02-21 01:54:02 +00:00
|
|
|
}
|
2009-05-30 05:06:04 +00:00
|
|
|
|
2004-03-14 03:23:54 +00:00
|
|
|
if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
|
2006-07-11 20:29:49 +00:00
|
|
|
// Check to make sure that the "address of" an intrinsic function is never
|
|
|
|
// taken.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(
|
|
|
|
!F->isIntrinsic() ||
|
|
|
|
i == (isa<CallInst>(I) ? e - 1 : isa<InvokeInst>(I) ? e - 3 : 0),
|
|
|
|
"Cannot take the address of an intrinsic!", &I);
|
|
|
|
Assert(
|
|
|
|
!F->isIntrinsic() || isa<CallInst>(I) ||
|
2014-10-17 17:39:00 +00:00
|
|
|
F->getIntrinsicID() == Intrinsic::donothing ||
|
|
|
|
F->getIntrinsicID() == Intrinsic::experimental_patchpoint_void ||
|
2015-02-19 11:28:47 +00:00
|
|
|
F->getIntrinsicID() == Intrinsic::experimental_patchpoint_i64 ||
|
|
|
|
F->getIntrinsicID() == Intrinsic::experimental_gc_statepoint,
|
2015-03-07 21:15:40 +00:00
|
|
|
"Cannot invoke an intrinsinc other than"
|
|
|
|
" donothing or patchpoint",
|
|
|
|
&I);
|
|
|
|
Assert(F->getParent() == M, "Referencing function in another module!",
|
|
|
|
&I);
|
2004-03-14 03:23:54 +00:00
|
|
|
} else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(OpBB->getParent() == BB->getParent(),
|
|
|
|
"Referring to a basic block in another function!", &I);
|
2004-03-14 03:23:54 +00:00
|
|
|
} else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(OpArg->getParent() == BB->getParent(),
|
|
|
|
"Referring to an argument in another function!", &I);
|
2007-04-20 21:48:08 +00:00
|
|
|
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GV->getParent() == M, "Referencing global in another module!", &I);
|
2012-02-26 02:23:37 +00:00
|
|
|
} else if (isa<Instruction>(I.getOperand(i))) {
|
|
|
|
verifyDominatesUse(I, i);
|
2006-01-26 00:08:45 +00:00
|
|
|
} else if (isa<InlineAsm>(I.getOperand(i))) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert((i + 1 == e && isa<CallInst>(I)) ||
|
|
|
|
(i + 3 == e && isa<InvokeInst>(I)),
|
|
|
|
"Cannot take the address of an inline asm!", &I);
|
2013-07-31 17:49:08 +00:00
|
|
|
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) {
|
|
|
|
if (CE->getType()->isPtrOrPtrVectorTy()) {
|
|
|
|
// If we have a ConstantExpr pointer, we need to see if it came from an
|
|
|
|
// illegal bitcast (inttoptr <constant int> )
|
|
|
|
SmallVector<const ConstantExpr *, 4> Stack;
|
|
|
|
SmallPtrSet<const ConstantExpr *, 4> Visited;
|
|
|
|
Stack.push_back(CE);
|
|
|
|
|
|
|
|
while (!Stack.empty()) {
|
|
|
|
const ConstantExpr *V = Stack.pop_back_val();
|
2014-11-19 07:49:26 +00:00
|
|
|
if (!Visited.insert(V).second)
|
2013-07-31 17:49:08 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
VerifyConstantExprBitcastType(V);
|
|
|
|
|
|
|
|
for (unsigned I = 0, N = V->getNumOperands(); I != N; ++I) {
|
|
|
|
if (ConstantExpr *Op = dyn_cast<ConstantExpr>(V->getOperand(I)))
|
|
|
|
Stack.push_back(Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2003-10-05 17:44:18 +00:00
|
|
|
}
|
|
|
|
}
|
2012-03-24 00:14:51 +00:00
|
|
|
|
2014-11-11 21:30:22 +00:00
|
|
|
if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I.getType()->isFPOrFPVectorTy(),
|
|
|
|
"fpmath requires a floating point result!", &I);
|
|
|
|
Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
|
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
|
|
|
if (ConstantFP *CFP0 =
|
|
|
|
mdconst::dyn_extract_or_null<ConstantFP>(MD->getOperand(0))) {
|
2012-04-16 16:28:59 +00:00
|
|
|
APFloat Accuracy = CFP0->getValueAPF();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Accuracy.isFiniteNonZero() && !Accuracy.isNegative(),
|
|
|
|
"fpmath accuracy not a positive number!", &I);
|
2012-04-16 16:28:59 +00:00
|
|
|
} else {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(false, "invalid fpmath accuracy!", &I);
|
2012-04-16 16:28:59 +00:00
|
|
|
}
|
2012-04-10 08:22:43 +00:00
|
|
|
}
|
|
|
|
|
2014-11-11 21:30:22 +00:00
|
|
|
if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
|
|
|
|
"Ranges are only for loads, calls and invokes!", &I);
|
2014-10-20 23:52:07 +00:00
|
|
|
visitRangeMetadata(I, Range, I.getType());
|
|
|
|
}
|
2012-03-24 00:14:51 +00:00
|
|
|
|
2014-10-21 20:56:29 +00:00
|
|
|
if (I.getMetadata(LLVMContext::MD_nonnull)) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
|
|
|
|
&I);
|
|
|
|
Assert(isa<LoadInst>(I),
|
|
|
|
"nonnull applies only to load instructions, use attributes"
|
|
|
|
" for calls or invokes",
|
|
|
|
&I);
|
2014-10-21 20:56:29 +00:00
|
|
|
}
|
|
|
|
|
2015-03-20 19:26:58 +00:00
|
|
|
if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
|
2015-03-24 17:32:19 +00:00
|
|
|
Assert(isa<MDLocation>(N), "invalid !dbg metadata attachment", &I, N);
|
|
|
|
visitMDNode(*N);
|
2015-03-20 19:26:58 +00:00
|
|
|
}
|
|
|
|
|
2004-09-29 20:07:45 +00:00
|
|
|
InstsInThisBlock.insert(&I);
|
2003-05-08 03:47:33 +00:00
|
|
|
}
|
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
/// VerifyIntrinsicType - Verify that the specified type (which comes from an
|
|
|
|
/// intrinsic argument or return value) matches the type constraints specified
|
|
|
|
/// by the .td file (e.g. an "any integer" argument really is an integer).
|
|
|
|
///
|
|
|
|
/// This return true on error but does not print a message.
|
|
|
|
bool Verifier::VerifyIntrinsicType(Type *Ty,
|
|
|
|
ArrayRef<Intrinsic::IITDescriptor> &Infos,
|
|
|
|
SmallVectorImpl<Type*> &ArgTys) {
|
|
|
|
using namespace Intrinsic;
|
|
|
|
|
|
|
|
// If we ran out of descriptors, there are too many arguments.
|
2013-07-20 17:46:00 +00:00
|
|
|
if (Infos.empty()) return true;
|
2012-05-27 19:37:05 +00:00
|
|
|
IITDescriptor D = Infos.front();
|
|
|
|
Infos = Infos.slice(1);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
switch (D.Kind) {
|
|
|
|
case IITDescriptor::Void: return !Ty->isVoidTy();
|
2013-10-31 17:18:11 +00:00
|
|
|
case IITDescriptor::VarArg: return true;
|
2012-05-27 19:37:05 +00:00
|
|
|
case IITDescriptor::MMX: return !Ty->isX86_MMXTy();
|
|
|
|
case IITDescriptor::Metadata: return !Ty->isMetadataTy();
|
2013-01-11 01:45:05 +00:00
|
|
|
case IITDescriptor::Half: return !Ty->isHalfTy();
|
2012-05-27 19:37:05 +00:00
|
|
|
case IITDescriptor::Float: return !Ty->isFloatTy();
|
|
|
|
case IITDescriptor::Double: return !Ty->isDoubleTy();
|
|
|
|
case IITDescriptor::Integer: return !Ty->isIntegerTy(D.Integer_Width);
|
|
|
|
case IITDescriptor::Vector: {
|
|
|
|
VectorType *VT = dyn_cast<VectorType>(Ty);
|
2014-04-09 06:08:46 +00:00
|
|
|
return !VT || VT->getNumElements() != D.Vector_Width ||
|
2012-05-27 19:37:05 +00:00
|
|
|
VerifyIntrinsicType(VT->getElementType(), Infos, ArgTys);
|
|
|
|
}
|
|
|
|
case IITDescriptor::Pointer: {
|
|
|
|
PointerType *PT = dyn_cast<PointerType>(Ty);
|
2014-04-09 06:08:46 +00:00
|
|
|
return !PT || PT->getAddressSpace() != D.Pointer_AddressSpace ||
|
2012-05-27 19:37:05 +00:00
|
|
|
VerifyIntrinsicType(PT->getElementType(), Infos, ArgTys);
|
|
|
|
}
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
case IITDescriptor::Struct: {
|
|
|
|
StructType *ST = dyn_cast<StructType>(Ty);
|
2014-04-09 06:08:46 +00:00
|
|
|
if (!ST || ST->getNumElements() != D.Struct_NumElements)
|
2012-05-27 19:37:05 +00:00
|
|
|
return true;
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
for (unsigned i = 0, e = D.Struct_NumElements; i != e; ++i)
|
|
|
|
if (VerifyIntrinsicType(ST->getElementType(i), Infos, ArgTys))
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
case IITDescriptor::Argument:
|
2012-06-02 10:20:22 +00:00
|
|
|
// Two cases here - If this is the second occurrence of an argument, verify
|
2013-07-20 17:46:00 +00:00
|
|
|
// that the later instance matches the previous instance.
|
2012-05-27 19:37:05 +00:00
|
|
|
if (D.getArgumentNumber() < ArgTys.size())
|
2013-07-20 17:46:00 +00:00
|
|
|
return Ty != ArgTys[D.getArgumentNumber()];
|
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
// Otherwise, if this is the first instance of an argument, record it and
|
|
|
|
// verify the "Any" kind.
|
|
|
|
assert(D.getArgumentNumber() == ArgTys.size() && "Table consistency error");
|
|
|
|
ArgTys.push_back(Ty);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
switch (D.getArgumentKind()) {
|
2015-01-22 20:14:38 +00:00
|
|
|
case IITDescriptor::AK_Any: return false; // Success
|
2012-05-27 19:37:05 +00:00
|
|
|
case IITDescriptor::AK_AnyInteger: return !Ty->isIntOrIntVectorTy();
|
|
|
|
case IITDescriptor::AK_AnyFloat: return !Ty->isFPOrFPVectorTy();
|
|
|
|
case IITDescriptor::AK_AnyVector: return !isa<VectorType>(Ty);
|
|
|
|
case IITDescriptor::AK_AnyPointer: return !isa<PointerType>(Ty);
|
|
|
|
}
|
|
|
|
llvm_unreachable("all argument kinds not covered");
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2014-03-28 12:31:39 +00:00
|
|
|
case IITDescriptor::ExtendArgument: {
|
2012-05-27 19:37:05 +00:00
|
|
|
// This may only be used when referring to a previous vector argument.
|
2014-03-28 12:31:39 +00:00
|
|
|
if (D.getArgumentNumber() >= ArgTys.size())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Type *NewTy = ArgTys[D.getArgumentNumber()];
|
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
|
|
|
|
NewTy = VectorType::getExtendedElementVectorType(VTy);
|
|
|
|
else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
|
|
|
|
NewTy = IntegerType::get(ITy->getContext(), 2 * ITy->getBitWidth());
|
|
|
|
else
|
|
|
|
return true;
|
2012-05-27 19:37:05 +00:00
|
|
|
|
2014-03-28 12:31:39 +00:00
|
|
|
return Ty != NewTy;
|
|
|
|
}
|
|
|
|
case IITDescriptor::TruncArgument: {
|
2012-05-27 19:37:05 +00:00
|
|
|
// This may only be used when referring to a previous vector argument.
|
2014-03-28 12:31:39 +00:00
|
|
|
if (D.getArgumentNumber() >= ArgTys.size())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
Type *NewTy = ArgTys[D.getArgumentNumber()];
|
|
|
|
if (VectorType *VTy = dyn_cast<VectorType>(NewTy))
|
|
|
|
NewTy = VectorType::getTruncatedElementVectorType(VTy);
|
|
|
|
else if (IntegerType *ITy = dyn_cast<IntegerType>(NewTy))
|
|
|
|
NewTy = IntegerType::get(ITy->getContext(), ITy->getBitWidth() / 2);
|
|
|
|
else
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return Ty != NewTy;
|
|
|
|
}
|
2014-03-29 07:04:54 +00:00
|
|
|
case IITDescriptor::HalfVecArgument:
|
|
|
|
// This may only be used when referring to a previous vector argument.
|
|
|
|
return D.getArgumentNumber() >= ArgTys.size() ||
|
|
|
|
!isa<VectorType>(ArgTys[D.getArgumentNumber()]) ||
|
|
|
|
VectorType::getHalfElementsVectorType(
|
|
|
|
cast<VectorType>(ArgTys[D.getArgumentNumber()])) != Ty;
|
2014-12-04 09:40:44 +00:00
|
|
|
case IITDescriptor::SameVecWidthArgument: {
|
|
|
|
if (D.getArgumentNumber() >= ArgTys.size())
|
|
|
|
return true;
|
|
|
|
VectorType * ReferenceType =
|
|
|
|
dyn_cast<VectorType>(ArgTys[D.getArgumentNumber()]);
|
|
|
|
VectorType *ThisArgType = dyn_cast<VectorType>(Ty);
|
|
|
|
if (!ThisArgType || !ReferenceType ||
|
|
|
|
(ReferenceType->getVectorNumElements() !=
|
|
|
|
ThisArgType->getVectorNumElements()))
|
|
|
|
return true;
|
|
|
|
return VerifyIntrinsicType(ThisArgType->getVectorElementType(),
|
|
|
|
Infos, ArgTys);
|
|
|
|
}
|
2014-12-25 07:49:20 +00:00
|
|
|
case IITDescriptor::PtrToArgument: {
|
|
|
|
if (D.getArgumentNumber() >= ArgTys.size())
|
|
|
|
return true;
|
|
|
|
Type * ReferenceType = ArgTys[D.getArgumentNumber()];
|
|
|
|
PointerType *ThisArgType = dyn_cast<PointerType>(Ty);
|
|
|
|
return (!ThisArgType || ThisArgType->getElementType() != ReferenceType);
|
|
|
|
}
|
Masked Gather and Scatter Intrinsics.
Gather and Scatter are new introduced intrinsics, comming after recently implemented masked load and store.
This is the first patch for Gather and Scatter intrinsics. It includes only the syntax, parsing and verification.
Gather and Scatter intrinsics allow to perform multiple memory accesses (read/write) in one vector instruction.
The intrinsics are not target specific and will have the following syntax:
Gather:
declare <16 x i32> @llvm.masked.gather.v16i32(<16 x i32*> <vector of ptrs>, i32 <alignment>, <16 x i1> <mask>, <16 x i32> <passthru>)
declare <8 x float> @llvm.masked.gather.v8f32(<8 x float*><vector of ptrs>, i32 <alignment>, <8 x i1> <mask>, <8 x float><passthru>)
Scatter:
declare void @llvm.masked.scatter.v8i32(<8 x i32><vector value to be stored> , <8 x i32*><vector of ptrs> , i32 <alignment>, <8 x i1> <mask>)
declare void @llvm.masked.scatter.v16i32(<16 x i32> <vector value to be stored> , <16 x i32*> <vector of ptrs>, i32 <alignment>, <16 x i1><mask> )
Vector of ptrs - a set of source/destination addresses, to load/store the value.
Mask - switches on/off vector lanes to prevent memory access for switched-off lanes
vector of ptrs, value and mask should have the same vector width.
These are code examples where gather / scatter should be used and will allow function vectorization
;void foo1(int * restrict A, int * restrict B, int * restrict C) {
; for (int i=0; i<SIZE; i++) {
; A[i] = B[C[i]];
; }
;}
;void foo3(int * restrict A, int * restrict B) {
; for (int i=0; i<SIZE; i++) {
; A[B[i]] = i+5;
; }
;}
Tests will come in the following patches, with CodeGen and Vectorizer.
http://reviews.llvm.org/D7433
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@228521 91177308-0d34-0410-b5e6-96231b3b80d8
2015-02-08 08:27:19 +00:00
|
|
|
case IITDescriptor::VecOfPtrsToElt: {
|
|
|
|
if (D.getArgumentNumber() >= ArgTys.size())
|
|
|
|
return true;
|
|
|
|
VectorType * ReferenceType =
|
|
|
|
dyn_cast<VectorType> (ArgTys[D.getArgumentNumber()]);
|
|
|
|
VectorType *ThisArgVecTy = dyn_cast<VectorType>(Ty);
|
|
|
|
if (!ThisArgVecTy || !ReferenceType ||
|
|
|
|
(ReferenceType->getVectorNumElements() !=
|
|
|
|
ThisArgVecTy->getVectorNumElements()))
|
|
|
|
return true;
|
|
|
|
PointerType *ThisArgEltTy =
|
|
|
|
dyn_cast<PointerType>(ThisArgVecTy->getVectorElementType());
|
|
|
|
if (!ThisArgEltTy)
|
|
|
|
return true;
|
|
|
|
return (!(ThisArgEltTy->getElementType() ==
|
|
|
|
ReferenceType->getVectorElementType()));
|
|
|
|
}
|
2012-05-27 19:37:05 +00:00
|
|
|
}
|
|
|
|
llvm_unreachable("unhandled");
|
|
|
|
}
|
2009-01-07 00:09:01 +00:00
|
|
|
|
2013-10-31 17:18:11 +00:00
|
|
|
/// \brief Verify if the intrinsic has variable arguments.
|
|
|
|
/// This method is intended to be called after all the fixed arguments have been
|
|
|
|
/// verified first.
|
|
|
|
///
|
|
|
|
/// This method returns true on error and does not print an error message.
|
|
|
|
bool
|
|
|
|
Verifier::VerifyIntrinsicIsVarArg(bool isVarArg,
|
|
|
|
ArrayRef<Intrinsic::IITDescriptor> &Infos) {
|
|
|
|
using namespace Intrinsic;
|
|
|
|
|
|
|
|
// If there are no descriptors left, then it can't be a vararg.
|
|
|
|
if (Infos.empty())
|
2015-03-09 01:57:13 +00:00
|
|
|
return isVarArg;
|
2013-10-31 17:18:11 +00:00
|
|
|
|
|
|
|
// There should be only one descriptor remaining at this point.
|
|
|
|
if (Infos.size() != 1)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// Check and verify the descriptor.
|
|
|
|
IITDescriptor D = Infos.front();
|
|
|
|
Infos = Infos.slice(1);
|
|
|
|
if (D.Kind == IITDescriptor::VarArg)
|
2015-03-09 01:57:13 +00:00
|
|
|
return !isVarArg;
|
2013-10-31 17:18:11 +00:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2003-05-08 03:47:33 +00:00
|
|
|
/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
|
2004-03-02 00:22:19 +00:00
|
|
|
///
|
2003-11-11 22:41:34 +00:00
|
|
|
void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
|
2003-05-08 03:47:33 +00:00
|
|
|
Function *IF = CI.getCalledFunction();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(IF->isDeclaration(), "Intrinsic functions should never be defined!",
|
|
|
|
IF);
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
// Verify that the intrinsic prototype lines up with what the .td files
|
|
|
|
// describe.
|
|
|
|
FunctionType *IFTy = IF->getFunctionType();
|
2013-10-31 17:18:11 +00:00
|
|
|
bool IsVarArg = IFTy->isVarArg();
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2012-05-27 19:37:05 +00:00
|
|
|
SmallVector<Intrinsic::IITDescriptor, 8> Table;
|
|
|
|
getIntrinsicInfoTableEntries(ID, Table);
|
|
|
|
ArrayRef<Intrinsic::IITDescriptor> TableRef = Table;
|
|
|
|
|
|
|
|
SmallVector<Type *, 4> ArgTys;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!VerifyIntrinsicType(IFTy->getReturnType(), TableRef, ArgTys),
|
|
|
|
"Intrinsic has incorrect return type!", IF);
|
2012-05-27 19:37:05 +00:00
|
|
|
for (unsigned i = 0, e = IFTy->getNumParams(); i != e; ++i)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!VerifyIntrinsicType(IFTy->getParamType(i), TableRef, ArgTys),
|
|
|
|
"Intrinsic has incorrect argument type!", IF);
|
2013-10-31 17:18:11 +00:00
|
|
|
|
|
|
|
// Verify if the intrinsic call matches the vararg property.
|
|
|
|
if (IsVarArg)
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef),
|
|
|
|
"Intrinsic was not defined with variable arguments!", IF);
|
2013-10-31 17:18:11 +00:00
|
|
|
else
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!VerifyIntrinsicIsVarArg(IsVarArg, TableRef),
|
|
|
|
"Callsite was not defined with variable arguments!", IF);
|
2013-10-31 17:18:11 +00:00
|
|
|
|
|
|
|
// All descriptors should be absorbed by now.
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(TableRef.empty(), "Intrinsic has too few arguments!", IF);
|
2012-05-27 19:37:05 +00:00
|
|
|
|
|
|
|
// Now that we have the intrinsic ID and the actual argument types (and we
|
|
|
|
// know they are legal for the intrinsic!) get the intrinsic name through the
|
|
|
|
// usual means. This allows us to verify the mangling of argument types into
|
|
|
|
// the name.
|
2014-03-10 21:22:44 +00:00
|
|
|
const std::string ExpectedName = Intrinsic::getName(ID, ArgTys);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(ExpectedName == IF->getName(),
|
|
|
|
"Intrinsic name not mangled correctly for type arguments! "
|
|
|
|
"Should be: " +
|
|
|
|
ExpectedName,
|
|
|
|
IF);
|
2013-07-20 17:46:00 +00:00
|
|
|
|
2009-12-28 09:07:21 +00:00
|
|
|
// If the intrinsic takes MDNode arguments, verify that they are either global
|
|
|
|
// or are local to *this* function.
|
2010-06-07 19:18:58 +00:00
|
|
|
for (unsigned i = 0, e = CI.getNumArgOperands(); i != e; ++i)
|
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
|
|
|
if (auto *MD = dyn_cast<MetadataAsValue>(CI.getArgOperand(i)))
|
|
|
|
visitMetadataAsValue(*MD, CI.getParent()->getParent());
|
2009-12-18 20:09:14 +00:00
|
|
|
|
2007-09-17 20:30:04 +00:00
|
|
|
switch (ID) {
|
|
|
|
default:
|
|
|
|
break;
|
2011-12-12 04:36:02 +00:00
|
|
|
case Intrinsic::ctlz: // llvm.ctlz
|
|
|
|
case Intrinsic::cttz: // llvm.cttz
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(CI.getArgOperand(1)),
|
|
|
|
"is_zero_undef argument of bit counting intrinsics must be a "
|
|
|
|
"constant int",
|
|
|
|
&CI);
|
2011-12-12 04:36:02 +00:00
|
|
|
break;
|
2015-03-15 00:50:57 +00:00
|
|
|
case Intrinsic::dbg_declare: // llvm.dbg.declare
|
|
|
|
Assert(isa<MetadataAsValue>(CI.getArgOperand(0)),
|
2015-03-07 21:15:40 +00:00
|
|
|
"invalid llvm.dbg.declare intrinsic call 1", &CI);
|
2015-03-15 01:21:30 +00:00
|
|
|
visitDbgIntrinsic("declare", cast<DbgDeclareInst>(CI));
|
|
|
|
break;
|
|
|
|
case Intrinsic::dbg_value: // llvm.dbg.value
|
|
|
|
visitDbgIntrinsic("value", cast<DbgValueInst>(CI));
|
2015-03-15 00:50:57 +00:00
|
|
|
break;
|
2008-11-21 16:42:48 +00:00
|
|
|
case Intrinsic::memcpy:
|
|
|
|
case Intrinsic::memmove:
|
2015-03-02 09:35:06 +00:00
|
|
|
case Intrinsic::memset: {
|
|
|
|
ConstantInt *AlignCI = dyn_cast<ConstantInt>(CI.getArgOperand(3));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(AlignCI,
|
|
|
|
"alignment argument of memory intrinsics must be a constant int",
|
|
|
|
&CI);
|
2015-03-02 09:35:06 +00:00
|
|
|
const APInt &AlignVal = AlignCI->getValue();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(AlignCI->isZero() || AlignVal.isPowerOf2(),
|
|
|
|
"alignment argument of memory intrinsics must be a power of 2", &CI);
|
|
|
|
Assert(isa<ConstantInt>(CI.getArgOperand(4)),
|
|
|
|
"isvolatile argument of memory intrinsics must be a constant int",
|
|
|
|
&CI);
|
2008-08-23 05:31:10 +00:00
|
|
|
break;
|
2015-03-02 09:35:06 +00:00
|
|
|
}
|
2008-08-23 09:46:46 +00:00
|
|
|
case Intrinsic::gcroot:
|
|
|
|
case Intrinsic::gcwrite:
|
2008-08-24 20:46:13 +00:00
|
|
|
case Intrinsic::gcread:
|
|
|
|
if (ID == Intrinsic::gcroot) {
|
2008-10-25 16:28:35 +00:00
|
|
|
AllocaInst *AI =
|
2010-06-23 13:56:57 +00:00
|
|
|
dyn_cast<AllocaInst>(CI.getArgOperand(0)->stripPointerCasts());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(AI, "llvm.gcroot parameter #1 must be an alloca.", &CI);
|
|
|
|
Assert(isa<Constant>(CI.getArgOperand(1)),
|
|
|
|
"llvm.gcroot parameter #2 must be a constant.", &CI);
|
2010-09-30 20:23:47 +00:00
|
|
|
if (!AI->getType()->getElementType()->isPointerTy()) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!isa<ConstantPointerNull>(CI.getArgOperand(1)),
|
|
|
|
"llvm.gcroot parameter #1 must either be a pointer alloca, "
|
|
|
|
"or argument #2 must be a non-null constant.",
|
|
|
|
&CI);
|
2010-09-30 20:23:47 +00:00
|
|
|
}
|
2008-08-24 20:46:13 +00:00
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CI.getParent()->getParent()->hasGC(),
|
|
|
|
"Enclosing function does not use GC.", &CI);
|
2008-08-24 20:46:13 +00:00
|
|
|
break;
|
2007-09-29 16:25:54 +00:00
|
|
|
case Intrinsic::init_trampoline:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<Function>(CI.getArgOperand(1)->stripPointerCasts()),
|
|
|
|
"llvm.init_trampoline parameter #2 must resolve to a function.",
|
|
|
|
&CI);
|
2007-12-25 02:02:10 +00:00
|
|
|
break;
|
2008-10-16 06:00:36 +00:00
|
|
|
case Intrinsic::prefetch:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(CI.getArgOperand(1)) &&
|
|
|
|
isa<ConstantInt>(CI.getArgOperand(2)) &&
|
|
|
|
cast<ConstantInt>(CI.getArgOperand(1))->getZExtValue() < 2 &&
|
|
|
|
cast<ConstantInt>(CI.getArgOperand(2))->getZExtValue() < 4,
|
|
|
|
"invalid arguments to llvm.prefetch", &CI);
|
2008-10-16 06:00:36 +00:00
|
|
|
break;
|
2008-11-18 23:09:31 +00:00
|
|
|
case Intrinsic::stackprotector:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<AllocaInst>(CI.getArgOperand(1)->stripPointerCasts()),
|
|
|
|
"llvm.stackprotector parameter #2 must resolve to an alloca.", &CI);
|
2008-11-18 23:09:31 +00:00
|
|
|
break;
|
2009-10-13 07:57:33 +00:00
|
|
|
case Intrinsic::lifetime_start:
|
|
|
|
case Intrinsic::lifetime_end:
|
|
|
|
case Intrinsic::invariant_start:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(CI.getArgOperand(0)),
|
|
|
|
"size argument of memory use markers must be a constant integer",
|
|
|
|
&CI);
|
2009-10-13 07:57:33 +00:00
|
|
|
break;
|
|
|
|
case Intrinsic::invariant_end:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(CI.getArgOperand(1)),
|
|
|
|
"llvm.invariant.end parameter #2 must be a constant integer", &CI);
|
2009-10-13 07:57:33 +00:00
|
|
|
break;
|
2015-01-13 00:48:10 +00:00
|
|
|
|
2015-03-05 18:26:34 +00:00
|
|
|
case Intrinsic::frameescape: {
|
2015-01-13 00:48:10 +00:00
|
|
|
BasicBlock *BB = CI.getParent();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(BB == &BB->getParent()->front(),
|
|
|
|
"llvm.frameescape used outside of entry block", &CI);
|
|
|
|
Assert(!SawFrameEscape,
|
|
|
|
"multiple calls to llvm.frameescape in one function", &CI);
|
2015-03-05 18:26:34 +00:00
|
|
|
for (Value *Arg : CI.arg_operands()) {
|
2015-04-02 21:13:31 +00:00
|
|
|
if (isa<ConstantPointerNull>(Arg))
|
|
|
|
continue; // Null values are allowed as placeholders.
|
2015-03-05 18:26:34 +00:00
|
|
|
auto *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(AI && AI->isStaticAlloca(),
|
|
|
|
"llvm.frameescape only accepts static allocas", &CI);
|
2015-03-05 18:26:34 +00:00
|
|
|
}
|
|
|
|
FrameEscapeInfo[BB->getParent()].first = CI.getNumArgOperands();
|
|
|
|
SawFrameEscape = true;
|
2015-01-13 00:48:10 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-01-13 01:51:34 +00:00
|
|
|
case Intrinsic::framerecover: {
|
2015-01-13 00:48:10 +00:00
|
|
|
Value *FnArg = CI.getArgOperand(0)->stripPointerCasts();
|
|
|
|
Function *Fn = dyn_cast<Function>(FnArg);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Fn && !Fn->isDeclaration(),
|
|
|
|
"llvm.framerecover first "
|
|
|
|
"argument must be function defined in this module",
|
|
|
|
&CI);
|
2015-03-05 18:26:34 +00:00
|
|
|
auto *IdxArg = dyn_cast<ConstantInt>(CI.getArgOperand(2));
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(IdxArg, "idx argument of llvm.framerecover must be a constant int",
|
|
|
|
&CI);
|
2015-03-05 18:26:34 +00:00
|
|
|
auto &Entry = FrameEscapeInfo[Fn];
|
|
|
|
Entry.second = unsigned(
|
|
|
|
std::max(uint64_t(Entry.second), IdxArg->getLimitedValue(~0U) + 1));
|
2015-01-13 00:48:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2015-01-30 23:28:05 +00:00
|
|
|
case Intrinsic::experimental_gc_statepoint:
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(!CI.isInlineAsm(),
|
|
|
|
"gc.statepoint support for inline assembly unimplemented", &CI);
|
2015-03-27 05:09:33 +00:00
|
|
|
Assert(CI.getParent()->getParent()->hasGC(),
|
|
|
|
"Enclosing function does not use GC.", &CI);
|
2015-02-03 23:18:47 +00:00
|
|
|
|
|
|
|
VerifyStatepoint(ImmutableCallSite(&CI));
|
2014-12-01 21:18:12 +00:00
|
|
|
break;
|
|
|
|
case Intrinsic::experimental_gc_result_int:
|
|
|
|
case Intrinsic::experimental_gc_result_float:
|
2015-01-22 20:14:38 +00:00
|
|
|
case Intrinsic::experimental_gc_result_ptr:
|
|
|
|
case Intrinsic::experimental_gc_result: {
|
2015-03-27 05:09:33 +00:00
|
|
|
Assert(CI.getParent()->getParent()->hasGC(),
|
|
|
|
"Enclosing function does not use GC.", &CI);
|
2014-12-01 21:18:12 +00:00
|
|
|
// Are we tied to a statepoint properly?
|
|
|
|
CallSite StatepointCS(CI.getArgOperand(0));
|
2015-01-07 22:48:01 +00:00
|
|
|
const Function *StatepointFn =
|
|
|
|
StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr;
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(StatepointFn && StatepointFn->isDeclaration() &&
|
|
|
|
StatepointFn->getIntrinsicID() ==
|
|
|
|
Intrinsic::experimental_gc_statepoint,
|
|
|
|
"gc.result operand #1 must be from a statepoint", &CI,
|
|
|
|
CI.getArgOperand(0));
|
2014-12-03 19:53:15 +00:00
|
|
|
|
2014-12-03 22:23:24 +00:00
|
|
|
// Assert that result type matches wrapped callee.
|
|
|
|
const Value *Target = StatepointCS.getArgument(0);
|
|
|
|
const PointerType *PT = cast<PointerType>(Target->getType());
|
|
|
|
const FunctionType *TargetFuncType =
|
|
|
|
cast<FunctionType>(PT->getElementType());
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CI.getType() == TargetFuncType->getReturnType(),
|
|
|
|
"gc.result result type does not match wrapped callee", &CI);
|
2014-12-01 21:18:12 +00:00
|
|
|
break;
|
2007-09-17 20:30:04 +00:00
|
|
|
}
|
2014-12-01 21:18:12 +00:00
|
|
|
case Intrinsic::experimental_gc_relocate: {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(CI.getNumArgOperands() == 3, "wrong number of arguments", &CI);
|
2015-02-19 11:28:47 +00:00
|
|
|
|
|
|
|
// Check that this relocate is correctly tied to the statepoint
|
|
|
|
|
|
|
|
// This is case for relocate on the unwinding path of an invoke statepoint
|
|
|
|
if (ExtractValueInst *ExtractValue =
|
|
|
|
dyn_cast<ExtractValueInst>(CI.getArgOperand(0))) {
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<LandingPadInst>(ExtractValue->getAggregateOperand()),
|
|
|
|
"gc relocate on unwind path incorrectly linked to the statepoint",
|
|
|
|
&CI);
|
2015-02-19 11:28:47 +00:00
|
|
|
|
|
|
|
const BasicBlock *invokeBB =
|
|
|
|
ExtractValue->getParent()->getUniquePredecessor();
|
|
|
|
|
|
|
|
// Landingpad relocates should have only one predecessor with invoke
|
|
|
|
// statepoint terminator
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(invokeBB, "safepoints should have unique landingpads",
|
|
|
|
ExtractValue->getParent());
|
|
|
|
Assert(invokeBB->getTerminator(), "safepoint block should be well formed",
|
|
|
|
invokeBB);
|
|
|
|
Assert(isStatepoint(invokeBB->getTerminator()),
|
|
|
|
"gc relocate should be linked to a statepoint", invokeBB);
|
2015-02-19 11:28:47 +00:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
// In all other cases relocate should be tied to the statepoint directly.
|
|
|
|
// This covers relocates on a normal return path of invoke statepoint and
|
|
|
|
// relocates of a call statepoint
|
|
|
|
auto Token = CI.getArgOperand(0);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<Instruction>(Token) && isStatepoint(cast<Instruction>(Token)),
|
|
|
|
"gc relocate is incorrectly tied to the statepoint", &CI, Token);
|
2015-02-19 11:28:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Verify rest of the relocate arguments
|
|
|
|
|
|
|
|
GCRelocateOperands ops(&CI);
|
|
|
|
ImmutableCallSite StatepointCS(ops.statepoint());
|
2014-12-01 21:18:12 +00:00
|
|
|
|
|
|
|
// Both the base and derived must be piped through the safepoint
|
|
|
|
Value* Base = CI.getArgOperand(1);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(Base),
|
|
|
|
"gc.relocate operand #2 must be integer offset", &CI);
|
|
|
|
|
2014-12-01 21:18:12 +00:00
|
|
|
Value* Derived = CI.getArgOperand(2);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(isa<ConstantInt>(Derived),
|
|
|
|
"gc.relocate operand #3 must be integer offset", &CI);
|
2014-12-01 21:18:12 +00:00
|
|
|
|
|
|
|
const int BaseIndex = cast<ConstantInt>(Base)->getZExtValue();
|
|
|
|
const int DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
|
|
|
|
// Check the bounds
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCS.arg_size(),
|
|
|
|
"gc.relocate: statepoint base index out of bounds", &CI);
|
|
|
|
Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(),
|
|
|
|
"gc.relocate: statepoint derived index out of bounds", &CI);
|
2015-01-07 22:48:01 +00:00
|
|
|
|
|
|
|
// Check that BaseIndex and DerivedIndex fall within the 'gc parameters'
|
|
|
|
// section of the statepoint's argument
|
2015-03-10 05:58:21 +00:00
|
|
|
Assert(StatepointCS.arg_size() > 0,
|
|
|
|
"gc.statepoint: insufficient arguments");
|
2015-03-11 06:57:30 +00:00
|
|
|
Assert(isa<ConstantInt>(StatepointCS.getArgument(1)),
|
|
|
|
"gc.statement: number of call arguments must be constant integer");
|
2015-03-10 05:58:21 +00:00
|
|
|
const unsigned NumCallArgs =
|
2015-01-07 22:48:01 +00:00
|
|
|
cast<ConstantInt>(StatepointCS.getArgument(1))->getZExtValue();
|
2015-03-10 05:58:21 +00:00
|
|
|
Assert(StatepointCS.arg_size() > NumCallArgs+3,
|
|
|
|
"gc.statepoint: mismatch in number of call arguments");
|
2015-03-11 06:57:30 +00:00
|
|
|
Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs+3)),
|
|
|
|
"gc.statepoint: number of deoptimization arguments must be "
|
|
|
|
"a constant integer");
|
2015-01-07 22:48:01 +00:00
|
|
|
const int NumDeoptArgs =
|
|
|
|
cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 3))->getZExtValue();
|
|
|
|
const int GCParamArgsStart = NumCallArgs + NumDeoptArgs + 4;
|
|
|
|
const int GCParamArgsEnd = StatepointCS.arg_size();
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd,
|
|
|
|
"gc.relocate: statepoint base index doesn't fall within the "
|
|
|
|
"'gc parameters' section of the statepoint call",
|
|
|
|
&CI);
|
|
|
|
Assert(GCParamArgsStart <= DerivedIndex && DerivedIndex < GCParamArgsEnd,
|
|
|
|
"gc.relocate: statepoint derived index doesn't fall within the "
|
|
|
|
"'gc parameters' section of the statepoint call",
|
|
|
|
&CI);
|
2014-12-03 19:53:15 +00:00
|
|
|
|
2014-12-03 22:23:24 +00:00
|
|
|
// Assert that the result type matches the type of the relocated pointer
|
|
|
|
GCRelocateOperands Operands(&CI);
|
2015-03-07 21:15:40 +00:00
|
|
|
Assert(Operands.derivedPtr()->getType() == CI.getType(),
|
|
|
|
"gc.relocate: relocating a pointer shouldn't change its type", &CI);
|
2014-12-01 21:18:12 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
};
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
2015-03-15 01:21:30 +00:00
|
|
|
template <class DbgIntrinsicTy>
|
|
|
|
void Verifier::visitDbgIntrinsic(StringRef Kind, DbgIntrinsicTy &DII) {
|
|
|
|
auto *MD = cast<MetadataAsValue>(DII.getArgOperand(0))->getMetadata();
|
|
|
|
Assert(isa<ValueAsMetadata>(MD) ||
|
|
|
|
(isa<MDNode>(MD) && !cast<MDNode>(MD)->getNumOperands()),
|
|
|
|
"invalid llvm.dbg." + Kind + " intrinsic address/value", &DII, MD);
|
|
|
|
Assert(isa<MDLocalVariable>(DII.getRawVariable()),
|
|
|
|
"invalid llvm.dbg." + Kind + " intrinsic variable", &DII,
|
|
|
|
DII.getRawVariable());
|
|
|
|
Assert(isa<MDExpression>(DII.getRawExpression()),
|
|
|
|
"invalid llvm.dbg." + Kind + " intrinsic expression", &DII,
|
|
|
|
DII.getRawExpression());
|
Verifier: Check that inlined-at locations agree
Check that the `MDLocalVariable::getInlinedAt()` in a debug info
intrinsic's variable always matches the `MDLocation::getInlinedAt()` of
its `!dbg` attachment.
The goal here is to get rid of `MDLocalVariable::getInlinedAt()`
entirely (PR22778), since it's expensive and unnecessary, but I'll let
this verifier check bake for a while (a week maybe?) first. I've
updated the testcases that had the wrong value for `inlinedAt:`.
This checks that things are sane in the IR, but currently things go out
of whack in a few places in the backend. I'll follow shortly with
assertions in the backend (with code fixes).
If you have out-of-tree testcases that just started failing, here's how
I updated these ones:
1. The verifier check gives you the basic block, function, instruction,
and relevant metadata arguments (metadata numbering doesn't
necessarily match the source file, unfortunately).
2. Look at the `@llvm.dbg.*()` instruction, and compare the
`inlinedAt:` fields of the variable argument (second `metadata`
argument) and the `!dbg` attachment.
3. Figure out based on the variable `scope:` chain and the functions in
the file whether the variable has been inlined (and into what), so
you can determine which `inlinedAt:` is actually correct. In all of
the in-tree testcases, the `!MDLocation()` was correct and the
`!MDLocalVariable()` was wrong, but YMMV.
4. Duplicate the metadata that you're going to change, and add/drop the
`inlinedAt:` field from one of them. Be careful that the other
references to the same metadata node point at the correct one.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@234021 91177308-0d34-0410-b5e6-96231b3b80d8
2015-04-03 16:54:30 +00:00
|
|
|
|
|
|
|
// Ignore broken !dbg attachments; they're checked elsewhere.
|
|
|
|
if (MDNode *N = DII.getDebugLoc().getAsMDNode())
|
|
|
|
if (!isa<MDLocation>(N))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// The inlined-at attachments for variables and !dbg attachments must agree.
|
|
|
|
MDLocalVariable *Var = DII.getVariable();
|
|
|
|
MDLocation *VarIA = Var->getInlinedAt();
|
|
|
|
MDLocation *Loc = DII.getDebugLoc();
|
|
|
|
MDLocation *LocIA = Loc ? Loc->getInlinedAt() : nullptr;
|
|
|
|
BasicBlock *BB = DII.getParent();
|
|
|
|
Assert(VarIA == LocIA, "mismatched variable and !dbg inlined-at", &DII, BB,
|
|
|
|
BB ? BB->getParent() : nullptr, Var, VarIA, Loc, LocIA);
|
2015-03-15 01:21:30 +00:00
|
|
|
}
|
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
void Verifier::visitUnresolvedTypeRef(const MDString *S, const MDNode *N) {
|
|
|
|
// This is in its own function so we get an error for each bad type ref (not
|
|
|
|
// just the first).
|
|
|
|
Assert(false, "unresolved type ref", S, N);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::verifyTypeRefs() {
|
|
|
|
auto *CUs = M->getNamedMetadata("llvm.dbg.cu");
|
|
|
|
if (!CUs)
|
|
|
|
return;
|
2014-04-15 16:27:38 +00:00
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
// Visit all the compile units again to check the type references.
|
|
|
|
for (auto *CU : CUs->operands())
|
2015-04-06 17:45:07 +00:00
|
|
|
if (auto Ts = cast<MDCompileUnit>(CU)->getRetainedTypes())
|
|
|
|
for (MDType *Op : Ts)
|
2015-03-31 02:27:32 +00:00
|
|
|
if (auto *T = dyn_cast<MDCompositeType>(Op))
|
|
|
|
TypeRefs.erase(T->getRawIdentifier());
|
|
|
|
if (TypeRefs.empty())
|
|
|
|
return;
|
2014-04-15 16:27:38 +00:00
|
|
|
|
2015-03-31 02:27:32 +00:00
|
|
|
// Sort the unresolved references by name so the output is deterministic.
|
|
|
|
typedef std::pair<const MDString *, const MDNode *> TypeRef;
|
|
|
|
SmallVector<TypeRef, 32> Unresolved(TypeRefs.begin(), TypeRefs.end());
|
|
|
|
std::sort(Unresolved.begin(), Unresolved.end(),
|
|
|
|
[](const TypeRef &LHS, const TypeRef &RHS) {
|
|
|
|
return LHS.first->getString() < RHS.first->getString();
|
|
|
|
});
|
|
|
|
|
|
|
|
// Visit the unresolved refs (printing out the errors).
|
|
|
|
for (const TypeRef &TR : Unresolved)
|
|
|
|
visitUnresolvedTypeRef(TR.first, TR.second);
|
2013-07-19 00:31:03 +00:00
|
|
|
}
|
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implement the public interfaces to this file...
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
bool llvm::verifyFunction(const Function &f, raw_ostream *OS) {
|
2014-01-17 11:09:34 +00:00
|
|
|
Function &F = const_cast<Function &>(f);
|
2007-01-30 20:08:39 +00:00
|
|
|
assert(!F.isDeclaration() && "Cannot verify external functions");
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
raw_null_ostream NullStr;
|
|
|
|
Verifier V(OS ? *OS : NullStr);
|
|
|
|
|
|
|
|
// Note that this function's return value is inverted from what you would
|
|
|
|
// expect of a function called "verify".
|
|
|
|
return !V.verify(F);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool llvm::verifyModule(const Module &M, raw_ostream *OS) {
|
|
|
|
raw_null_ostream NullStr;
|
|
|
|
Verifier V(OS ? *OS : NullStr);
|
|
|
|
|
|
|
|
bool Broken = false;
|
|
|
|
for (Module::const_iterator I = M.begin(), E = M.end(); I != E; ++I)
|
2014-10-24 18:13:04 +00:00
|
|
|
if (!I->isDeclaration() && !I->isMaterializable())
|
2014-01-19 02:22:18 +00:00
|
|
|
Broken |= !V.verify(*I);
|
|
|
|
|
|
|
|
// Note that this function's return value is inverted from what you would
|
|
|
|
// expect of a function called "verify".
|
Verifier: Remove the separate DebugInfoVerifier class
Remove the separate `DebugInfoVerifier` class, as a partial step toward
better integrating debug info verification with the `Verifier`.
Right now, verification of debug info is kind of a mess.
- There are `DIDescriptor::Verify()` checks live in `DebugInfo.cpp`.
These return `bool`, and there's no way to see (except by opening a
debugger) why they fail.
- We rely on `DebugInfoFinder` to traverse the debug info graph and
dig up nodes. However, the regular `Verifier` visits many of these
nodes when it calls into debug info intrinsic operands. Visiting
twice and running different checks is kind of absurd.
- Moreover, `DebugInfoFinder` asserts on failed type resolution -- the
verifier should never assert!
By integrating the two verifiers, I'm aiming at solving these problems
(work to be done, obviously). Verification can be localized to the
`Verifier`; we can use a naive `MDNode` operand traversal to find all
the nodes; we can verify type references instead of asserting on
failure.
There are `assert()`s sprinkled throughout the optimizer and dwarf
backend on `DIDescriptor::Verify()` checks. This is a hangover from
when the debug info verifier was off, so I plan to remove them as I go
(once I confirm that the checks are done at verification time).
Note: to keep the behaviour of only running the debug info verifier when
-verify succeeds, I've added an `EverBroken` flag. Once the
`DebugInfoFinder` assertions are gone and the two traversals have been
merged, I expect to be able to remove this.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@232790 91177308-0d34-0410-b5e6-96231b3b80d8
2015-03-20 00:48:23 +00:00
|
|
|
return !V.verify(M) || Broken;
|
2014-01-19 02:22:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
2014-01-20 11:34:08 +00:00
|
|
|
struct VerifierLegacyPass : public FunctionPass {
|
2014-01-19 02:22:18 +00:00
|
|
|
static char ID;
|
|
|
|
|
|
|
|
Verifier V;
|
|
|
|
bool FatalErrors;
|
|
|
|
|
2015-03-15 00:46:57 +00:00
|
|
|
VerifierLegacyPass() : FunctionPass(ID), V(dbgs()), FatalErrors(true) {
|
2014-01-20 11:34:08 +00:00
|
|
|
initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry());
|
2014-01-19 02:22:18 +00:00
|
|
|
}
|
2014-01-20 11:34:08 +00:00
|
|
|
explicit VerifierLegacyPass(bool FatalErrors)
|
2014-01-19 02:22:18 +00:00
|
|
|
: FunctionPass(ID), V(dbgs()), FatalErrors(FatalErrors) {
|
2014-01-20 11:34:08 +00:00
|
|
|
initializeVerifierLegacyPassPass(*PassRegistry::getPassRegistry());
|
2014-01-19 02:22:18 +00:00
|
|
|
}
|
|
|
|
|
2014-03-05 06:35:38 +00:00
|
|
|
bool runOnFunction(Function &F) override {
|
2014-01-19 02:22:18 +00:00
|
|
|
if (!V.verify(F) && FatalErrors)
|
|
|
|
report_fatal_error("Broken function found, compilation aborted!");
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-03-05 06:35:38 +00:00
|
|
|
bool doFinalization(Module &M) override {
|
2014-01-19 02:22:18 +00:00
|
|
|
if (!V.verify(M) && FatalErrors)
|
|
|
|
report_fatal_error("Broken module found, compilation aborted!");
|
|
|
|
|
2014-04-15 16:27:38 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
|
|
AU.setPreservesAll();
|
|
|
|
}
|
|
|
|
};
|
2002-02-20 17:55:43 +00:00
|
|
|
}
|
|
|
|
|
2014-01-20 11:34:08 +00:00
|
|
|
char VerifierLegacyPass::ID = 0;
|
|
|
|
INITIALIZE_PASS(VerifierLegacyPass, "verify", "Module Verifier", false, false)
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2014-01-19 02:22:18 +00:00
|
|
|
FunctionPass *llvm::createVerifierPass(bool FatalErrors) {
|
2014-01-20 11:34:08 +00:00
|
|
|
return new VerifierLegacyPass(FatalErrors);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2014-01-19 02:22:18 +00:00
|
|
|
|
2015-01-05 02:47:05 +00:00
|
|
|
PreservedAnalyses VerifierPass::run(Module &M) {
|
|
|
|
if (verifyModule(M, &dbgs()) && FatalErrors)
|
2014-01-20 11:34:08 +00:00
|
|
|
report_fatal_error("Broken module found, compilation aborted!");
|
|
|
|
|
|
|
|
return PreservedAnalyses::all();
|
|
|
|
}
|
|
|
|
|
2015-01-05 02:47:05 +00:00
|
|
|
PreservedAnalyses VerifierPass::run(Function &F) {
|
|
|
|
if (verifyFunction(F, &dbgs()) && FatalErrors)
|
2014-01-20 11:34:08 +00:00
|
|
|
report_fatal_error("Broken function found, compilation aborted!");
|
|
|
|
|
|
|
|
return PreservedAnalyses::all();
|
|
|
|
}
|