2007-04-29 05:31:57 +00:00
|
|
|
//===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//
|
2007-04-22 06:24:45 +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.
|
2007-04-22 06:24:45 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Bitcode writer implementation.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Bitcode/ReaderWriter.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "ValueEnumerator.h"
|
|
|
|
#include "llvm/ADT/Triple.h"
|
2007-04-22 06:24:45 +00:00
|
|
|
#include "llvm/Bitcode/BitstreamWriter.h"
|
2007-04-23 01:01:37 +00:00
|
|
|
#include "llvm/Bitcode/LLVMBitCodes.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
|
|
|
#include "llvm/IR/InlineAsm.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/Operator.h"
|
2014-07-25 14:49:26 +00:00
|
|
|
#include "llvm/IR/UseListOrder.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/ValueSymbolTable.h"
|
2011-12-07 21:44:12 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2009-07-11 20:10:48 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2007-04-22 06:24:45 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Program.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-12-19 20:43:38 +00:00
|
|
|
#include <cctype>
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
#include <map>
|
2007-04-22 06:24:45 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2007-05-04 20:52:02 +00:00
|
|
|
/// These are manifest constants used by the bitcode writer. They do not need to
|
|
|
|
/// be kept in sync with the reader, but need to be consistent within this file.
|
|
|
|
enum {
|
|
|
|
// VALUE_SYMTAB_BLOCK abbrev id's.
|
|
|
|
VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
|
2007-05-04 20:58:35 +00:00
|
|
|
VST_ENTRY_7_ABBREV,
|
2007-05-05 01:26:50 +00:00
|
|
|
VST_ENTRY_6_ABBREV,
|
2007-05-05 07:36:14 +00:00
|
|
|
VST_BBENTRY_6_ABBREV,
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
// CONSTANTS_BLOCK abbrev id's.
|
|
|
|
CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
|
|
|
|
CONSTANTS_INTEGER_ABBREV,
|
|
|
|
CONSTANTS_CE_CAST_Abbrev,
|
2007-05-05 07:44:49 +00:00
|
|
|
CONSTANTS_NULL_Abbrev,
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:44:49 +00:00
|
|
|
// FUNCTION_BLOCK abbrev id's.
|
2007-05-06 01:28:01 +00:00
|
|
|
FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
|
2007-05-06 02:38:57 +00:00
|
|
|
FUNCTION_INST_BINOP_ABBREV,
|
2009-07-20 21:19:07 +00:00
|
|
|
FUNCTION_INST_BINOP_FLAGS_ABBREV,
|
2007-05-06 02:38:57 +00:00
|
|
|
FUNCTION_INST_CAST_ABBREV,
|
2007-05-06 01:28:01 +00:00
|
|
|
FUNCTION_INST_RET_VOID_ABBREV,
|
|
|
|
FUNCTION_INST_RET_VAL_ABBREV,
|
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
|
|
|
FUNCTION_INST_UNREACHABLE_ABBREV
|
2007-05-04 20:52:02 +00:00
|
|
|
};
|
|
|
|
|
2007-04-24 07:07:11 +00:00
|
|
|
static unsigned GetEncodedCastOpcode(unsigned Opcode) {
|
|
|
|
switch (Opcode) {
|
2009-07-14 16:55:14 +00:00
|
|
|
default: llvm_unreachable("Unknown cast instruction!");
|
2007-04-24 07:07:11 +00:00
|
|
|
case Instruction::Trunc : return bitc::CAST_TRUNC;
|
|
|
|
case Instruction::ZExt : return bitc::CAST_ZEXT;
|
|
|
|
case Instruction::SExt : return bitc::CAST_SEXT;
|
|
|
|
case Instruction::FPToUI : return bitc::CAST_FPTOUI;
|
|
|
|
case Instruction::FPToSI : return bitc::CAST_FPTOSI;
|
|
|
|
case Instruction::UIToFP : return bitc::CAST_UITOFP;
|
|
|
|
case Instruction::SIToFP : return bitc::CAST_SITOFP;
|
|
|
|
case Instruction::FPTrunc : return bitc::CAST_FPTRUNC;
|
|
|
|
case Instruction::FPExt : return bitc::CAST_FPEXT;
|
|
|
|
case Instruction::PtrToInt: return bitc::CAST_PTRTOINT;
|
|
|
|
case Instruction::IntToPtr: return bitc::CAST_INTTOPTR;
|
|
|
|
case Instruction::BitCast : return bitc::CAST_BITCAST;
|
2013-11-18 02:51:33 +00:00
|
|
|
case Instruction::AddrSpaceCast: return bitc::CAST_ADDRSPACECAST;
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned GetEncodedBinaryOpcode(unsigned Opcode) {
|
|
|
|
switch (Opcode) {
|
2009-07-14 16:55:14 +00:00
|
|
|
default: llvm_unreachable("Unknown binary instruction!");
|
2009-06-04 22:49:04 +00:00
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::FAdd: return bitc::BINOP_ADD;
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::FSub: return bitc::BINOP_SUB;
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::FMul: return bitc::BINOP_MUL;
|
2007-04-24 07:07:11 +00:00
|
|
|
case Instruction::UDiv: return bitc::BINOP_UDIV;
|
|
|
|
case Instruction::FDiv:
|
|
|
|
case Instruction::SDiv: return bitc::BINOP_SDIV;
|
|
|
|
case Instruction::URem: return bitc::BINOP_UREM;
|
|
|
|
case Instruction::FRem:
|
|
|
|
case Instruction::SRem: return bitc::BINOP_SREM;
|
|
|
|
case Instruction::Shl: return bitc::BINOP_SHL;
|
|
|
|
case Instruction::LShr: return bitc::BINOP_LSHR;
|
|
|
|
case Instruction::AShr: return bitc::BINOP_ASHR;
|
|
|
|
case Instruction::And: return bitc::BINOP_AND;
|
|
|
|
case Instruction::Or: return bitc::BINOP_OR;
|
|
|
|
case Instruction::Xor: return bitc::BINOP_XOR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-28 21:48:00 +00:00
|
|
|
static unsigned GetEncodedRMWOperation(AtomicRMWInst::BinOp Op) {
|
|
|
|
switch (Op) {
|
|
|
|
default: llvm_unreachable("Unknown RMW operation!");
|
|
|
|
case AtomicRMWInst::Xchg: return bitc::RMW_XCHG;
|
|
|
|
case AtomicRMWInst::Add: return bitc::RMW_ADD;
|
|
|
|
case AtomicRMWInst::Sub: return bitc::RMW_SUB;
|
|
|
|
case AtomicRMWInst::And: return bitc::RMW_AND;
|
|
|
|
case AtomicRMWInst::Nand: return bitc::RMW_NAND;
|
|
|
|
case AtomicRMWInst::Or: return bitc::RMW_OR;
|
|
|
|
case AtomicRMWInst::Xor: return bitc::RMW_XOR;
|
|
|
|
case AtomicRMWInst::Max: return bitc::RMW_MAX;
|
|
|
|
case AtomicRMWInst::Min: return bitc::RMW_MIN;
|
|
|
|
case AtomicRMWInst::UMax: return bitc::RMW_UMAX;
|
|
|
|
case AtomicRMWInst::UMin: return bitc::RMW_UMIN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-25 23:16:38 +00:00
|
|
|
static unsigned GetEncodedOrdering(AtomicOrdering Ordering) {
|
|
|
|
switch (Ordering) {
|
|
|
|
case NotAtomic: return bitc::ORDERING_NOTATOMIC;
|
|
|
|
case Unordered: return bitc::ORDERING_UNORDERED;
|
|
|
|
case Monotonic: return bitc::ORDERING_MONOTONIC;
|
|
|
|
case Acquire: return bitc::ORDERING_ACQUIRE;
|
|
|
|
case Release: return bitc::ORDERING_RELEASE;
|
|
|
|
case AcquireRelease: return bitc::ORDERING_ACQREL;
|
|
|
|
case SequentiallyConsistent: return bitc::ORDERING_SEQCST;
|
|
|
|
}
|
2012-01-10 18:08:01 +00:00
|
|
|
llvm_unreachable("Invalid ordering");
|
2011-07-25 23:16:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned GetEncodedSynchScope(SynchronizationScope SynchScope) {
|
|
|
|
switch (SynchScope) {
|
|
|
|
case SingleThread: return bitc::SYNCHSCOPE_SINGLETHREAD;
|
|
|
|
case CrossThread: return bitc::SYNCHSCOPE_CROSSTHREAD;
|
|
|
|
}
|
2012-01-10 18:08:01 +00:00
|
|
|
llvm_unreachable("Invalid synch scope");
|
2011-07-25 23:16:38 +00:00
|
|
|
}
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
static void WriteStringRecord(unsigned Code, StringRef Str,
|
2007-04-22 06:24:45 +00:00
|
|
|
unsigned AbbrevToUse, BitstreamWriter &Stream) {
|
|
|
|
SmallVector<unsigned, 64> Vals;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 19:11:41 +00:00
|
|
|
// Code: [strchar x N]
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
for (unsigned i = 0, e = Str.size(); i != e; ++i) {
|
|
|
|
if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(Str[i]))
|
|
|
|
AbbrevToUse = 0;
|
2007-04-22 06:24:45 +00:00
|
|
|
Vals.push_back(Str[i]);
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit the finished record.
|
|
|
|
Stream.EmitRecord(Code, Vals, AbbrevToUse);
|
|
|
|
}
|
|
|
|
|
2013-07-26 04:16:55 +00:00
|
|
|
static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) {
|
|
|
|
switch (Kind) {
|
|
|
|
case Attribute::Alignment:
|
|
|
|
return bitc::ATTR_KIND_ALIGNMENT;
|
|
|
|
case Attribute::AlwaysInline:
|
|
|
|
return bitc::ATTR_KIND_ALWAYS_INLINE;
|
|
|
|
case Attribute::Builtin:
|
|
|
|
return bitc::ATTR_KIND_BUILTIN;
|
|
|
|
case Attribute::ByVal:
|
|
|
|
return bitc::ATTR_KIND_BY_VAL;
|
2013-12-19 02:14:12 +00:00
|
|
|
case Attribute::InAlloca:
|
|
|
|
return bitc::ATTR_KIND_IN_ALLOCA;
|
2013-07-26 04:16:55 +00:00
|
|
|
case Attribute::Cold:
|
|
|
|
return bitc::ATTR_KIND_COLD;
|
|
|
|
case Attribute::InlineHint:
|
|
|
|
return bitc::ATTR_KIND_INLINE_HINT;
|
|
|
|
case Attribute::InReg:
|
|
|
|
return bitc::ATTR_KIND_IN_REG;
|
2014-06-05 19:29:43 +00:00
|
|
|
case Attribute::JumpTable:
|
|
|
|
return bitc::ATTR_KIND_JUMP_TABLE;
|
2013-07-26 04:16:55 +00:00
|
|
|
case Attribute::MinSize:
|
|
|
|
return bitc::ATTR_KIND_MIN_SIZE;
|
|
|
|
case Attribute::Naked:
|
|
|
|
return bitc::ATTR_KIND_NAKED;
|
|
|
|
case Attribute::Nest:
|
|
|
|
return bitc::ATTR_KIND_NEST;
|
|
|
|
case Attribute::NoAlias:
|
|
|
|
return bitc::ATTR_KIND_NO_ALIAS;
|
|
|
|
case Attribute::NoBuiltin:
|
|
|
|
return bitc::ATTR_KIND_NO_BUILTIN;
|
|
|
|
case Attribute::NoCapture:
|
|
|
|
return bitc::ATTR_KIND_NO_CAPTURE;
|
|
|
|
case Attribute::NoDuplicate:
|
|
|
|
return bitc::ATTR_KIND_NO_DUPLICATE;
|
|
|
|
case Attribute::NoImplicitFloat:
|
|
|
|
return bitc::ATTR_KIND_NO_IMPLICIT_FLOAT;
|
|
|
|
case Attribute::NoInline:
|
|
|
|
return bitc::ATTR_KIND_NO_INLINE;
|
|
|
|
case Attribute::NonLazyBind:
|
|
|
|
return bitc::ATTR_KIND_NON_LAZY_BIND;
|
2014-05-20 01:23:40 +00:00
|
|
|
case Attribute::NonNull:
|
|
|
|
return bitc::ATTR_KIND_NON_NULL;
|
2014-07-18 15:51:28 +00:00
|
|
|
case Attribute::Dereferenceable:
|
|
|
|
return bitc::ATTR_KIND_DEREFERENCEABLE;
|
2013-07-26 04:16:55 +00:00
|
|
|
case Attribute::NoRedZone:
|
|
|
|
return bitc::ATTR_KIND_NO_RED_ZONE;
|
|
|
|
case Attribute::NoReturn:
|
|
|
|
return bitc::ATTR_KIND_NO_RETURN;
|
|
|
|
case Attribute::NoUnwind:
|
|
|
|
return bitc::ATTR_KIND_NO_UNWIND;
|
|
|
|
case Attribute::OptimizeForSize:
|
|
|
|
return bitc::ATTR_KIND_OPTIMIZE_FOR_SIZE;
|
2013-08-23 11:53:55 +00:00
|
|
|
case Attribute::OptimizeNone:
|
|
|
|
return bitc::ATTR_KIND_OPTIMIZE_NONE;
|
2013-07-26 04:16:55 +00:00
|
|
|
case Attribute::ReadNone:
|
|
|
|
return bitc::ATTR_KIND_READ_NONE;
|
|
|
|
case Attribute::ReadOnly:
|
|
|
|
return bitc::ATTR_KIND_READ_ONLY;
|
|
|
|
case Attribute::Returned:
|
|
|
|
return bitc::ATTR_KIND_RETURNED;
|
|
|
|
case Attribute::ReturnsTwice:
|
|
|
|
return bitc::ATTR_KIND_RETURNS_TWICE;
|
|
|
|
case Attribute::SExt:
|
|
|
|
return bitc::ATTR_KIND_S_EXT;
|
|
|
|
case Attribute::StackAlignment:
|
|
|
|
return bitc::ATTR_KIND_STACK_ALIGNMENT;
|
|
|
|
case Attribute::StackProtect:
|
|
|
|
return bitc::ATTR_KIND_STACK_PROTECT;
|
|
|
|
case Attribute::StackProtectReq:
|
|
|
|
return bitc::ATTR_KIND_STACK_PROTECT_REQ;
|
|
|
|
case Attribute::StackProtectStrong:
|
|
|
|
return bitc::ATTR_KIND_STACK_PROTECT_STRONG;
|
|
|
|
case Attribute::StructRet:
|
|
|
|
return bitc::ATTR_KIND_STRUCT_RET;
|
|
|
|
case Attribute::SanitizeAddress:
|
|
|
|
return bitc::ATTR_KIND_SANITIZE_ADDRESS;
|
|
|
|
case Attribute::SanitizeThread:
|
|
|
|
return bitc::ATTR_KIND_SANITIZE_THREAD;
|
|
|
|
case Attribute::SanitizeMemory:
|
|
|
|
return bitc::ATTR_KIND_SANITIZE_MEMORY;
|
|
|
|
case Attribute::UWTable:
|
|
|
|
return bitc::ATTR_KIND_UW_TABLE;
|
|
|
|
case Attribute::ZExt:
|
|
|
|
return bitc::ATTR_KIND_Z_EXT;
|
|
|
|
case Attribute::EndAttrKinds:
|
|
|
|
llvm_unreachable("Can not encode end-attribute kinds marker.");
|
|
|
|
case Attribute::None:
|
|
|
|
llvm_unreachable("Can not encode none-attribute.");
|
|
|
|
}
|
|
|
|
|
|
|
|
llvm_unreachable("Trying to encode unknown attribute");
|
|
|
|
}
|
|
|
|
|
2013-02-10 23:09:32 +00:00
|
|
|
static void WriteAttributeGroupTable(const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
2013-02-11 22:33:26 +00:00
|
|
|
const std::vector<AttributeSet> &AttrGrps = VE.getAttributeGroups();
|
|
|
|
if (AttrGrps.empty()) return;
|
2013-02-10 23:09:32 +00:00
|
|
|
|
|
|
|
Stream.EnterSubblock(bitc::PARAMATTR_GROUP_BLOCK_ID, 3);
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
2013-02-11 22:33:26 +00:00
|
|
|
for (unsigned i = 0, e = AttrGrps.size(); i != e; ++i) {
|
|
|
|
AttributeSet AS = AttrGrps[i];
|
2013-02-10 23:09:32 +00:00
|
|
|
for (unsigned i = 0, e = AS.getNumSlots(); i != e; ++i) {
|
|
|
|
AttributeSet A = AS.getSlotAttributes(i);
|
|
|
|
|
2013-02-11 22:33:26 +00:00
|
|
|
Record.push_back(VE.getAttributeGroupID(A));
|
2013-02-10 23:09:32 +00:00
|
|
|
Record.push_back(AS.getSlotIndex(i));
|
|
|
|
|
|
|
|
for (AttributeSet::iterator I = AS.begin(0), E = AS.end(0);
|
|
|
|
I != E; ++I) {
|
|
|
|
Attribute Attr = *I;
|
|
|
|
if (Attr.isEnumAttribute()) {
|
|
|
|
Record.push_back(0);
|
2013-07-26 04:16:55 +00:00
|
|
|
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
|
2014-07-18 06:51:55 +00:00
|
|
|
} else if (Attr.isIntAttribute()) {
|
2013-02-10 23:09:32 +00:00
|
|
|
Record.push_back(1);
|
2013-07-26 04:16:55 +00:00
|
|
|
Record.push_back(getAttrKindEncoding(Attr.getKindAsEnum()));
|
2013-02-10 23:09:32 +00:00
|
|
|
Record.push_back(Attr.getValueAsInt());
|
|
|
|
} else {
|
|
|
|
StringRef Kind = Attr.getKindAsString();
|
|
|
|
StringRef Val = Attr.getValueAsString();
|
|
|
|
|
|
|
|
Record.push_back(Val.empty() ? 3 : 4);
|
|
|
|
Record.append(Kind.begin(), Kind.end());
|
|
|
|
Record.push_back(0);
|
|
|
|
if (!Val.empty()) {
|
|
|
|
Record.append(Val.begin(), Val.end());
|
|
|
|
Record.push_back(0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Stream.EmitRecord(bitc::PARAMATTR_GRP_CODE_ENTRY, Record);
|
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
static void WriteAttributeTable(const ValueEnumerator &VE,
|
2007-05-04 00:44:52 +00:00
|
|
|
BitstreamWriter &Stream) {
|
2012-12-07 23:16:57 +00:00
|
|
|
const std::vector<AttributeSet> &Attrs = VE.getAttributes();
|
2007-05-04 00:44:52 +00:00
|
|
|
if (Attrs.empty()) return;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 02:59:04 +00:00
|
|
|
Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
|
2012-12-07 23:16:57 +00:00
|
|
|
const AttributeSet &A = Attrs[i];
|
2013-02-12 08:13:50 +00:00
|
|
|
for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i)
|
|
|
|
Record.push_back(VE.getAttributeGroupID(A.getSlotAttributes(i)));
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-02-12 08:13:50 +00:00
|
|
|
Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
|
2007-05-04 02:59:04 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 02:59:04 +00:00
|
|
|
Stream.ExitBlock();
|
2007-05-04 00:44:52 +00:00
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
|
|
|
|
/// WriteTypeTable - Write out the type table for a module.
|
|
|
|
static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
|
|
|
|
const ValueEnumerator::TypeList &TypeList = VE.getTypes();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */);
|
2007-04-22 06:24:45 +00:00
|
|
|
SmallVector<uint64_t, 64> TypeVals;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-12-08 00:38:45 +00:00
|
|
|
uint64_t NumBits = Log2_32_Ceil(VE.getTypes().size()+1);
|
|
|
|
|
2007-05-05 06:30:12 +00:00
|
|
|
// Abbrev for TYPE_CODE_POINTER.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER));
|
2011-12-08 00:38:45 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
|
2007-12-12 08:44:39 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0
|
2007-05-05 06:30:12 +00:00
|
|
|
unsigned PtrAbbrev = Stream.EmitAbbrev(Abbv);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 06:30:12 +00:00
|
|
|
// Abbrev for TYPE_CODE_FUNCTION.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
2011-12-08 00:38:45 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
|
|
|
|
|
2007-05-05 06:30:12 +00:00
|
|
|
unsigned FunctionAbbrev = Stream.EmitAbbrev(Abbv);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
// Abbrev for TYPE_CODE_STRUCT_ANON.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_ANON));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
2011-12-08 00:38:45 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
unsigned StructAnonAbbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
|
|
|
|
// Abbrev for TYPE_CODE_STRUCT_NAME.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAME));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
|
|
|
|
unsigned StructNameAbbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
|
|
|
|
// Abbrev for TYPE_CODE_STRUCT_NAMED.
|
2007-05-05 06:30:12 +00:00
|
|
|
Abbv = new BitCodeAbbrev();
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED));
|
2007-05-05 06:30:12 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
2011-12-08 00:38:45 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
|
|
|
|
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
unsigned StructNamedAbbrev = Stream.EmitAbbrev(Abbv);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-05-05 06:30:12 +00:00
|
|
|
// Abbrev for TYPE_CODE_ARRAY.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // size
|
2011-12-08 00:38:45 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, NumBits));
|
|
|
|
|
2007-05-05 06:30:12 +00:00
|
|
|
unsigned ArrayAbbrev = Stream.EmitAbbrev(Abbv);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit an entry count so the reader can reserve space.
|
|
|
|
TypeVals.push_back(TypeList.size());
|
|
|
|
Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);
|
|
|
|
TypeVals.clear();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Loop over all of the types, emitting each in turn.
|
|
|
|
for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *T = TypeList[i];
|
2007-04-22 06:24:45 +00:00
|
|
|
int AbbrevToUse = 0;
|
|
|
|
unsigned Code = 0;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
switch (T->getTypeID()) {
|
2012-11-25 15:23:39 +00:00
|
|
|
case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break;
|
|
|
|
case Type::HalfTyID: Code = bitc::TYPE_CODE_HALF; break;
|
|
|
|
case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break;
|
|
|
|
case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
|
|
|
|
case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
|
|
|
|
case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
|
2007-08-03 01:03:46 +00:00
|
|
|
case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
|
2012-11-25 15:23:39 +00:00
|
|
|
case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break;
|
|
|
|
case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break;
|
|
|
|
case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break;
|
2007-04-22 06:24:45 +00:00
|
|
|
case Type::IntegerTyID:
|
|
|
|
// INTEGER: [width]
|
|
|
|
Code = bitc::TYPE_CODE_INTEGER;
|
|
|
|
TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
|
|
|
|
break;
|
2007-12-11 12:20:47 +00:00
|
|
|
case Type::PointerTyID: {
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = cast<PointerType>(T);
|
2007-12-12 08:44:39 +00:00
|
|
|
// POINTER: [pointee type, address space]
|
2007-04-22 06:24:45 +00:00
|
|
|
Code = bitc::TYPE_CODE_POINTER;
|
2007-12-11 08:59:05 +00:00
|
|
|
TypeVals.push_back(VE.getTypeID(PTy->getElementType()));
|
2007-12-12 08:44:39 +00:00
|
|
|
unsigned AddressSpace = PTy->getAddressSpace();
|
|
|
|
TypeVals.push_back(AddressSpace);
|
|
|
|
if (AddressSpace == 0) AbbrevToUse = PtrAbbrev;
|
2007-04-22 06:24:45 +00:00
|
|
|
break;
|
2007-12-11 12:20:47 +00:00
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
case Type::FunctionTyID: {
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FT = cast<FunctionType>(T);
|
2011-11-03 00:14:01 +00:00
|
|
|
// FUNCTION: [isvararg, retty, paramty x N]
|
2007-04-22 06:24:45 +00:00
|
|
|
Code = bitc::TYPE_CODE_FUNCTION;
|
|
|
|
TypeVals.push_back(FT->isVarArg());
|
|
|
|
TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
|
|
|
|
for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
|
|
|
|
TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
|
2007-05-05 06:30:12 +00:00
|
|
|
AbbrevToUse = FunctionAbbrev;
|
2007-04-22 06:24:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::StructTyID: {
|
2011-07-18 04:54:35 +00:00
|
|
|
StructType *ST = cast<StructType>(T);
|
2007-05-05 06:30:12 +00:00
|
|
|
// STRUCT: [ispacked, eltty x N]
|
2007-04-22 06:24:45 +00:00
|
|
|
TypeVals.push_back(ST->isPacked());
|
2007-05-04 19:11:41 +00:00
|
|
|
// Output all of the element types.
|
2007-04-22 06:24:45 +00:00
|
|
|
for (StructType::element_iterator I = ST->element_begin(),
|
|
|
|
E = ST->element_end(); I != E; ++I)
|
|
|
|
TypeVals.push_back(VE.getTypeID(*I));
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2011-08-12 18:06:37 +00:00
|
|
|
if (ST->isLiteral()) {
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Code = bitc::TYPE_CODE_STRUCT_ANON;
|
|
|
|
AbbrevToUse = StructAnonAbbrev;
|
|
|
|
} else {
|
|
|
|
if (ST->isOpaque()) {
|
|
|
|
Code = bitc::TYPE_CODE_OPAQUE;
|
|
|
|
} else {
|
|
|
|
Code = bitc::TYPE_CODE_STRUCT_NAMED;
|
|
|
|
AbbrevToUse = StructNamedAbbrev;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Emit the name if it is present.
|
|
|
|
if (!ST->getName().empty())
|
|
|
|
WriteStringRecord(bitc::TYPE_CODE_STRUCT_NAME, ST->getName(),
|
|
|
|
StructNameAbbrev, Stream);
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::ArrayTyID: {
|
2011-07-18 04:54:35 +00:00
|
|
|
ArrayType *AT = cast<ArrayType>(T);
|
2007-04-22 06:24:45 +00:00
|
|
|
// ARRAY: [numelts, eltty]
|
|
|
|
Code = bitc::TYPE_CODE_ARRAY;
|
|
|
|
TypeVals.push_back(AT->getNumElements());
|
|
|
|
TypeVals.push_back(VE.getTypeID(AT->getElementType()));
|
2007-05-05 06:30:12 +00:00
|
|
|
AbbrevToUse = ArrayAbbrev;
|
2007-04-22 06:24:45 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Type::VectorTyID: {
|
2011-07-18 04:54:35 +00:00
|
|
|
VectorType *VT = cast<VectorType>(T);
|
2007-04-22 06:24:45 +00:00
|
|
|
// VECTOR [numelts, eltty]
|
|
|
|
Code = bitc::TYPE_CODE_VECTOR;
|
|
|
|
TypeVals.push_back(VT->getNumElements());
|
|
|
|
TypeVals.push_back(VE.getTypeID(VT->getElementType()));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Emit the finished record.
|
|
|
|
Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
|
|
|
|
TypeVals.clear();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2014-05-26 13:38:51 +00:00
|
|
|
static unsigned getEncodedLinkage(const GlobalValue &GV) {
|
|
|
|
switch (GV.getLinkage()) {
|
2015-01-08 16:25:01 +00:00
|
|
|
case GlobalValue::ExternalLinkage:
|
|
|
|
return 0;
|
|
|
|
case GlobalValue::WeakAnyLinkage:
|
2015-01-14 20:55:48 +00:00
|
|
|
return 16;
|
2015-01-08 16:25:01 +00:00
|
|
|
case GlobalValue::AppendingLinkage:
|
|
|
|
return 2;
|
|
|
|
case GlobalValue::InternalLinkage:
|
|
|
|
return 3;
|
|
|
|
case GlobalValue::LinkOnceAnyLinkage:
|
2015-01-14 20:55:48 +00:00
|
|
|
return 18;
|
2015-01-08 16:25:01 +00:00
|
|
|
case GlobalValue::ExternalWeakLinkage:
|
|
|
|
return 7;
|
|
|
|
case GlobalValue::CommonLinkage:
|
|
|
|
return 8;
|
|
|
|
case GlobalValue::PrivateLinkage:
|
|
|
|
return 9;
|
|
|
|
case GlobalValue::WeakODRLinkage:
|
2015-01-14 20:55:48 +00:00
|
|
|
return 17;
|
2015-01-08 16:25:01 +00:00
|
|
|
case GlobalValue::LinkOnceODRLinkage:
|
2015-01-14 20:55:48 +00:00
|
|
|
return 19;
|
2015-01-08 16:25:01 +00:00
|
|
|
case GlobalValue::AvailableExternallyLinkage:
|
|
|
|
return 12;
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
2012-01-10 18:08:01 +00:00
|
|
|
llvm_unreachable("Invalid linkage");
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
|
2014-05-26 13:38:51 +00:00
|
|
|
static unsigned getEncodedVisibility(const GlobalValue &GV) {
|
|
|
|
switch (GV.getVisibility()) {
|
2007-04-29 20:56:48 +00:00
|
|
|
case GlobalValue::DefaultVisibility: return 0;
|
|
|
|
case GlobalValue::HiddenVisibility: return 1;
|
|
|
|
case GlobalValue::ProtectedVisibility: return 2;
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
2012-01-10 18:08:01 +00:00
|
|
|
llvm_unreachable("Invalid visibility");
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
|
2014-05-26 13:38:51 +00:00
|
|
|
static unsigned getEncodedDLLStorageClass(const GlobalValue &GV) {
|
|
|
|
switch (GV.getDLLStorageClass()) {
|
2014-01-14 15:22:47 +00:00
|
|
|
case GlobalValue::DefaultStorageClass: return 0;
|
|
|
|
case GlobalValue::DLLImportStorageClass: return 1;
|
|
|
|
case GlobalValue::DLLExportStorageClass: return 2;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Invalid DLL storage class");
|
|
|
|
}
|
|
|
|
|
2014-05-28 18:15:43 +00:00
|
|
|
static unsigned getEncodedThreadLocalMode(const GlobalValue &GV) {
|
2014-05-26 13:38:51 +00:00
|
|
|
switch (GV.getThreadLocalMode()) {
|
2012-06-23 11:37:03 +00:00
|
|
|
case GlobalVariable::NotThreadLocal: return 0;
|
|
|
|
case GlobalVariable::GeneralDynamicTLSModel: return 1;
|
|
|
|
case GlobalVariable::LocalDynamicTLSModel: return 2;
|
|
|
|
case GlobalVariable::InitialExecTLSModel: return 3;
|
|
|
|
case GlobalVariable::LocalExecTLSModel: return 4;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Invalid TLS model");
|
|
|
|
}
|
|
|
|
|
2014-06-27 18:19:56 +00:00
|
|
|
static unsigned getEncodedComdatSelectionKind(const Comdat &C) {
|
|
|
|
switch (C.getSelectionKind()) {
|
|
|
|
case Comdat::Any:
|
|
|
|
return bitc::COMDAT_SELECTION_KIND_ANY;
|
|
|
|
case Comdat::ExactMatch:
|
|
|
|
return bitc::COMDAT_SELECTION_KIND_EXACT_MATCH;
|
|
|
|
case Comdat::Largest:
|
|
|
|
return bitc::COMDAT_SELECTION_KIND_LARGEST;
|
|
|
|
case Comdat::NoDuplicates:
|
|
|
|
return bitc::COMDAT_SELECTION_KIND_NO_DUPLICATES;
|
|
|
|
case Comdat::SameSize:
|
|
|
|
return bitc::COMDAT_SELECTION_KIND_SAME_SIZE;
|
|
|
|
}
|
|
|
|
llvm_unreachable("Invalid selection kind");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void writeComdats(const ValueEnumerator &VE, BitstreamWriter &Stream) {
|
2015-01-14 18:25:45 +00:00
|
|
|
SmallVector<uint16_t, 64> Vals;
|
2014-06-27 18:19:56 +00:00
|
|
|
for (const Comdat *C : VE.getComdats()) {
|
|
|
|
// COMDAT: [selection_kind, name]
|
|
|
|
Vals.push_back(getEncodedComdatSelectionKind(*C));
|
2015-01-14 18:25:45 +00:00
|
|
|
size_t Size = C->getName().size();
|
|
|
|
assert(isUInt<16>(Size));
|
|
|
|
Vals.push_back(Size);
|
2014-06-27 18:19:56 +00:00
|
|
|
for (char Chr : C->getName())
|
|
|
|
Vals.push_back((unsigned char)Chr);
|
|
|
|
Stream.EmitRecord(bitc::MODULE_CODE_COMDAT, Vals, /*AbbrevToUse=*/0);
|
|
|
|
Vals.clear();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit top-level description of module, including target triple, inline asm,
|
|
|
|
// descriptors for global variables, and function prototype info.
|
|
|
|
static void WriteModuleInfo(const Module *M, const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
// Emit various pieces of data attached to a module.
|
|
|
|
if (!M->getTargetTriple().empty())
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_TRIPLE, M->getTargetTriple(),
|
|
|
|
0/*TODO*/, Stream);
|
2014-02-25 20:01:08 +00:00
|
|
|
const std::string &DL = M->getDataLayoutStr();
|
|
|
|
if (!DL.empty())
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_DATALAYOUT, DL, 0 /*TODO*/, Stream);
|
2007-04-22 06:24:45 +00:00
|
|
|
if (!M->getModuleInlineAsm().empty())
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_ASM, M->getModuleInlineAsm(),
|
|
|
|
0/*TODO*/, Stream);
|
|
|
|
|
2008-08-17 18:44:35 +00:00
|
|
|
// Emit information about sections and GC, computing how many there are. Also
|
|
|
|
// compute the maximum alignment value.
|
2007-04-22 06:24:45 +00:00
|
|
|
std::map<std::string, unsigned> SectionMap;
|
2008-08-17 18:44:35 +00:00
|
|
|
std::map<std::string, unsigned> GCMap;
|
2007-04-23 16:04:05 +00:00
|
|
|
unsigned MaxAlignment = 0;
|
2007-04-23 18:58:34 +00:00
|
|
|
unsigned MaxGlobalType = 0;
|
2014-05-26 13:38:51 +00:00
|
|
|
for (const GlobalValue &GV : M->globals()) {
|
|
|
|
MaxAlignment = std::max(MaxAlignment, GV.getAlignment());
|
|
|
|
MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV.getType()));
|
|
|
|
if (GV.hasSection()) {
|
2011-08-12 16:45:18 +00:00
|
|
|
// Give section names unique ID's.
|
2014-05-26 13:38:51 +00:00
|
|
|
unsigned &Entry = SectionMap[GV.getSection()];
|
2011-08-12 16:45:18 +00:00
|
|
|
if (!Entry) {
|
2014-05-26 13:38:51 +00:00
|
|
|
WriteStringRecord(bitc::MODULE_CODE_SECTIONNAME, GV.getSection(),
|
2011-08-12 16:45:18 +00:00
|
|
|
0/*TODO*/, Stream);
|
|
|
|
Entry = SectionMap.size();
|
|
|
|
}
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
2014-05-26 13:38:51 +00:00
|
|
|
for (const Function &F : *M) {
|
|
|
|
MaxAlignment = std::max(MaxAlignment, F.getAlignment());
|
|
|
|
if (F.hasSection()) {
|
2007-12-10 03:18:06 +00:00
|
|
|
// Give section names unique ID's.
|
2014-05-26 13:38:51 +00:00
|
|
|
unsigned &Entry = SectionMap[F.getSection()];
|
2007-12-10 03:18:06 +00:00
|
|
|
if (!Entry) {
|
2014-05-26 13:38:51 +00:00
|
|
|
WriteStringRecord(bitc::MODULE_CODE_SECTIONNAME, F.getSection(),
|
2007-12-10 03:18:06 +00:00
|
|
|
0/*TODO*/, Stream);
|
|
|
|
Entry = SectionMap.size();
|
|
|
|
}
|
|
|
|
}
|
2014-05-26 13:38:51 +00:00
|
|
|
if (F.hasGC()) {
|
2008-08-17 18:44:35 +00:00
|
|
|
// Same for GC names.
|
2014-05-26 13:38:51 +00:00
|
|
|
unsigned &Entry = GCMap[F.getGC()];
|
2007-12-10 03:18:06 +00:00
|
|
|
if (!Entry) {
|
2014-05-26 13:38:51 +00:00
|
|
|
WriteStringRecord(bitc::MODULE_CODE_GCNAME, F.getGC(),
|
2007-12-10 03:18:06 +00:00
|
|
|
0/*TODO*/, Stream);
|
2008-08-17 18:44:35 +00:00
|
|
|
Entry = GCMap.size();
|
2007-12-10 03:18:06 +00:00
|
|
|
}
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-23 16:04:05 +00:00
|
|
|
// Emit abbrev for globals, now that we know # sections and max alignment.
|
|
|
|
unsigned SimpleGVarAbbrev = 0;
|
2009-09-20 02:20:51 +00:00
|
|
|
if (!M->global_empty()) {
|
2007-04-23 16:04:05 +00:00
|
|
|
// Add an abbrev for common globals with no visibility or thread localness.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
|
2007-05-04 20:34:50 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
|
2007-04-23 18:58:34 +00:00
|
|
|
Log2_32_Ceil(MaxGlobalType+1)));
|
2007-05-04 20:34:50 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constant.
|
2007-04-23 16:04:05 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Initializer.
|
2015-01-14 20:55:48 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 5)); // Linkage.
|
2007-05-04 20:34:50 +00:00
|
|
|
if (MaxAlignment == 0) // Alignment.
|
2007-04-23 16:04:05 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(0));
|
|
|
|
else {
|
|
|
|
unsigned MaxEncAlignment = Log2_32(MaxAlignment)+1;
|
2007-05-04 20:34:50 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
|
2007-04-23 18:58:34 +00:00
|
|
|
Log2_32_Ceil(MaxEncAlignment+1)));
|
2007-04-23 16:04:05 +00:00
|
|
|
}
|
|
|
|
if (SectionMap.empty()) // Section.
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(0));
|
|
|
|
else
|
2007-05-04 20:34:50 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
|
2007-04-24 03:29:47 +00:00
|
|
|
Log2_32_Ceil(SectionMap.size()+1)));
|
2007-04-23 16:04:05 +00:00
|
|
|
// Don't bother emitting vis + thread local.
|
|
|
|
SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit the global variable information.
|
|
|
|
SmallVector<unsigned, 64> Vals;
|
2014-05-26 13:38:51 +00:00
|
|
|
for (const GlobalVariable &GV : M->globals()) {
|
2007-04-23 16:04:05 +00:00
|
|
|
unsigned AbbrevToUse = 0;
|
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
// GLOBALVAR: [type, isconst, initid,
|
2011-01-08 16:42:36 +00:00
|
|
|
// linkage, alignment, section, visibility, threadlocal,
|
2014-01-14 15:22:47 +00:00
|
|
|
// unnamed_addr, externally_initialized, dllstorageclass]
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(VE.getTypeID(GV.getType()));
|
|
|
|
Vals.push_back(GV.isConstant());
|
|
|
|
Vals.push_back(GV.isDeclaration() ? 0 :
|
|
|
|
(VE.getValueID(GV.getInitializer()) + 1));
|
2007-04-22 06:24:45 +00:00
|
|
|
Vals.push_back(getEncodedLinkage(GV));
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(Log2_32(GV.getAlignment())+1);
|
|
|
|
Vals.push_back(GV.hasSection() ? SectionMap[GV.getSection()] : 0);
|
|
|
|
if (GV.isThreadLocal() ||
|
|
|
|
GV.getVisibility() != GlobalValue::DefaultVisibility ||
|
|
|
|
GV.hasUnnamedAddr() || GV.isExternallyInitialized() ||
|
2014-06-27 18:19:56 +00:00
|
|
|
GV.getDLLStorageClass() != GlobalValue::DefaultStorageClass ||
|
|
|
|
GV.hasComdat()) {
|
2007-04-23 16:04:05 +00:00
|
|
|
Vals.push_back(getEncodedVisibility(GV));
|
2012-06-23 11:37:03 +00:00
|
|
|
Vals.push_back(getEncodedThreadLocalMode(GV));
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(GV.hasUnnamedAddr());
|
|
|
|
Vals.push_back(GV.isExternallyInitialized());
|
2014-01-14 15:22:47 +00:00
|
|
|
Vals.push_back(getEncodedDLLStorageClass(GV));
|
2014-06-27 18:19:56 +00:00
|
|
|
Vals.push_back(GV.hasComdat() ? VE.getComdatID(GV.getComdat()) : 0);
|
2007-04-23 16:04:05 +00:00
|
|
|
} else {
|
|
|
|
AbbrevToUse = SimpleGVarAbbrev;
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
Stream.EmitRecord(bitc::MODULE_CODE_GLOBALVAR, Vals, AbbrevToUse);
|
|
|
|
Vals.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Emit the function proto information.
|
2014-05-26 13:38:51 +00:00
|
|
|
for (const Function &F : *M) {
|
2011-12-07 23:57:55 +00:00
|
|
|
// FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment,
|
2014-12-03 02:08:38 +00:00
|
|
|
// section, visibility, gc, unnamed_addr, prologuedata,
|
|
|
|
// dllstorageclass, comdat, prefixdata]
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(VE.getTypeID(F.getType()));
|
|
|
|
Vals.push_back(F.getCallingConv());
|
|
|
|
Vals.push_back(F.isDeclaration());
|
2007-04-22 06:24:45 +00:00
|
|
|
Vals.push_back(getEncodedLinkage(F));
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(VE.getAttributeID(F.getAttributes()));
|
|
|
|
Vals.push_back(Log2_32(F.getAlignment())+1);
|
|
|
|
Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
|
2007-04-22 06:24:45 +00:00
|
|
|
Vals.push_back(getEncodedVisibility(F));
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
|
|
|
|
Vals.push_back(F.hasUnnamedAddr());
|
2014-12-03 02:08:38 +00:00
|
|
|
Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
|
|
|
|
: 0);
|
2014-01-14 15:22:47 +00:00
|
|
|
Vals.push_back(getEncodedDLLStorageClass(F));
|
2014-06-27 18:19:56 +00:00
|
|
|
Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
|
2014-12-03 02:08:38 +00:00
|
|
|
Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
|
|
|
|
: 0);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
unsigned AbbrevToUse = 0;
|
|
|
|
Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
|
|
|
|
Vals.clear();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 02:46:40 +00:00
|
|
|
// Emit the alias information.
|
2014-05-26 13:38:51 +00:00
|
|
|
for (const GlobalAlias &A : M->aliases()) {
|
2011-12-08 00:11:31 +00:00
|
|
|
// ALIAS: [alias type, aliasee val#, linkage, visibility]
|
2014-05-26 13:38:51 +00:00
|
|
|
Vals.push_back(VE.getTypeID(A.getType()));
|
|
|
|
Vals.push_back(VE.getValueID(A.getAliasee()));
|
|
|
|
Vals.push_back(getEncodedLinkage(A));
|
|
|
|
Vals.push_back(getEncodedVisibility(A));
|
|
|
|
Vals.push_back(getEncodedDLLStorageClass(A));
|
2014-06-06 01:20:28 +00:00
|
|
|
Vals.push_back(getEncodedThreadLocalMode(A));
|
|
|
|
Vals.push_back(A.hasUnnamedAddr());
|
2007-04-26 02:46:40 +00:00
|
|
|
unsigned AbbrevToUse = 0;
|
|
|
|
Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
|
|
|
|
Vals.clear();
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
|
2009-07-20 21:19:07 +00:00
|
|
|
static uint64_t GetOptimizationFlags(const Value *V) {
|
|
|
|
uint64_t Flags = 0;
|
|
|
|
|
2014-10-15 17:45:13 +00:00
|
|
|
if (const auto *OBO = dyn_cast<OverflowingBinaryOperator>(V)) {
|
2009-08-20 17:11:38 +00:00
|
|
|
if (OBO->hasNoSignedWrap())
|
|
|
|
Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;
|
|
|
|
if (OBO->hasNoUnsignedWrap())
|
|
|
|
Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;
|
2014-10-15 17:45:13 +00:00
|
|
|
} else if (const auto *PEO = dyn_cast<PossiblyExactOperator>(V)) {
|
2011-02-06 21:44:57 +00:00
|
|
|
if (PEO->isExact())
|
|
|
|
Flags |= 1 << bitc::PEO_EXACT;
|
2014-10-15 17:45:13 +00:00
|
|
|
} else if (const auto *FPMO = dyn_cast<FPMathOperator>(V)) {
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FPMO->hasUnsafeAlgebra())
|
2012-12-09 21:12:04 +00:00
|
|
|
Flags |= FastMathFlags::UnsafeAlgebra;
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FPMO->hasNoNaNs())
|
2012-12-09 21:12:04 +00:00
|
|
|
Flags |= FastMathFlags::NoNaNs;
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FPMO->hasNoInfs())
|
2012-12-09 21:12:04 +00:00
|
|
|
Flags |= FastMathFlags::NoInfs;
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FPMO->hasNoSignedZeros())
|
2012-12-09 21:12:04 +00:00
|
|
|
Flags |= FastMathFlags::NoSignedZeros;
|
2012-11-27 00:43:38 +00:00
|
|
|
if (FPMO->hasAllowReciprocal())
|
2012-12-09 21:12:04 +00:00
|
|
|
Flags |= FastMathFlags::AllowReciprocal;
|
2009-07-20 21:19:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return Flags;
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
|
2014-12-11 23:02:24 +00:00
|
|
|
static void WriteValueAsMetadata(const ValueAsMetadata *MD,
|
|
|
|
const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream,
|
|
|
|
SmallVectorImpl<uint64_t> &Record) {
|
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
|
|
|
// Mimic an MDNode with a value as one operand.
|
|
|
|
Value *V = MD->getValue();
|
|
|
|
Record.push_back(VE.getTypeID(V->getType()));
|
|
|
|
Record.push_back(VE.getValueID(V));
|
2014-12-11 23:02:24 +00:00
|
|
|
Stream.EmitRecord(bitc::METADATA_VALUE, Record, 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
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
static void WriteMDNode(const MDNode *N,
|
2009-07-29 18:15:02 +00:00
|
|
|
const ValueEnumerator &VE,
|
2009-08-04 05:01:35 +00:00
|
|
|
BitstreamWriter &Stream,
|
2013-07-11 16:22:38 +00:00
|
|
|
SmallVectorImpl<uint64_t> &Record) {
|
2009-12-31 01:22:29 +00:00
|
|
|
for (unsigned i = 0, e = N->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 *MD = N->getOperand(i);
|
|
|
|
if (!MD) {
|
2009-08-04 05:01:35 +00:00
|
|
|
Record.push_back(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
|
|
|
continue;
|
2009-08-04 05:01:35 +00:00
|
|
|
}
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@223802 91177308-0d34-0410-b5e6-96231b3b80d8
2014-12-09 18:38:53 +00:00
|
|
|
assert(!isa<LocalAsMetadata>(MD) && "Unexpected function-local metadata");
|
2014-12-11 23:02:24 +00:00
|
|
|
Record.push_back(VE.getMetadataID(MD) + 1);
|
2009-08-04 05:01:35 +00:00
|
|
|
}
|
2015-01-08 22:38:29 +00:00
|
|
|
Stream.EmitRecord(N->isDistinct() ? bitc::METADATA_DISTINCT_NODE
|
|
|
|
: bitc::METADATA_NODE,
|
|
|
|
Record);
|
2009-08-04 05:01:35 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
2009-08-04 02:26:56 +00:00
|
|
|
|
2015-01-13 21:10:44 +00:00
|
|
|
static void WriteMDLocation(const MDLocation *N, const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream,
|
|
|
|
SmallVectorImpl<uint64_t> &Record,
|
|
|
|
unsigned Abbrev) {
|
|
|
|
Record.push_back(N->isDistinct());
|
|
|
|
Record.push_back(N->getLine());
|
|
|
|
Record.push_back(N->getColumn());
|
|
|
|
Record.push_back(VE.getMetadataID(N->getScope()));
|
|
|
|
|
|
|
|
// Always emit the inlined-at location, even though it's optional.
|
|
|
|
if (Metadata *InlinedAt = N->getInlinedAt())
|
|
|
|
Record.push_back(VE.getMetadataID(InlinedAt) + 1);
|
|
|
|
else
|
|
|
|
Record.push_back(0);
|
|
|
|
|
|
|
|
Stream.EmitRecord(bitc::METADATA_LOCATION, Record, Abbrev);
|
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
|
2010-07-21 23:38:33 +00:00
|
|
|
static void WriteModuleMetadata(const Module *M,
|
|
|
|
const ValueEnumerator &VE,
|
2009-08-04 05:01:35 +00:00
|
|
|
BitstreamWriter &Stream) {
|
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 auto &MDs = VE.getMDs();
|
2015-01-12 22:30:34 +00:00
|
|
|
if (MDs.empty() && M->named_metadata_empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
|
|
|
|
2009-07-29 18:15:02 +00:00
|
|
|
unsigned MDSAbbrev = 0;
|
2015-01-12 22:30:34 +00:00
|
|
|
if (VE.hasMDString()) {
|
|
|
|
// Abbrev for METADATA_STRING.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
|
|
|
|
MDSAbbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
}
|
|
|
|
|
2015-01-13 21:10:44 +00:00
|
|
|
unsigned LocAbbrev = 0;
|
|
|
|
if (VE.hasMDLocation()) {
|
|
|
|
// Abbrev for METADATA_LOCATION.
|
|
|
|
//
|
|
|
|
// Assume the column is usually under 128, and always output the inlined-at
|
|
|
|
// location (it's never more expensive than building an array size 1).
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_LOCATION));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));
|
|
|
|
LocAbbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
}
|
|
|
|
|
2015-01-12 22:34:10 +00:00
|
|
|
unsigned NameAbbrev = 0;
|
|
|
|
if (!M->named_metadata_empty()) {
|
|
|
|
// Abbrev for METADATA_NAME.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
|
|
|
|
NameAbbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
}
|
|
|
|
|
2009-07-29 18:15:02 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2015-01-12 22:31:35 +00:00
|
|
|
for (const Metadata *MD : MDs) {
|
2015-01-13 21:10:44 +00:00
|
|
|
if (const MDLocation *Loc = dyn_cast<MDLocation>(MD)) {
|
|
|
|
WriteMDLocation(Loc, VE, Stream, Record, LocAbbrev);
|
|
|
|
continue;
|
|
|
|
}
|
2015-01-12 22:31:35 +00:00
|
|
|
if (const MDNode *N = dyn_cast<MDNode>(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
|
|
|
WriteMDNode(N, VE, Stream, Record);
|
2015-01-12 22:30:34 +00:00
|
|
|
continue;
|
|
|
|
}
|
2015-01-12 22:31:35 +00:00
|
|
|
if (const auto *MDC = dyn_cast<ConstantAsMetadata>(MD)) {
|
2014-12-11 23:02:24 +00:00
|
|
|
WriteValueAsMetadata(MDC, VE, Stream, Record);
|
2015-01-12 22:30:34 +00:00
|
|
|
continue;
|
2010-07-21 23:38:33 +00:00
|
|
|
}
|
2015-01-12 22:31:35 +00:00
|
|
|
const MDString *MDS = cast<MDString>(MD);
|
2015-01-12 22:30:34 +00:00
|
|
|
// Code: [strchar x N]
|
|
|
|
Record.append(MDS->bytes_begin(), MDS->bytes_end());
|
|
|
|
|
|
|
|
// Emit the finished record.
|
|
|
|
Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev);
|
|
|
|
Record.clear();
|
2010-07-21 23:38:33 +00:00
|
|
|
}
|
2009-08-04 05:01:35 +00:00
|
|
|
|
2010-07-21 23:38:33 +00:00
|
|
|
// Write named metadata.
|
2015-01-12 22:33:00 +00:00
|
|
|
for (const NamedMDNode &NMD : M->named_metadata()) {
|
2010-07-21 23:38:33 +00:00
|
|
|
// Write name.
|
2015-01-12 22:33:00 +00:00
|
|
|
StringRef Str = NMD.getName();
|
2015-01-12 22:34:10 +00:00
|
|
|
Record.append(Str.bytes_begin(), Str.bytes_end());
|
|
|
|
Stream.EmitRecord(bitc::METADATA_NAME, Record, NameAbbrev);
|
2010-07-21 23:38:33 +00:00
|
|
|
Record.clear();
|
|
|
|
|
|
|
|
// Write named metadata operands.
|
2015-01-12 22:35:34 +00:00
|
|
|
for (const MDNode *N : NMD.operands())
|
|
|
|
Record.push_back(VE.getMetadataID(N));
|
2011-06-17 17:56:00 +00:00
|
|
|
Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
|
2010-07-21 23:38:33 +00:00
|
|
|
Record.clear();
|
2009-08-04 05:01:35 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2015-01-12 22:30:34 +00:00
|
|
|
Stream.ExitBlock();
|
2009-09-18 19:26:43 +00:00
|
|
|
}
|
|
|
|
|
2010-01-14 19:38:44 +00:00
|
|
|
static void WriteFunctionLocalMetadata(const Function &F,
|
|
|
|
const ValueEnumerator &VE,
|
2010-01-13 19:37:33 +00:00
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
bool StartedMetadataBlock = false;
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
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 SmallVectorImpl<const LocalAsMetadata *> &MDs =
|
|
|
|
VE.getFunctionLocalMDs();
|
|
|
|
for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
|
|
|
|
assert(MDs[i] && "Expected valid function-local metadata");
|
|
|
|
if (!StartedMetadataBlock) {
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
|
|
|
StartedMetadataBlock = true;
|
|
|
|
}
|
2014-12-11 23:02:24 +00:00
|
|
|
WriteValueAsMetadata(MDs[i], VE, Stream, Record);
|
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
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-01-13 19:37:33 +00:00
|
|
|
if (StartedMetadataBlock)
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
static void WriteMetadataAttachment(const Function &F,
|
2009-09-20 02:20:51 +00:00
|
|
|
const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
2010-04-03 02:17:50 +00:00
|
|
|
Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
|
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
// Write metadata attachments
|
2011-06-17 17:56:00 +00:00
|
|
|
// METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
|
2014-11-11 21:30:22 +00:00
|
|
|
SmallVector<std::pair<unsigned, MDNode *>, 4> MDs;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
|
|
|
|
I != E; ++I) {
|
2009-10-22 18:55:16 +00:00
|
|
|
MDs.clear();
|
2010-04-03 02:17:50 +00:00
|
|
|
I->getAllMetadataOtherThanDebugLoc(MDs);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-12-28 23:41:32 +00:00
|
|
|
// If no metadata, ignore instruction.
|
|
|
|
if (MDs.empty()) continue;
|
|
|
|
|
|
|
|
Record.push_back(VE.getInstructionID(I));
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-12-28 23:41:32 +00:00
|
|
|
for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
|
|
|
|
Record.push_back(MDs[i].first);
|
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
|
|
|
Record.push_back(VE.getMetadataID(MDs[i].second));
|
2009-09-18 19:26:43 +00:00
|
|
|
}
|
2011-06-17 17:56:00 +00:00
|
|
|
Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
|
2009-12-28 23:41:32 +00:00
|
|
|
Record.clear();
|
2009-09-18 19:26:43 +00:00
|
|
|
}
|
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
Stream.ExitBlock();
|
2009-09-18 19:26:43 +00:00
|
|
|
}
|
|
|
|
|
2009-12-28 20:10:43 +00:00
|
|
|
static void WriteModuleMetadataStore(const Module *M, BitstreamWriter &Stream) {
|
2009-09-18 19:26:43 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
// Write metadata kinds
|
|
|
|
// METADATA_KIND - [n x [id, name]]
|
2012-12-03 22:57:47 +00:00
|
|
|
SmallVector<StringRef, 8> Names;
|
2009-12-29 09:01:33 +00:00
|
|
|
M->getMDKindNames(Names);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-07-20 21:42:28 +00:00
|
|
|
if (Names.empty()) return;
|
2009-12-28 20:10:43 +00:00
|
|
|
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-07-20 21:42:28 +00:00
|
|
|
for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) {
|
2009-12-28 20:10:43 +00:00
|
|
|
Record.push_back(MDKindID);
|
|
|
|
StringRef KName = Names[MDKindID];
|
|
|
|
Record.append(KName.begin(), KName.end());
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
|
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
|
2009-12-28 20:10:43 +00:00
|
|
|
Stream.ExitBlock();
|
2009-08-04 05:01:35 +00:00
|
|
|
}
|
2009-07-22 17:43:22 +00:00
|
|
|
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
static void emitSignedInt64(SmallVectorImpl<uint64_t> &Vals, uint64_t V) {
|
|
|
|
if ((int64_t)V >= 0)
|
|
|
|
Vals.push_back(V << 1);
|
|
|
|
else
|
|
|
|
Vals.push_back((-V << 1) | 1);
|
|
|
|
}
|
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
static void WriteConstants(unsigned FirstVal, unsigned LastVal,
|
|
|
|
const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream, bool isGlobal) {
|
|
|
|
if (FirstVal == LastVal) return;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);
|
2007-05-06 00:42:18 +00:00
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
unsigned AggregateAbbrev = 0;
|
|
|
|
unsigned String8Abbrev = 0;
|
|
|
|
unsigned CString7Abbrev = 0;
|
|
|
|
unsigned CString6Abbrev = 0;
|
|
|
|
// If this is a constant pool for the module, emit module-specific abbrevs.
|
|
|
|
if (isGlobal) {
|
|
|
|
// Abbrev for CST_CODE_AGGREGATE.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_AGGREGATE));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, Log2_32_Ceil(LastVal+1)));
|
|
|
|
AggregateAbbrev = Stream.EmitAbbrev(Abbv);
|
2007-04-24 00:16:04 +00:00
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
// Abbrev for CST_CODE_STRING.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_STRING));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
|
|
|
|
String8Abbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
// Abbrev for CST_CODE_CSTRING.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
|
|
|
|
CString7Abbrev = Stream.EmitAbbrev(Abbv);
|
|
|
|
// Abbrev for CST_CODE_CSTRING.
|
|
|
|
Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CSTRING));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
|
|
|
|
CString6Abbrev = Stream.EmitAbbrev(Abbv);
|
2009-09-20 02:20:51 +00:00
|
|
|
}
|
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-08-04 02:26:56 +00:00
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
const ValueEnumerator::ValueList &Vals = VE.getValues();
|
2014-04-15 06:32:26 +00:00
|
|
|
Type *LastTy = nullptr;
|
2009-08-04 05:01:35 +00:00
|
|
|
for (unsigned i = FirstVal; i != LastVal; ++i) {
|
|
|
|
const Value *V = Vals[i].first;
|
2007-04-24 00:16:04 +00:00
|
|
|
// If we need to switch types, do so now.
|
|
|
|
if (V->getType() != LastTy) {
|
|
|
|
LastTy = V->getType();
|
|
|
|
Record.push_back(VE.getTypeID(LastTy));
|
2007-05-05 07:36:14 +00:00
|
|
|
Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,
|
|
|
|
CONSTANTS_SETTYPE_ABBREV);
|
2007-04-24 00:16:04 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-24 00:16:04 +00:00
|
|
|
if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
|
2009-10-13 20:46:56 +00:00
|
|
|
Record.push_back(unsigned(IA->hasSideEffects()) |
|
2012-09-05 00:56:20 +00:00
|
|
|
unsigned(IA->isAlignStack()) << 1 |
|
|
|
|
unsigned(IA->getDialect()&1) << 2);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:58:20 +00:00
|
|
|
// Add the asm string.
|
|
|
|
const std::string &AsmStr = IA->getAsmString();
|
|
|
|
Record.push_back(AsmStr.size());
|
|
|
|
for (unsigned i = 0, e = AsmStr.size(); i != e; ++i)
|
|
|
|
Record.push_back(AsmStr[i]);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:58:20 +00:00
|
|
|
// Add the constraint string.
|
|
|
|
const std::string &ConstraintStr = IA->getConstraintString();
|
|
|
|
Record.push_back(ConstraintStr.size());
|
|
|
|
for (unsigned i = 0, e = ConstraintStr.size(); i != e; ++i)
|
|
|
|
Record.push_back(ConstraintStr[i]);
|
|
|
|
Stream.EmitRecord(bitc::CST_CODE_INLINEASM, Record);
|
|
|
|
Record.clear();
|
2007-04-24 00:16:04 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
const Constant *C = cast<Constant>(V);
|
|
|
|
unsigned Code = -1U;
|
|
|
|
unsigned AbbrevToUse = 0;
|
|
|
|
if (C->isNullValue()) {
|
|
|
|
Code = bitc::CST_CODE_NULL;
|
|
|
|
} else if (isa<UndefValue>(C)) {
|
|
|
|
Code = bitc::CST_CODE_UNDEF;
|
|
|
|
} else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
|
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
|
|
|
if (IV->getBitWidth() <= 64) {
|
|
|
|
uint64_t V = IV->getSExtValue();
|
|
|
|
emitSignedInt64(Record, V);
|
|
|
|
Code = bitc::CST_CODE_INTEGER;
|
|
|
|
AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
|
|
|
|
} else { // Wide integers, > 64 bits in size.
|
|
|
|
// We have an arbitrary precision integer value to write whose
|
|
|
|
// bit width is > 64. However, in canonical unsigned integer
|
|
|
|
// format it is likely that the high bits are going to be zero.
|
|
|
|
// So, we only write the number of active words.
|
|
|
|
unsigned NWords = IV->getValue().getActiveWords();
|
|
|
|
const uint64_t *RawWords = IV->getValue().getRawData();
|
|
|
|
for (unsigned i = 0; i != NWords; ++i) {
|
|
|
|
emitSignedInt64(Record, RawWords[i]);
|
|
|
|
}
|
|
|
|
Code = bitc::CST_CODE_WIDE_INTEGER;
|
|
|
|
}
|
2007-04-24 00:16:04 +00:00
|
|
|
} else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
|
|
|
|
Code = bitc::CST_CODE_FLOAT;
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = CFP->getType();
|
2011-12-17 00:04:22 +00:00
|
|
|
if (Ty->isHalfTy() || Ty->isFloatTy() || Ty->isDoubleTy()) {
|
2008-10-09 18:53:47 +00:00
|
|
|
Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
|
2009-10-05 05:54:46 +00:00
|
|
|
} else if (Ty->isX86_FP80Ty()) {
|
2007-09-26 23:20:33 +00:00
|
|
|
// api needed to prevent premature destruction
|
2009-03-23 21:16:53 +00:00
|
|
|
// bits are not in the same order as a normal i80 APInt, compensate.
|
2008-10-09 18:53:47 +00:00
|
|
|
APInt api = CFP->getValueAPF().bitcastToAPInt();
|
2007-09-26 23:20:33 +00:00
|
|
|
const uint64_t *p = api.getRawData();
|
2009-03-23 21:16:53 +00:00
|
|
|
Record.push_back((p[1] << 48) | (p[0] >> 16));
|
|
|
|
Record.push_back(p[0] & 0xffffLL);
|
2009-10-05 05:54:46 +00:00
|
|
|
} else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) {
|
2008-10-09 18:53:47 +00:00
|
|
|
APInt api = CFP->getValueAPF().bitcastToAPInt();
|
2007-09-26 23:20:33 +00:00
|
|
|
const uint64_t *p = api.getRawData();
|
2007-09-11 18:32:33 +00:00
|
|
|
Record.push_back(p[0]);
|
|
|
|
Record.push_back(p[1]);
|
2007-08-09 22:51:36 +00:00
|
|
|
} else {
|
|
|
|
assert (0 && "Unknown FP type!");
|
2007-04-24 00:16:04 +00:00
|
|
|
}
|
2012-01-30 00:51:16 +00:00
|
|
|
} else if (isa<ConstantDataSequential>(C) &&
|
|
|
|
cast<ConstantDataSequential>(C)->isString()) {
|
|
|
|
const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);
|
|
|
|
// Emit constant strings specially.
|
|
|
|
unsigned NumElts = Str->getNumElements();
|
|
|
|
// If this is a null-terminated string, use the denser CSTRING encoding.
|
|
|
|
if (Str->isCString()) {
|
|
|
|
Code = bitc::CST_CODE_CSTRING;
|
|
|
|
--NumElts; // Don't encode the null, which isn't allowed by char6.
|
|
|
|
} else {
|
|
|
|
Code = bitc::CST_CODE_STRING;
|
|
|
|
AbbrevToUse = String8Abbrev;
|
|
|
|
}
|
|
|
|
bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
|
|
|
|
bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
|
|
|
|
for (unsigned i = 0; i != NumElts; ++i) {
|
|
|
|
unsigned char V = Str->getElementAsInteger(i);
|
|
|
|
Record.push_back(V);
|
|
|
|
isCStr7 &= (V & 128) == 0;
|
|
|
|
if (isCStrChar6)
|
|
|
|
isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
|
|
|
|
}
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2012-01-30 00:51:16 +00:00
|
|
|
if (isCStrChar6)
|
|
|
|
AbbrevToUse = CString6Abbrev;
|
|
|
|
else if (isCStr7)
|
|
|
|
AbbrevToUse = CString7Abbrev;
|
2012-11-15 22:34:00 +00:00
|
|
|
} else if (const ConstantDataSequential *CDS =
|
2012-01-30 00:51:16 +00:00
|
|
|
dyn_cast<ConstantDataSequential>(C)) {
|
2012-01-30 07:36:01 +00:00
|
|
|
Code = bitc::CST_CODE_DATA;
|
2012-01-30 00:51:16 +00:00
|
|
|
Type *EltTy = CDS->getType()->getElementType();
|
|
|
|
if (isa<IntegerType>(EltTy)) {
|
|
|
|
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
|
|
|
|
Record.push_back(CDS->getElementAsInteger(i));
|
|
|
|
} else if (EltTy->isFloatTy()) {
|
|
|
|
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
|
|
|
|
union { float F; uint32_t I; };
|
|
|
|
F = CDS->getElementAsFloat(i);
|
|
|
|
Record.push_back(I);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
assert(EltTy->isDoubleTy() && "Unknown ConstantData element type");
|
|
|
|
for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
|
|
|
|
union { double F; uint64_t I; };
|
|
|
|
F = CDS->getElementAsDouble(i);
|
|
|
|
Record.push_back(I);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (isa<ConstantArray>(C) || isa<ConstantStruct>(C) ||
|
|
|
|
isa<ConstantVector>(C)) {
|
2007-04-24 00:16:04 +00:00
|
|
|
Code = bitc::CST_CODE_AGGREGATE;
|
|
|
|
for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(i)));
|
2007-05-05 07:36:14 +00:00
|
|
|
AbbrevToUse = AggregateAbbrev;
|
2007-04-24 00:16:04 +00:00
|
|
|
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
|
2007-04-24 07:07:11 +00:00
|
|
|
switch (CE->getOpcode()) {
|
|
|
|
default:
|
|
|
|
if (Instruction::isCast(CE->getOpcode())) {
|
|
|
|
Code = bitc::CST_CODE_CE_CAST;
|
|
|
|
Record.push_back(GetEncodedCastOpcode(CE->getOpcode()));
|
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
2007-05-05 07:36:14 +00:00
|
|
|
AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
|
2007-04-24 07:07:11 +00:00
|
|
|
} else {
|
|
|
|
assert(CE->getNumOperands() == 2 && "Unknown constant expr!");
|
|
|
|
Code = bitc::CST_CODE_CE_BINOP;
|
|
|
|
Record.push_back(GetEncodedBinaryOpcode(CE->getOpcode()));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(1)));
|
2009-07-20 21:19:07 +00:00
|
|
|
uint64_t Flags = GetOptimizationFlags(CE);
|
|
|
|
if (Flags != 0)
|
|
|
|
Record.push_back(Flags);
|
2007-04-24 07:07:11 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Instruction::GetElementPtr:
|
|
|
|
Code = bitc::CST_CODE_CE_GEP;
|
2009-07-27 21:53:46 +00:00
|
|
|
if (cast<GEPOperator>(C)->isInBounds())
|
|
|
|
Code = bitc::CST_CODE_CE_INBOUNDS_GEP;
|
2007-04-24 07:07:11 +00:00
|
|
|
for (unsigned i = 0, e = CE->getNumOperands(); i != e; ++i) {
|
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(i)->getType()));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(i)));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Instruction::Select:
|
|
|
|
Code = bitc::CST_CODE_CE_SELECT;
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(1)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(2)));
|
|
|
|
break;
|
|
|
|
case Instruction::ExtractElement:
|
|
|
|
Code = bitc::CST_CODE_CE_EXTRACTELT;
|
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(1)->getType()));
|
2007-04-24 07:07:11 +00:00
|
|
|
Record.push_back(VE.getValueID(C->getOperand(1)));
|
|
|
|
break;
|
|
|
|
case Instruction::InsertElement:
|
|
|
|
Code = bitc::CST_CODE_CE_INSERTELT;
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(1)));
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(2)->getType()));
|
2007-04-24 07:07:11 +00:00
|
|
|
Record.push_back(VE.getValueID(C->getOperand(2)));
|
|
|
|
break;
|
|
|
|
case Instruction::ShuffleVector:
|
2009-02-12 21:28:33 +00:00
|
|
|
// If the return type and argument types are the same, this is a
|
|
|
|
// standard shufflevector instruction. If the types are different,
|
|
|
|
// then the shuffle is widening or truncating the input vectors, and
|
|
|
|
// the argument type must also be encoded.
|
|
|
|
if (C->getType() == C->getOperand(0)->getType()) {
|
|
|
|
Code = bitc::CST_CODE_CE_SHUFFLEVEC;
|
|
|
|
} else {
|
|
|
|
Code = bitc::CST_CODE_CE_SHUFVEC_EX;
|
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
|
|
|
|
}
|
2007-04-24 07:07:11 +00:00
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(1)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(2)));
|
|
|
|
break;
|
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
2009-07-08 03:04:38 +00:00
|
|
|
Code = bitc::CST_CODE_CE_CMP;
|
2007-04-24 07:07:11 +00:00
|
|
|
Record.push_back(VE.getTypeID(C->getOperand(0)->getType()));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(0)));
|
|
|
|
Record.push_back(VE.getValueID(C->getOperand(1)));
|
|
|
|
Record.push_back(CE->getPredicate());
|
|
|
|
break;
|
|
|
|
}
|
2009-10-28 05:24:40 +00:00
|
|
|
} else if (const BlockAddress *BA = dyn_cast<BlockAddress>(C)) {
|
|
|
|
Code = bitc::CST_CODE_BLOCKADDRESS;
|
|
|
|
Record.push_back(VE.getTypeID(BA->getFunction()->getType()));
|
|
|
|
Record.push_back(VE.getValueID(BA->getFunction()));
|
|
|
|
Record.push_back(VE.getGlobalBasicBlockID(BA->getBasicBlock()));
|
2007-04-24 00:16:04 +00:00
|
|
|
} else {
|
2010-07-21 21:18:37 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
C->dump();
|
|
|
|
#endif
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unknown constant!");
|
2007-04-24 00:16:04 +00:00
|
|
|
}
|
|
|
|
Stream.EmitRecord(Code, Record, AbbrevToUse);
|
|
|
|
Record.clear();
|
|
|
|
}
|
|
|
|
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void WriteModuleConstants(const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
const ValueEnumerator::ValueList &Vals = VE.getValues();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-24 00:16:04 +00:00
|
|
|
// Find the first constant to emit, which is the first non-globalvalue value.
|
|
|
|
// We know globalvalues have been emitted by WriteModuleInfo.
|
|
|
|
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
|
|
|
|
if (!isa<GlobalValue>(Vals[i].first)) {
|
2009-08-04 05:01:35 +00:00
|
|
|
WriteConstants(i, Vals.size(), VE, Stream, true);
|
2007-04-24 00:16:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-04-23 20:35:01 +00:00
|
|
|
|
2007-05-06 00:00:00 +00:00
|
|
|
/// PushValueAndType - The file has to encode both the value and type id for
|
|
|
|
/// many values, because we need to know what type to create for forward
|
|
|
|
/// references. However, most operands are not forward references, so this type
|
|
|
|
/// field is not needed.
|
|
|
|
///
|
|
|
|
/// This function adds V's value ID to Vals. If the value ID is higher than the
|
|
|
|
/// instruction ID, then it is a forward reference, and it also includes the
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
/// type ID. The value ID that is written is encoded relative to the InstID.
|
2009-01-16 18:40:27 +00:00
|
|
|
static bool PushValueAndType(const Value *V, unsigned InstID,
|
2013-07-11 16:22:38 +00:00
|
|
|
SmallVectorImpl<unsigned> &Vals,
|
2007-05-06 00:00:00 +00:00
|
|
|
ValueEnumerator &VE) {
|
|
|
|
unsigned ValID = VE.getValueID(V);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// Make encoding relative to the InstID.
|
|
|
|
Vals.push_back(InstID - ValID);
|
2007-05-06 00:00:00 +00:00
|
|
|
if (ValID >= InstID) {
|
|
|
|
Vals.push_back(VE.getTypeID(V->getType()));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
/// pushValue - Like PushValueAndType, but where the type of the value is
|
|
|
|
/// omitted (perhaps it was already encoded in an earlier operand).
|
|
|
|
static void pushValue(const Value *V, unsigned InstID,
|
2013-07-11 16:22:38 +00:00
|
|
|
SmallVectorImpl<unsigned> &Vals,
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
ValueEnumerator &VE) {
|
|
|
|
unsigned ValID = VE.getValueID(V);
|
|
|
|
Vals.push_back(InstID - ValID);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pushValueSigned(const Value *V, unsigned InstID,
|
2013-07-11 16:22:38 +00:00
|
|
|
SmallVectorImpl<uint64_t> &Vals,
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
ValueEnumerator &VE) {
|
|
|
|
unsigned ValID = VE.getValueID(V);
|
|
|
|
int64_t diff = ((int32_t)InstID - (int32_t)ValID);
|
|
|
|
emitSignedInt64(Vals, diff);
|
|
|
|
}
|
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
/// WriteInstruction - Emit an instruction to the specified stream.
|
2007-05-06 00:00:00 +00:00
|
|
|
static void WriteInstruction(const Instruction &I, unsigned InstID,
|
|
|
|
ValueEnumerator &VE, BitstreamWriter &Stream,
|
2013-07-11 16:22:38 +00:00
|
|
|
SmallVectorImpl<unsigned> &Vals) {
|
2007-04-26 05:53:54 +00:00
|
|
|
unsigned Code = 0;
|
|
|
|
unsigned AbbrevToUse = 0;
|
2009-09-18 19:26:43 +00:00
|
|
|
VE.setInstructionID(&I);
|
2007-04-26 05:53:54 +00:00
|
|
|
switch (I.getOpcode()) {
|
|
|
|
default:
|
|
|
|
if (Instruction::isCast(I.getOpcode())) {
|
2007-05-01 02:13:26 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_CAST;
|
2007-05-06 02:38:57 +00:00
|
|
|
if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE))
|
|
|
|
AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
|
2007-04-26 05:53:54 +00:00
|
|
|
Vals.push_back(VE.getTypeID(I.getType()));
|
2007-05-06 00:21:25 +00:00
|
|
|
Vals.push_back(GetEncodedCastOpcode(I.getOpcode()));
|
2007-04-26 05:53:54 +00:00
|
|
|
} else {
|
|
|
|
assert(isa<BinaryOperator>(I) && "Unknown instruction!");
|
2007-05-02 04:26:36 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_BINOP;
|
2007-05-06 02:38:57 +00:00
|
|
|
if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE))
|
|
|
|
AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(1), InstID, Vals, VE);
|
2007-05-06 00:21:25 +00:00
|
|
|
Vals.push_back(GetEncodedBinaryOpcode(I.getOpcode()));
|
2009-07-20 21:19:07 +00:00
|
|
|
uint64_t Flags = GetOptimizationFlags(&I);
|
|
|
|
if (Flags != 0) {
|
|
|
|
if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
|
|
|
|
AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
|
|
|
|
Vals.push_back(Flags);
|
|
|
|
}
|
2007-04-26 05:53:54 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-05-01 02:13:26 +00:00
|
|
|
|
|
|
|
case Instruction::GetElementPtr:
|
|
|
|
Code = bitc::FUNC_CODE_INST_GEP;
|
2009-07-27 21:53:46 +00:00
|
|
|
if (cast<GEPOperator>(&I)->isInBounds())
|
|
|
|
Code = bitc::FUNC_CODE_INST_INBOUNDS_GEP;
|
2007-05-06 00:00:00 +00:00
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
|
|
|
|
PushValueAndType(I.getOperand(i), InstID, Vals, VE);
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
2008-05-31 19:11:15 +00:00
|
|
|
case Instruction::ExtractValue: {
|
2008-05-23 01:55:30 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_EXTRACTVAL;
|
2008-05-31 19:11:15 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
|
|
|
const ExtractValueInst *EVI = cast<ExtractValueInst>(&I);
|
|
|
|
for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
|
|
|
|
Vals.push_back(*i);
|
2008-05-23 01:55:30 +00:00
|
|
|
break;
|
2008-05-31 19:11:15 +00:00
|
|
|
}
|
|
|
|
case Instruction::InsertValue: {
|
2008-05-23 01:55:30 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_INSERTVAL;
|
2008-05-31 19:11:15 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
|
|
|
PushValueAndType(I.getOperand(1), InstID, Vals, VE);
|
|
|
|
const InsertValueInst *IVI = cast<InsertValueInst>(&I);
|
|
|
|
for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
|
|
|
|
Vals.push_back(*i);
|
2008-05-23 01:55:30 +00:00
|
|
|
break;
|
2008-05-31 19:11:15 +00:00
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
case Instruction::Select:
|
2008-09-16 01:01:33 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_VSELECT;
|
2007-05-06 00:21:25 +00:00
|
|
|
PushValueAndType(I.getOperand(1), InstID, Vals, VE);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(2), InstID, Vals, VE);
|
2008-09-16 01:01:33 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
|
|
|
case Instruction::ExtractElement:
|
|
|
|
Code = bitc::FUNC_CODE_INST_EXTRACTELT;
|
2007-05-06 00:21:25 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
PushValueAndType(I.getOperand(1), InstID, Vals, VE);
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
|
|
|
case Instruction::InsertElement:
|
|
|
|
Code = bitc::FUNC_CODE_INST_INSERTELT;
|
2007-05-06 00:21:25 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(1), InstID, Vals, VE);
|
[IR] Make {extract,insert}element accept an index of any integer type.
Given the following C code llvm currently generates suboptimal code for
x86-64:
__m128 bss4( const __m128 *ptr, size_t i, size_t j )
{
float f = ptr[i][j];
return (__m128) { f, f, f, f };
}
=================================================
define <4 x float> @_Z4bss4PKDv4_fmm(<4 x float>* nocapture readonly %ptr, i64 %i, i64 %j) #0 {
%a1 = getelementptr inbounds <4 x float>* %ptr, i64 %i
%a2 = load <4 x float>* %a1, align 16, !tbaa !1
%a3 = trunc i64 %j to i32
%a4 = extractelement <4 x float> %a2, i32 %a3
%a5 = insertelement <4 x float> undef, float %a4, i32 0
%a6 = insertelement <4 x float> %a5, float %a4, i32 1
%a7 = insertelement <4 x float> %a6, float %a4, i32 2
%a8 = insertelement <4 x float> %a7, float %a4, i32 3
ret <4 x float> %a8
}
=================================================
shlq $4, %rsi
addq %rdi, %rsi
movslq %edx, %rax
vbroadcastss (%rsi,%rax,4), %xmm0
retq
=================================================
The movslq is uneeded, but is present because of the trunc to i32 and then
sext back to i64 that the backend adds for vbroadcastss.
We can't remove it because it changes the meaning. The IR that clang
generates is already suboptimal. What clang really should emit is:
%a4 = extractelement <4 x float> %a2, i64 %j
This patch makes that legal. A separate patch will teach clang to do it.
Differential Revision: http://reviews.llvm.org/D3519
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@207801 91177308-0d34-0410-b5e6-96231b3b80d8
2014-05-01 22:12:39 +00:00
|
|
|
PushValueAndType(I.getOperand(2), InstID, Vals, VE);
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
|
|
|
case Instruction::ShuffleVector:
|
|
|
|
Code = bitc::FUNC_CODE_INST_SHUFFLEVEC;
|
2007-05-06 00:21:25 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(1), InstID, Vals, VE);
|
|
|
|
pushValue(I.getOperand(2), InstID, Vals, VE);
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
|
|
|
case Instruction::ICmp:
|
|
|
|
case Instruction::FCmp:
|
2009-07-08 03:04:38 +00:00
|
|
|
// compare returning Int1Ty or vector of Int1Ty
|
|
|
|
Code = bitc::FUNC_CODE_INST_CMP2;
|
2007-05-06 00:00:00 +00:00
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(1), InstID, Vals, VE);
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(cast<CmpInst>(I).getPredicate());
|
|
|
|
break;
|
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
case Instruction::Ret:
|
2008-02-26 01:29:32 +00:00
|
|
|
{
|
|
|
|
Code = bitc::FUNC_CODE_INST_RET;
|
|
|
|
unsigned NumOperands = I.getNumOperands();
|
|
|
|
if (NumOperands == 0)
|
|
|
|
AbbrevToUse = FUNCTION_INST_RET_VOID_ABBREV;
|
|
|
|
else if (NumOperands == 1) {
|
|
|
|
if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE))
|
|
|
|
AbbrevToUse = FUNCTION_INST_RET_VAL_ABBREV;
|
|
|
|
} else {
|
|
|
|
for (unsigned i = 0, e = NumOperands; i != e; ++i)
|
|
|
|
PushValueAndType(I.getOperand(i), InstID, Vals, VE);
|
|
|
|
}
|
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
|
|
|
case Instruction::Br:
|
2009-01-30 18:27:21 +00:00
|
|
|
{
|
|
|
|
Code = bitc::FUNC_CODE_INST_BR;
|
2013-02-11 01:16:51 +00:00
|
|
|
const BranchInst &II = cast<BranchInst>(I);
|
2009-01-30 18:27:21 +00:00
|
|
|
Vals.push_back(VE.getValueID(II.getSuccessor(0)));
|
|
|
|
if (II.isConditional()) {
|
|
|
|
Vals.push_back(VE.getValueID(II.getSuccessor(1)));
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(II.getCondition(), InstID, Vals, VE);
|
2009-01-30 18:27:21 +00:00
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case Instruction::Switch:
|
SwitchInst refactoring.
The purpose of refactoring is to hide operand roles from SwitchInst user (programmer). If you want to play with operands directly, probably you will need lower level methods than SwitchInst ones (TerminatorInst or may be User). After this patch we can reorganize SwitchInst operands and successors as we want.
What was done:
1. Changed semantics of index inside the getCaseValue method:
getCaseValue(0) means "get first case", not a condition. Use getCondition() if you want to resolve the condition. I propose don't mix SwitchInst case indexing with low level indexing (TI successors indexing, User's operands indexing), since it may be dangerous.
2. By the same reason findCaseValue(ConstantInt*) returns actual number of case value. 0 means first case, not default. If there is no case with given value, ErrorIndex will returned.
3. Added getCaseSuccessor method. I propose to avoid usage of TerminatorInst::getSuccessor if you want to resolve case successor BB. Use getCaseSuccessor instead, since internal SwitchInst organization of operands/successors is hidden and may be changed in any moment.
4. Added resolveSuccessorIndex and resolveCaseIndex. The main purpose of these methods is to see how case successors are really mapped in TerminatorInst.
4.1 "resolveSuccessorIndex" was created if you need to level down from SwitchInst to TerminatorInst. It returns TerminatorInst's successor index for given case successor.
4.2 "resolveCaseIndex" converts low level successors index to case index that curresponds to the given successor.
Note: There are also related compatability fix patches for dragonegg, klee, llvm-gcc-4.0, llvm-gcc-4.2, safecode, clang.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@149481 91177308-0d34-0410-b5e6-96231b3b80d8
2012-02-01 07:49:51 +00:00
|
|
|
{
|
|
|
|
Code = bitc::FUNC_CODE_INST_SWITCH;
|
2013-02-11 01:16:51 +00:00
|
|
|
const SwitchInst &SI = cast<SwitchInst>(I);
|
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
|
|
|
Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));
|
|
|
|
pushValue(SI.getCondition(), InstID, Vals, VE);
|
|
|
|
Vals.push_back(VE.getValueID(SI.getDefaultDest()));
|
2013-02-11 01:16:51 +00:00
|
|
|
for (SwitchInst::ConstCaseIt i = SI.case_begin(), e = SI.case_end();
|
2012-03-08 07:06:20 +00:00
|
|
|
i != e; ++i) {
|
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
|
|
|
Vals.push_back(VE.getValueID(i.getCaseValue()));
|
|
|
|
Vals.push_back(VE.getValueID(i.getCaseSuccessor()));
|
SwitchInst refactoring.
The purpose of refactoring is to hide operand roles from SwitchInst user (programmer). If you want to play with operands directly, probably you will need lower level methods than SwitchInst ones (TerminatorInst or may be User). After this patch we can reorganize SwitchInst operands and successors as we want.
What was done:
1. Changed semantics of index inside the getCaseValue method:
getCaseValue(0) means "get first case", not a condition. Use getCondition() if you want to resolve the condition. I propose don't mix SwitchInst case indexing with low level indexing (TI successors indexing, User's operands indexing), since it may be dangerous.
2. By the same reason findCaseValue(ConstantInt*) returns actual number of case value. 0 means first case, not default. If there is no case with given value, ErrorIndex will returned.
3. Added getCaseSuccessor method. I propose to avoid usage of TerminatorInst::getSuccessor if you want to resolve case successor BB. Use getCaseSuccessor instead, since internal SwitchInst organization of operands/successors is hidden and may be changed in any moment.
4. Added resolveSuccessorIndex and resolveCaseIndex. The main purpose of these methods is to see how case successors are really mapped in TerminatorInst.
4.1 "resolveSuccessorIndex" was created if you need to level down from SwitchInst to TerminatorInst. It returns TerminatorInst's successor index for given case successor.
4.2 "resolveCaseIndex" converts low level successors index to case index that curresponds to the given successor.
Note: There are also related compatability fix patches for dragonegg, klee, llvm-gcc-4.0, llvm-gcc-4.2, safecode, clang.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@149481 91177308-0d34-0410-b5e6-96231b3b80d8
2012-02-01 07:49:51 +00:00
|
|
|
}
|
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
2009-10-28 00:19:10 +00:00
|
|
|
case Instruction::IndirectBr:
|
|
|
|
Code = bitc::FUNC_CODE_INST_INDIRECTBR;
|
2009-10-27 19:13:16 +00:00
|
|
|
Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// Encode the address operand as relative, but not the basic blocks.
|
|
|
|
pushValue(I.getOperand(0), InstID, Vals, VE);
|
|
|
|
for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i)
|
2009-10-27 19:13:16 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(i)));
|
|
|
|
break;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-05-01 07:03:37 +00:00
|
|
|
case Instruction::Invoke: {
|
2009-01-16 18:40:27 +00:00
|
|
|
const InvokeInst *II = cast<InvokeInst>(&I);
|
|
|
|
const Value *Callee(II->getCalledValue());
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = cast<PointerType>(Callee->getType());
|
|
|
|
FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
2007-05-01 02:13:26 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_INVOKE;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
Vals.push_back(VE.getAttributeID(II->getAttributes()));
|
2007-11-27 13:23:08 +00:00
|
|
|
Vals.push_back(II->getCallingConv());
|
2009-01-07 22:39:29 +00:00
|
|
|
Vals.push_back(VE.getValueID(II->getNormalDest()));
|
|
|
|
Vals.push_back(VE.getValueID(II->getUnwindDest()));
|
2009-01-16 18:40:27 +00:00
|
|
|
PushValueAndType(Callee, InstID, Vals, VE);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 02:13:26 +00:00
|
|
|
// Emit value #'s for the fixed parameters.
|
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(i), InstID, Vals, VE); // fixed param.
|
2007-05-01 02:13:26 +00:00
|
|
|
|
|
|
|
// Emit type/value pairs for varargs params.
|
|
|
|
if (FTy->isVarArg()) {
|
2010-03-24 13:21:49 +00:00
|
|
|
for (unsigned i = FTy->getNumParams(), e = I.getNumOperands()-3;
|
2007-05-06 00:00:00 +00:00
|
|
|
i != e; ++i)
|
|
|
|
PushValueAndType(I.getOperand(i), InstID, Vals, VE); // vararg
|
2007-05-01 02:13:26 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-05-01 07:03:37 +00:00
|
|
|
}
|
2011-07-31 06:30:59 +00:00
|
|
|
case Instruction::Resume:
|
|
|
|
Code = bitc::FUNC_CODE_INST_RESUME;
|
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
|
|
|
break;
|
2007-04-26 05:53:54 +00:00
|
|
|
case Instruction::Unreachable:
|
|
|
|
Code = bitc::FUNC_CODE_INST_UNREACHABLE;
|
2007-05-06 01:28:01 +00:00
|
|
|
AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
|
2007-04-26 05:53:54 +00:00
|
|
|
break;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-06-20 14:18:48 +00:00
|
|
|
case Instruction::PHI: {
|
|
|
|
const PHINode &PN = cast<PHINode>(I);
|
2007-05-01 02:13:26 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_PHI;
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// With the newer instruction encoding, forward references could give
|
|
|
|
// negative valued IDs. This is most common for PHIs, so we use
|
|
|
|
// signed VBRs.
|
|
|
|
SmallVector<uint64_t, 128> Vals64;
|
|
|
|
Vals64.push_back(VE.getTypeID(PN.getType()));
|
2011-06-20 14:18:48 +00:00
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValueSigned(PN.getIncomingValue(i), InstID, Vals64, VE);
|
|
|
|
Vals64.push_back(VE.getValueID(PN.getIncomingBlock(i)));
|
2011-06-20 14:18:48 +00:00
|
|
|
}
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// Emit a Vals64 vector and exit.
|
|
|
|
Stream.EmitRecord(Code, Vals64, AbbrevToUse);
|
|
|
|
Vals64.clear();
|
|
|
|
return;
|
2011-06-20 14:18:48 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
case Instruction::LandingPad: {
|
|
|
|
const LandingPadInst &LP = cast<LandingPadInst>(I);
|
|
|
|
Code = bitc::FUNC_CODE_INST_LANDINGPAD;
|
|
|
|
Vals.push_back(VE.getTypeID(LP.getType()));
|
|
|
|
PushValueAndType(LP.getPersonalityFn(), InstID, Vals, VE);
|
|
|
|
Vals.push_back(LP.isCleanup());
|
|
|
|
Vals.push_back(LP.getNumClauses());
|
|
|
|
for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {
|
|
|
|
if (LP.isCatch(I))
|
|
|
|
Vals.push_back(LandingPadInst::Catch);
|
|
|
|
else
|
|
|
|
Vals.push_back(LandingPadInst::Filter);
|
|
|
|
PushValueAndType(LP.getClause(I), InstID, Vals, VE);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-07-16 01:34:27 +00:00
|
|
|
case Instruction::Alloca: {
|
2007-05-01 02:13:26 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_ALLOCA;
|
|
|
|
Vals.push_back(VE.getTypeID(I.getType()));
|
2010-05-28 01:38:28 +00:00
|
|
|
Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
|
2014-07-16 01:34:27 +00:00
|
|
|
const AllocaInst &AI = cast<AllocaInst>(I);
|
|
|
|
unsigned AlignRecord = Log2_32(AI.getAlignment()) + 1;
|
|
|
|
assert(Log2_32(Value::MaximumAlignment) + 1 < 1 << 5 &&
|
|
|
|
"not enough bits for maximum alignment");
|
|
|
|
assert(AlignRecord < 1 << 5 && "alignment greater than 1 << 64");
|
|
|
|
AlignRecord |= AI.isUsedWithInAlloca() << 5;
|
|
|
|
Vals.push_back(AlignRecord);
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
2014-07-16 01:34:27 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 02:13:26 +00:00
|
|
|
case Instruction::Load:
|
2011-08-09 23:02:53 +00:00
|
|
|
if (cast<LoadInst>(I).isAtomic()) {
|
|
|
|
Code = bitc::FUNC_CODE_INST_LOADATOMIC;
|
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE);
|
|
|
|
} else {
|
|
|
|
Code = bitc::FUNC_CODE_INST_LOAD;
|
|
|
|
if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE)) // ptr
|
|
|
|
AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
|
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);
|
|
|
|
Vals.push_back(cast<LoadInst>(I).isVolatile());
|
2011-08-09 23:02:53 +00:00
|
|
|
if (cast<LoadInst>(I).isAtomic()) {
|
|
|
|
Vals.push_back(GetEncodedOrdering(cast<LoadInst>(I).getOrdering()));
|
|
|
|
Vals.push_back(GetEncodedSynchScope(cast<LoadInst>(I).getSynchScope()));
|
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
|
|
|
case Instruction::Store:
|
2011-08-09 23:02:53 +00:00
|
|
|
if (cast<StoreInst>(I).isAtomic())
|
|
|
|
Code = bitc::FUNC_CODE_INST_STOREATOMIC;
|
|
|
|
else
|
|
|
|
Code = bitc::FUNC_CODE_INST_STORE;
|
2007-12-11 08:59:05 +00:00
|
|
|
PushValueAndType(I.getOperand(1), InstID, Vals, VE); // ptrty + ptr
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(0), InstID, Vals, VE); // val.
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
|
|
|
|
Vals.push_back(cast<StoreInst>(I).isVolatile());
|
2011-08-09 23:02:53 +00:00
|
|
|
if (cast<StoreInst>(I).isAtomic()) {
|
|
|
|
Vals.push_back(GetEncodedOrdering(cast<StoreInst>(I).getOrdering()));
|
|
|
|
Vals.push_back(GetEncodedSynchScope(cast<StoreInst>(I).getSynchScope()));
|
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
2011-07-28 21:48:00 +00:00
|
|
|
case Instruction::AtomicCmpXchg:
|
|
|
|
Code = bitc::FUNC_CODE_INST_CMPXCHG;
|
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE); // ptrty + ptr
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(1), InstID, Vals, VE); // cmp.
|
|
|
|
pushValue(I.getOperand(2), InstID, Vals, VE); // newval.
|
2011-07-28 21:48:00 +00:00
|
|
|
Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());
|
|
|
|
Vals.push_back(GetEncodedOrdering(
|
2014-03-11 10:48:52 +00:00
|
|
|
cast<AtomicCmpXchgInst>(I).getSuccessOrdering()));
|
2011-07-28 21:48:00 +00:00
|
|
|
Vals.push_back(GetEncodedSynchScope(
|
|
|
|
cast<AtomicCmpXchgInst>(I).getSynchScope()));
|
2014-03-11 10:48:52 +00:00
|
|
|
Vals.push_back(GetEncodedOrdering(
|
|
|
|
cast<AtomicCmpXchgInst>(I).getFailureOrdering()));
|
IR: add "cmpxchg weak" variant to support permitted failure.
This commit adds a weak variant of the cmpxchg operation, as described
in C++11. A cmpxchg instruction with this modifier is permitted to
fail to store, even if the comparison indicated it should.
As a result, cmpxchg instructions must return a flag indicating
success in addition to their original iN value loaded. Thus, for
uniformity *all* cmpxchg instructions now return "{ iN, i1 }". The
second flag is 1 when the store succeeded.
At the DAG level, a new ATOMIC_CMP_SWAP_WITH_SUCCESS node has been
added as the natural representation for the new cmpxchg instructions.
It is a strong cmpxchg.
By default this gets Expanded to the existing ATOMIC_CMP_SWAP during
Legalization, so existing backends should see no change in behaviour.
If they wish to deal with the enhanced node instead, they can call
setOperationAction on it. Beware: as a node with 2 results, it cannot
be selected from TableGen.
Currently, no use is made of the extra information provided in this
patch. Test updates are almost entirely adapting the input IR to the
new scheme.
Summary for out of tree users:
------------------------------
+ Legacy Bitcode files are upgraded during read.
+ Legacy assembly IR files will be invalid.
+ Front-ends must adapt to different type for "cmpxchg".
+ Backends should be unaffected by default.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@210903 91177308-0d34-0410-b5e6-96231b3b80d8
2014-06-13 14:24:07 +00:00
|
|
|
Vals.push_back(cast<AtomicCmpXchgInst>(I).isWeak());
|
2011-07-28 21:48:00 +00:00
|
|
|
break;
|
|
|
|
case Instruction::AtomicRMW:
|
|
|
|
Code = bitc::FUNC_CODE_INST_ATOMICRMW;
|
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE); // ptrty + ptr
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(1), InstID, Vals, VE); // val.
|
2011-07-28 21:48:00 +00:00
|
|
|
Vals.push_back(GetEncodedRMWOperation(
|
|
|
|
cast<AtomicRMWInst>(I).getOperation()));
|
|
|
|
Vals.push_back(cast<AtomicRMWInst>(I).isVolatile());
|
|
|
|
Vals.push_back(GetEncodedOrdering(cast<AtomicRMWInst>(I).getOrdering()));
|
|
|
|
Vals.push_back(GetEncodedSynchScope(
|
|
|
|
cast<AtomicRMWInst>(I).getSynchScope()));
|
|
|
|
break;
|
2011-07-25 23:16:38 +00:00
|
|
|
case Instruction::Fence:
|
|
|
|
Code = bitc::FUNC_CODE_INST_FENCE;
|
|
|
|
Vals.push_back(GetEncodedOrdering(cast<FenceInst>(I).getOrdering()));
|
|
|
|
Vals.push_back(GetEncodedSynchScope(cast<FenceInst>(I).getSynchScope()));
|
|
|
|
break;
|
2007-05-01 02:13:26 +00:00
|
|
|
case Instruction::Call: {
|
2010-06-26 09:35:09 +00:00
|
|
|
const CallInst &CI = cast<CallInst>(I);
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = cast<PointerType>(CI.getCalledValue()->getType());
|
|
|
|
FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
2007-05-08 05:38:01 +00:00
|
|
|
|
2011-06-17 18:17:37 +00:00
|
|
|
Code = bitc::FUNC_CODE_INST_CALL;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-06-26 09:35:09 +00:00
|
|
|
Vals.push_back(VE.getAttributeID(CI.getAttributes()));
|
2014-04-24 20:14:34 +00:00
|
|
|
Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()) |
|
|
|
|
unsigned(CI.isMustTailCall()) << 14);
|
2010-06-26 09:35:09 +00:00
|
|
|
PushValueAndType(CI.getCalledValue(), InstID, Vals, VE); // Callee
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 02:13:26 +00:00
|
|
|
// Emit value #'s for the fixed parameters.
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {
|
|
|
|
// Check for labels (can happen with asm labels).
|
|
|
|
if (FTy->getParamType(i)->isLabelTy())
|
|
|
|
Vals.push_back(VE.getValueID(CI.getArgOperand(i)));
|
|
|
|
else
|
|
|
|
pushValue(CI.getArgOperand(i), InstID, Vals, VE); // fixed param.
|
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 07:03:37 +00:00
|
|
|
// Emit type/value pairs for varargs params.
|
|
|
|
if (FTy->isVarArg()) {
|
2010-06-26 09:35:09 +00:00
|
|
|
for (unsigned i = FTy->getNumParams(), e = CI.getNumArgOperands();
|
2007-05-06 00:00:00 +00:00
|
|
|
i != e; ++i)
|
2010-06-26 09:35:09 +00:00
|
|
|
PushValueAndType(CI.getArgOperand(i), InstID, Vals, VE); // varargs
|
2007-05-01 02:13:26 +00:00
|
|
|
}
|
|
|
|
break;
|
2007-05-01 07:03:37 +00:00
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
case Instruction::VAArg:
|
|
|
|
Code = bitc::FUNC_CODE_INST_VAARG;
|
|
|
|
Vals.push_back(VE.getTypeID(I.getOperand(0)->getType())); // valistty
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
pushValue(I.getOperand(0), InstID, Vals, VE); // valist.
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getTypeID(I.getType())); // restype.
|
|
|
|
break;
|
2007-04-26 05:53:54 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
Stream.EmitRecord(Code, Vals, AbbrevToUse);
|
|
|
|
Vals.clear();
|
|
|
|
}
|
|
|
|
|
2007-05-01 02:14:57 +00:00
|
|
|
// Emit names for globals/functions etc.
|
|
|
|
static void WriteValueSymbolTable(const ValueSymbolTable &VST,
|
|
|
|
const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
if (VST.empty()) return;
|
2007-05-05 01:26:50 +00:00
|
|
|
Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
|
2007-05-04 20:34:50 +00:00
|
|
|
|
2007-05-01 02:14:57 +00:00
|
|
|
// FIXME: Set up the abbrev, we know how many values there are!
|
|
|
|
// FIXME: We know if the type names can use 7-bit ascii.
|
|
|
|
SmallVector<unsigned, 64> NameVals;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 02:14:57 +00:00
|
|
|
for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
|
|
|
|
SI != SE; ++SI) {
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 20:52:02 +00:00
|
|
|
const ValueName &Name = *SI;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 20:52:02 +00:00
|
|
|
// Figure out the encoding to use for the name.
|
|
|
|
bool is7Bit = true;
|
2007-05-05 01:26:50 +00:00
|
|
|
bool isChar6 = true;
|
|
|
|
for (const char *C = Name.getKeyData(), *E = C+Name.getKeyLength();
|
|
|
|
C != E; ++C) {
|
2009-09-20 02:20:51 +00:00
|
|
|
if (isChar6)
|
2007-05-05 01:26:50 +00:00
|
|
|
isChar6 = BitCodeAbbrevOp::isChar6(*C);
|
|
|
|
if ((unsigned char)*C & 128) {
|
2007-05-04 20:52:02 +00:00
|
|
|
is7Bit = false;
|
2007-05-05 01:26:50 +00:00
|
|
|
break; // don't bother scanning the rest.
|
2007-05-04 20:52:02 +00:00
|
|
|
}
|
2007-05-05 01:26:50 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 21:31:13 +00:00
|
|
|
unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-04-10 23:18:04 +00:00
|
|
|
// VST_ENTRY: [valueid, namechar x N]
|
|
|
|
// VST_BBENTRY: [bbid, namechar x N]
|
2007-05-03 22:18:21 +00:00
|
|
|
unsigned Code;
|
2011-04-10 23:18:04 +00:00
|
|
|
if (isa<BasicBlock>(SI->getValue())) {
|
|
|
|
Code = bitc::VST_CODE_BBENTRY;
|
|
|
|
if (isChar6)
|
|
|
|
AbbrevToUse = VST_BBENTRY_6_ABBREV;
|
2007-05-03 22:18:21 +00:00
|
|
|
} else {
|
|
|
|
Code = bitc::VST_CODE_ENTRY;
|
2007-05-05 01:26:50 +00:00
|
|
|
if (isChar6)
|
|
|
|
AbbrevToUse = VST_ENTRY_6_ABBREV;
|
|
|
|
else if (is7Bit)
|
|
|
|
AbbrevToUse = VST_ENTRY_7_ABBREV;
|
2007-05-03 22:18:21 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-03 22:18:21 +00:00
|
|
|
NameVals.push_back(VE.getValueID(SI->getValue()));
|
2007-05-04 20:52:02 +00:00
|
|
|
for (const char *P = Name.getKeyData(),
|
|
|
|
*E = Name.getKeyData()+Name.getKeyLength(); P != E; ++P)
|
2007-05-01 02:14:57 +00:00
|
|
|
NameVals.push_back((unsigned char)*P);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 02:14:57 +00:00
|
|
|
// Emit the finished record.
|
2007-05-03 22:18:21 +00:00
|
|
|
Stream.EmitRecord(Code, NameVals, AbbrevToUse);
|
2007-05-01 02:14:57 +00:00
|
|
|
NameVals.clear();
|
|
|
|
}
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2014-07-28 21:19:41 +00:00
|
|
|
static void WriteUseList(ValueEnumerator &VE, UseListOrder &&Order,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
assert(Order.Shuffle.size() >= 2 && "Shuffle too small");
|
|
|
|
unsigned Code;
|
|
|
|
if (isa<BasicBlock>(Order.V))
|
|
|
|
Code = bitc::USELIST_CODE_BB;
|
|
|
|
else
|
|
|
|
Code = bitc::USELIST_CODE_DEFAULT;
|
|
|
|
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
|
|
|
for (unsigned I : Order.Shuffle)
|
|
|
|
Record.push_back(I);
|
|
|
|
Record.push_back(VE.getValueID(Order.V));
|
|
|
|
Stream.EmitRecord(Code, Record);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void WriteUseListBlock(const Function *F, ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
auto hasMore = [&]() {
|
|
|
|
return !VE.UseListOrders.empty() && VE.UseListOrders.back().F == F;
|
|
|
|
};
|
|
|
|
if (!hasMore())
|
|
|
|
// Nothing to do.
|
|
|
|
return;
|
|
|
|
|
|
|
|
Stream.EnterSubblock(bitc::USELIST_BLOCK_ID, 3);
|
|
|
|
while (hasMore()) {
|
|
|
|
WriteUseList(VE, std::move(VE.UseListOrders.back()), Stream);
|
|
|
|
VE.UseListOrders.pop_back();
|
|
|
|
}
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2007-04-26 03:50:57 +00:00
|
|
|
/// WriteFunction - Emit a function body to the module stream.
|
2009-09-20 02:20:51 +00:00
|
|
|
static void WriteFunction(const Function &F, ValueEnumerator &VE,
|
2007-04-26 03:27:58 +00:00
|
|
|
BitstreamWriter &Stream) {
|
2007-05-06 02:38:57 +00:00
|
|
|
Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);
|
2011-06-03 17:02:19 +00:00
|
|
|
VE.incorporateFunction(F);
|
2007-04-26 05:53:54 +00:00
|
|
|
|
|
|
|
SmallVector<unsigned, 64> Vals;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
// Emit the number of basic blocks, so the reader can create them ahead of
|
|
|
|
// time.
|
|
|
|
Vals.push_back(VE.getBasicBlocks().size());
|
|
|
|
Stream.EmitRecord(bitc::FUNC_CODE_DECLAREBLOCKS, Vals);
|
|
|
|
Vals.clear();
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
// If there are function-local constants, emit them now.
|
|
|
|
unsigned CstStart, CstEnd;
|
|
|
|
VE.getFunctionConstantRange(CstStart, CstEnd);
|
2009-08-04 05:01:35 +00:00
|
|
|
WriteConstants(CstStart, CstEnd, VE, Stream, false);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-01-14 01:50:08 +00:00
|
|
|
// If there is function-local metadata, emit it now.
|
2010-01-14 19:38:44 +00:00
|
|
|
WriteFunctionLocalMetadata(F, VE, Stream);
|
2010-01-14 01:50:08 +00:00
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
// Keep a running idea of what the instruction ID is.
|
2007-05-06 00:00:00 +00:00
|
|
|
unsigned InstID = CstEnd;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
bool NeedsMetadataAttachment = false;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
DebugLoc LastDL;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2007-04-26 05:53:54 +00:00
|
|
|
// Finally, emit all the instructions, in order.
|
2008-04-25 16:53:59 +00:00
|
|
|
for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
|
2007-05-06 00:00:00 +00:00
|
|
|
for (BasicBlock::const_iterator I = BB->begin(), E = BB->end();
|
|
|
|
I != E; ++I) {
|
|
|
|
WriteInstruction(*I, InstID, VE, Stream, Vals);
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2009-12-28 23:41:32 +00:00
|
|
|
if (!I->getType()->isVoidTy())
|
2007-05-06 00:00:00 +00:00
|
|
|
++InstID;
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
// If the instruction has metadata, write a metadata attachment later.
|
|
|
|
NeedsMetadataAttachment |= I->hasMetadataOtherThanDebugLoc();
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
// If the instruction has a debug location, emit it.
|
|
|
|
DebugLoc DL = I->getDebugLoc();
|
|
|
|
if (DL.isUnknown()) {
|
|
|
|
// nothing todo.
|
|
|
|
} else if (DL == LastDL) {
|
|
|
|
// Just repeat the same debug loc as last time.
|
|
|
|
Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC_AGAIN, Vals);
|
|
|
|
} else {
|
|
|
|
MDNode *Scope, *IA;
|
|
|
|
DL.getScopeAndInlinedAt(Scope, IA, I->getContext());
|
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
|
|
|
assert(Scope && "Expected valid scope");
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
Vals.push_back(DL.getLine());
|
|
|
|
Vals.push_back(DL.getCol());
|
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
|
|
|
Vals.push_back(Scope ? VE.getMetadataID(Scope) + 1 : 0);
|
|
|
|
Vals.push_back(IA ? VE.getMetadataID(IA) + 1 : 0);
|
2015-01-09 17:53:27 +00:00
|
|
|
Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
|
2010-04-03 02:17:50 +00:00
|
|
|
Vals.clear();
|
2012-11-15 22:34:00 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
LastDL = DL;
|
|
|
|
}
|
2007-05-06 00:00:00 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-01 02:14:57 +00:00
|
|
|
// Emit names for all the instructions etc.
|
|
|
|
WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);
|
2009-09-18 19:26:43 +00:00
|
|
|
|
2010-04-03 02:17:50 +00:00
|
|
|
if (NeedsMetadataAttachment)
|
|
|
|
WriteMetadataAttachment(F, VE, Stream);
|
2014-07-28 21:19:41 +00:00
|
|
|
if (shouldPreserveBitcodeUseListOrder())
|
|
|
|
WriteUseListBlock(&F, VE, Stream);
|
2011-06-03 17:02:19 +00:00
|
|
|
VE.purgeFunction();
|
2007-04-26 05:53:54 +00:00
|
|
|
Stream.ExitBlock();
|
2007-04-26 03:27:58 +00:00
|
|
|
}
|
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
// Emit blockinfo, which defines the standard abbreviations etc.
|
|
|
|
static void WriteBlockInfo(const ValueEnumerator &VE, BitstreamWriter &Stream) {
|
|
|
|
// We only want to emit block info records for blocks that have multiple
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
// instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK.
|
2012-10-11 21:45:16 +00:00
|
|
|
// Other blocks can define their abbrevs inline.
|
2007-05-05 07:36:14 +00:00
|
|
|
Stream.EnterBlockInfoBlock(2);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
{ // 8-bit fixed-width VST_ENTRY/VST_BBENTRY strings.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
|
2009-09-20 02:20:51 +00:00
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
|
2007-05-05 07:36:14 +00:00
|
|
|
Abbv) != VST_ENTRY_8_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
{ // 7-bit fixed width VST_ENTRY strings.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
|
|
|
|
Abbv) != VST_ENTRY_7_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
|
|
|
{ // 6-bit char6 VST_ENTRY strings.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_ENTRY));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
|
|
|
|
Abbv) != VST_ENTRY_6_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
|
|
|
{ // 6-bit char6 VST_BBENTRY strings.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::VST_CODE_BBENTRY));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Char6));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
|
|
|
|
Abbv) != VST_BBENTRY_6_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
2011-04-10 23:18:04 +00:00
|
|
|
|
|
|
|
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
{ // SETTYPE abbrev for CONSTANTS_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_SETTYPE));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
|
|
|
|
Log2_32_Ceil(VE.getTypes().size()+1)));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
|
|
|
|
Abbv) != CONSTANTS_SETTYPE_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
{ // INTEGER abbrev for CONSTANTS_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_INTEGER));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
|
|
|
|
Abbv) != CONSTANTS_INTEGER_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
{ // CE_CAST abbrev for CONSTANTS_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_CE_CAST));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // cast opc
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // typeid
|
|
|
|
Log2_32_Ceil(VE.getTypes().size()+1)));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // value id
|
|
|
|
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
|
|
|
|
Abbv) != CONSTANTS_CE_CAST_Abbrev)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
|
|
|
{ // NULL abbrev for CONSTANTS_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::CST_CODE_NULL));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::CONSTANTS_BLOCK_ID,
|
|
|
|
Abbv) != CONSTANTS_NULL_Abbrev)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:36:14 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:44:49 +00:00
|
|
|
// FIXME: This should only use space for first class types!
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:44:49 +00:00
|
|
|
{ // INST_LOAD abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_LOAD));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Ptr
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 4)); // Align
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // volatile
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_LOAD_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-05 07:44:49 +00:00
|
|
|
}
|
2007-05-06 02:38:57 +00:00
|
|
|
{ // INST_BINOP abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_BINOP_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-06 02:38:57 +00:00
|
|
|
}
|
2009-07-20 21:19:07 +00:00
|
|
|
{ // INST_BINOP_FLAGS abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_BINOP));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // LHS
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // RHS
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 7)); // flags
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_BINOP_FLAGS_ABBREV)
|
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
|
|
|
}
|
2007-05-06 02:38:57 +00:00
|
|
|
{ // INST_CAST abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_CAST));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // OpVal
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, // dest ty
|
|
|
|
Log2_32_Ceil(VE.getTypes().size()+1)));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // opc
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_CAST_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-06 02:38:57 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-06 01:28:01 +00:00
|
|
|
{ // INST_RET abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_RET_VOID_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-06 01:28:01 +00:00
|
|
|
}
|
|
|
|
{ // INST_RET abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_RET));
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // ValID
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_RET_VAL_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-06 01:28:01 +00:00
|
|
|
}
|
|
|
|
{ // INST_UNREACHABLE abbrev for FUNCTION_BLOCK.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::FUNC_CODE_INST_UNREACHABLE));
|
|
|
|
if (Stream.EmitBlockInfoAbbrev(bitc::FUNCTION_BLOCK_ID,
|
|
|
|
Abbv) != FUNCTION_INST_UNREACHABLE_ABBREV)
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unexpected abbrev ordering!");
|
2007-05-06 01:28:01 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-05 07:36:14 +00:00
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
/// WriteModule - Emit the specified module to the bitstream.
|
|
|
|
static void WriteModule(const Module *M, BitstreamWriter &Stream) {
|
2007-04-23 18:58:34 +00:00
|
|
|
Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
Change encoding of instruction operands in bitcode binaries to be relative
to the instruction position. The old encoding would give an absolute
ID which counts up within a function, and only resets at the next function.
I.e., Instead of having:
... = icmp eq i32 n-1, n-2
br i1 ..., label %bb1, label %bb2
it will now be roughly:
... = icmp eq i32 1, 2
br i1 1, label %bb1, label %bb2
This makes it so that ids remain relatively small and can be encoded
in fewer bits.
With this encoding, forward reference operands will be given
negative-valued IDs. Use signed VBRs for the most common case
of forward references, which is phi instructions.
To retain backward compatibility we bump the bitcode version
from 0 to 1 to distinguish between the different encodings.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165739 91177308-0d34-0410-b5e6-96231b3b80d8
2012-10-11 20:20:40 +00:00
|
|
|
SmallVector<unsigned, 1> Vals;
|
|
|
|
unsigned CurVersion = 1;
|
|
|
|
Vals.push_back(CurVersion);
|
|
|
|
Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Analyze the module, enumerating globals, functions, etc.
|
2014-11-17 20:06:27 +00:00
|
|
|
ValueEnumerator VE(*M);
|
2007-05-05 07:36:14 +00:00
|
|
|
|
|
|
|
// Emit blockinfo, which defines the standard abbreviations etc.
|
|
|
|
WriteBlockInfo(VE, Stream);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2013-02-10 23:09:32 +00:00
|
|
|
// Emit information about attribute groups.
|
|
|
|
WriteAttributeGroupTable(VE, Stream);
|
|
|
|
|
2007-05-04 00:44:52 +00:00
|
|
|
// Emit information about parameter attributes.
|
2008-09-25 21:00:45 +00:00
|
|
|
WriteAttributeTable(VE, Stream);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit information describing all of the types in the module.
|
|
|
|
WriteTypeTable(VE, Stream);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2014-06-27 18:19:56 +00:00
|
|
|
writeComdats(VE, Stream);
|
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit top-level description of module, including target triple, inline asm,
|
|
|
|
// descriptors for global variables, and function prototype info.
|
|
|
|
WriteModuleInfo(M, VE, Stream);
|
2009-07-22 17:43:22 +00:00
|
|
|
|
2009-07-23 01:07:34 +00:00
|
|
|
// Emit constants.
|
|
|
|
WriteModuleConstants(VE, Stream);
|
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
// Emit metadata.
|
2010-07-21 23:38:33 +00:00
|
|
|
WriteModuleMetadata(M, VE, Stream);
|
2009-08-04 05:01:35 +00:00
|
|
|
|
2009-09-18 19:26:43 +00:00
|
|
|
// Emit metadata.
|
2009-12-28 20:10:43 +00:00
|
|
|
WriteModuleMetadataStore(M, Stream);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-23 20:35:01 +00:00
|
|
|
// Emit names for globals/functions etc.
|
|
|
|
WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2014-07-28 21:19:41 +00:00
|
|
|
// Emit module-level use-lists.
|
2014-07-25 14:49:26 +00:00
|
|
|
if (shouldPreserveBitcodeUseListOrder())
|
2014-07-28 21:19:41 +00:00
|
|
|
WriteUseListBlock(nullptr, VE, Stream);
|
2011-12-07 21:44:12 +00:00
|
|
|
|
2012-02-06 22:30:29 +00:00
|
|
|
// Emit function bodies.
|
|
|
|
for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F)
|
|
|
|
if (!F->isDeclaration())
|
|
|
|
WriteFunction(*F, VE, Stream);
|
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
2008-07-09 05:14:23 +00:00
|
|
|
/// EmitDarwinBCHeader - If generating a bc file on darwin, we have to emit a
|
|
|
|
/// header and trailer to make it compatible with the system archiver. To do
|
|
|
|
/// this we emit the following header, and then emit a trailer that pads the
|
|
|
|
/// file out to be a multiple of 16 bytes.
|
2009-09-20 02:20:51 +00:00
|
|
|
///
|
2008-07-09 05:14:23 +00:00
|
|
|
/// struct bc_header {
|
|
|
|
/// uint32_t Magic; // 0x0B17C0DE
|
|
|
|
/// uint32_t Version; // Version, currently always 0.
|
|
|
|
/// uint32_t BitcodeOffset; // Offset to traditional bitcode file.
|
|
|
|
/// uint32_t BitcodeSize; // Size of traditional bitcode file.
|
|
|
|
/// uint32_t CPUType; // CPU specifier.
|
|
|
|
/// ... potentially more later ...
|
|
|
|
/// };
|
|
|
|
enum {
|
|
|
|
DarwinBCSizeFieldOffset = 3*4, // Offset to bitcode_size.
|
|
|
|
DarwinBCHeaderSize = 5*4
|
|
|
|
};
|
|
|
|
|
2012-02-29 20:31:09 +00:00
|
|
|
static void WriteInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,
|
2012-02-29 20:31:01 +00:00
|
|
|
uint32_t &Position) {
|
|
|
|
Buffer[Position + 0] = (unsigned char) (Value >> 0);
|
|
|
|
Buffer[Position + 1] = (unsigned char) (Value >> 8);
|
|
|
|
Buffer[Position + 2] = (unsigned char) (Value >> 16);
|
|
|
|
Buffer[Position + 3] = (unsigned char) (Value >> 24);
|
|
|
|
Position += 4;
|
|
|
|
}
|
|
|
|
|
2012-02-29 20:31:09 +00:00
|
|
|
static void EmitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
|
2012-02-29 20:31:01 +00:00
|
|
|
const Triple &TT) {
|
2008-07-09 05:14:23 +00:00
|
|
|
unsigned CPUType = ~0U;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2010-02-12 20:13:44 +00:00
|
|
|
// Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*, arm-*, thumb-*,
|
2010-02-12 20:39:35 +00:00
|
|
|
// armv[0-9]-*, thumbv[0-9]-*, armv5te-*, or armv6t2-*. The CPUType is a magic
|
|
|
|
// number from /usr/include/mach/machine.h. It is ok to reproduce the
|
|
|
|
// specific constants here because they are implicitly part of the Darwin ABI.
|
2008-07-09 05:14:23 +00:00
|
|
|
enum {
|
|
|
|
DARWIN_CPU_ARCH_ABI64 = 0x01000000,
|
|
|
|
DARWIN_CPU_TYPE_X86 = 7,
|
2010-02-12 20:13:44 +00:00
|
|
|
DARWIN_CPU_TYPE_ARM = 12,
|
2008-07-09 05:14:23 +00:00
|
|
|
DARWIN_CPU_TYPE_POWERPC = 18
|
|
|
|
};
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2011-06-14 01:51:33 +00:00
|
|
|
Triple::ArchType Arch = TT.getArch();
|
|
|
|
if (Arch == Triple::x86_64)
|
2008-07-09 05:14:23 +00:00
|
|
|
CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;
|
2011-06-14 01:51:33 +00:00
|
|
|
else if (Arch == Triple::x86)
|
2008-07-09 05:14:23 +00:00
|
|
|
CPUType = DARWIN_CPU_TYPE_X86;
|
2011-06-14 01:51:33 +00:00
|
|
|
else if (Arch == Triple::ppc)
|
2008-07-09 05:14:23 +00:00
|
|
|
CPUType = DARWIN_CPU_TYPE_POWERPC;
|
2011-06-14 01:51:33 +00:00
|
|
|
else if (Arch == Triple::ppc64)
|
2008-07-09 05:14:23 +00:00
|
|
|
CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
|
2011-06-14 01:51:33 +00:00
|
|
|
else if (Arch == Triple::arm || Arch == Triple::thumb)
|
2010-02-12 20:13:44 +00:00
|
|
|
CPUType = DARWIN_CPU_TYPE_ARM;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-07-09 05:14:23 +00:00
|
|
|
// Traditional Bitcode starts after header.
|
2012-02-29 20:31:01 +00:00
|
|
|
assert(Buffer.size() >= DarwinBCHeaderSize &&
|
|
|
|
"Expected header size to be reserved");
|
2008-07-09 05:14:23 +00:00
|
|
|
unsigned BCOffset = DarwinBCHeaderSize;
|
2012-02-29 20:31:01 +00:00
|
|
|
unsigned BCSize = Buffer.size()-DarwinBCHeaderSize;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2012-02-29 20:31:01 +00:00
|
|
|
// Write the magic and version.
|
|
|
|
unsigned Position = 0;
|
|
|
|
WriteInt32ToBuffer(0x0B17C0DE , Buffer, Position);
|
|
|
|
WriteInt32ToBuffer(0 , Buffer, Position); // Version.
|
|
|
|
WriteInt32ToBuffer(BCOffset , Buffer, Position);
|
|
|
|
WriteInt32ToBuffer(BCSize , Buffer, Position);
|
|
|
|
WriteInt32ToBuffer(CPUType , Buffer, Position);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-07-09 05:14:23 +00:00
|
|
|
// If the file is not a multiple of 16 bytes, insert dummy padding.
|
2012-02-29 20:31:01 +00:00
|
|
|
while (Buffer.size() & 15)
|
|
|
|
Buffer.push_back(0);
|
2008-07-09 05:14:23 +00:00
|
|
|
}
|
|
|
|
|
2008-10-22 17:39:14 +00:00
|
|
|
/// WriteBitcodeToFile - Write the specified module to the specified output
|
|
|
|
/// stream.
|
|
|
|
void llvm::WriteBitcodeToFile(const Module *M, raw_ostream &Out) {
|
2012-12-03 21:29:36 +00:00
|
|
|
SmallVector<char, 0> Buffer;
|
2007-04-22 06:24:45 +00:00
|
|
|
Buffer.reserve(256*1024);
|
2008-12-19 18:37:59 +00:00
|
|
|
|
2012-02-29 20:31:01 +00:00
|
|
|
// If this is darwin or another generic macho target, reserve space for the
|
|
|
|
// header.
|
2011-06-14 01:51:33 +00:00
|
|
|
Triple TT(M->getTargetTriple());
|
|
|
|
if (TT.isOSDarwin())
|
2012-02-29 20:31:01 +00:00
|
|
|
Buffer.insert(Buffer.begin(), DarwinBCHeaderSize, 0);
|
|
|
|
|
|
|
|
// Emit the module into the buffer.
|
|
|
|
{
|
|
|
|
BitstreamWriter Stream(Buffer);
|
|
|
|
|
|
|
|
// Emit the file header.
|
|
|
|
Stream.Emit((unsigned)'B', 8);
|
|
|
|
Stream.Emit((unsigned)'C', 8);
|
|
|
|
Stream.Emit(0x0, 4);
|
|
|
|
Stream.Emit(0xC, 4);
|
|
|
|
Stream.Emit(0xE, 4);
|
|
|
|
Stream.Emit(0xD, 4);
|
|
|
|
|
|
|
|
// Emit the module.
|
|
|
|
WriteModule(M, Stream);
|
|
|
|
}
|
2008-07-09 05:14:23 +00:00
|
|
|
|
2011-06-14 01:51:33 +00:00
|
|
|
if (TT.isOSDarwin())
|
2012-02-29 20:31:01 +00:00
|
|
|
EmitDarwinBCHeaderAndTrailer(Buffer, TT);
|
|
|
|
|
|
|
|
// Write the generated bitstream to "Out".
|
|
|
|
Out.write((char*)&Buffer.front(), Buffer.size());
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|