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"
|
|
|
|
#include "llvm/Bitcode/BitstreamWriter.h"
|
2007-04-23 01:01:37 +00:00
|
|
|
#include "llvm/Bitcode/LLVMBitCodes.h"
|
2007-04-22 06:24:45 +00:00
|
|
|
#include "ValueEnumerator.h"
|
2007-04-24 00:16:04 +00:00
|
|
|
#include "llvm/Constants.h"
|
2007-04-22 06:24:45 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2007-05-06 01:58:20 +00:00
|
|
|
#include "llvm/InlineAsm.h"
|
2007-04-26 05:53:54 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2007-04-22 06:24:45 +00:00
|
|
|
#include "llvm/Module.h"
|
2009-07-20 21:19:07 +00:00
|
|
|
#include "llvm/Operator.h"
|
2007-04-23 20:35:01 +00:00
|
|
|
#include "llvm/ValueSymbolTable.h"
|
2011-06-14 01:51:33 +00:00
|
|
|
#include "llvm/ADT/Triple.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"
|
2008-10-22 17:39:14 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Program.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;
|
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
EnablePreserveUseListOrdering("enable-bc-uselist-preserve",
|
|
|
|
cl::desc("Turn on experimental support for "
|
|
|
|
"use-list order preservation."),
|
|
|
|
cl::init(false), cl::Hidden);
|
|
|
|
|
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 {
|
|
|
|
CurVersion = 0,
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 20:52:02 +00:00
|
|
|
// 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,
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-05-04 00:44:52 +00:00
|
|
|
// Emit information about parameter attributes.
|
2009-09-20 02:20:51 +00:00
|
|
|
static void WriteAttributeTable(const ValueEnumerator &VE,
|
2007-05-04 00:44:52 +00:00
|
|
|
BitstreamWriter &Stream) {
|
2008-09-25 21:00:45 +00:00
|
|
|
const std::vector<AttrListPtr> &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) {
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &A = Attrs[i];
|
2008-03-12 17:45:29 +00:00
|
|
|
for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i) {
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttributeWithIndex &PAWI = A.getSlot(i);
|
2008-03-12 17:45:29 +00:00
|
|
|
Record.push_back(PAWI.Index);
|
2008-12-19 09:38:31 +00:00
|
|
|
|
|
|
|
// FIXME: remove in LLVM 3.0
|
|
|
|
// Store the alignment in the bitcode as a 16-bit raw value instead of a
|
|
|
|
// 5-bit log2 encoded value. Shift the bits above the alignment up by
|
|
|
|
// 11 bits.
|
2012-01-20 17:56:17 +00:00
|
|
|
uint64_t FauxAttr = PAWI.Attrs.Raw() & 0xffff;
|
2008-12-19 09:38:31 +00:00
|
|
|
if (PAWI.Attrs & Attribute::Alignment)
|
2012-01-20 17:56:17 +00:00
|
|
|
FauxAttr |= (1ull<<16)<<
|
|
|
|
(((PAWI.Attrs & Attribute::Alignment).Raw()-1) >> 16);
|
|
|
|
FauxAttr |= (PAWI.Attrs.Raw() & (0x3FFull << 21)) << 11;
|
2008-12-19 09:38:31 +00:00
|
|
|
|
|
|
|
Record.push_back(FauxAttr);
|
2007-05-04 02:59:04 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-05-04 02:59:04 +00:00
|
|
|
Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
|
|
|
|
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);
|
|
|
|
|
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()) {
|
2009-07-14 16:55:14 +00:00
|
|
|
default: llvm_unreachable("Unknown type!");
|
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
|
|
|
case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break;
|
2011-12-17 00:04:22 +00:00
|
|
|
case Type::HalfTyID: Code = bitc::TYPE_CODE_HALF; break;
|
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
|
|
|
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;
|
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
|
|
|
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));
|
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
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned getEncodedLinkage(const GlobalValue *GV) {
|
|
|
|
switch (GV->getLinkage()) {
|
2010-08-20 22:05:50 +00:00
|
|
|
case GlobalValue::ExternalLinkage: return 0;
|
|
|
|
case GlobalValue::WeakAnyLinkage: return 1;
|
|
|
|
case GlobalValue::AppendingLinkage: return 2;
|
|
|
|
case GlobalValue::InternalLinkage: return 3;
|
|
|
|
case GlobalValue::LinkOnceAnyLinkage: return 4;
|
|
|
|
case GlobalValue::DLLImportLinkage: return 5;
|
|
|
|
case GlobalValue::DLLExportLinkage: return 6;
|
|
|
|
case GlobalValue::ExternalWeakLinkage: return 7;
|
|
|
|
case GlobalValue::CommonLinkage: return 8;
|
|
|
|
case GlobalValue::PrivateLinkage: return 9;
|
|
|
|
case GlobalValue::WeakODRLinkage: return 10;
|
|
|
|
case GlobalValue::LinkOnceODRLinkage: return 11;
|
|
|
|
case GlobalValue::AvailableExternallyLinkage: return 12;
|
|
|
|
case GlobalValue::LinkerPrivateLinkage: return 13;
|
|
|
|
case GlobalValue::LinkerPrivateWeakLinkage: return 14;
|
|
|
|
case GlobalValue::LinkerPrivateWeakDefAutoLinkage: return 15;
|
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
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
// 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 the list of dependent libraries for the Module.
|
|
|
|
for (Module::lib_iterator I = M->lib_begin(), E = M->lib_end(); I != E; ++I)
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_DEPLIB, *I, 0/*TODO*/, Stream);
|
|
|
|
|
|
|
|
// Emit various pieces of data attached to a module.
|
|
|
|
if (!M->getTargetTriple().empty())
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_TRIPLE, M->getTargetTriple(),
|
|
|
|
0/*TODO*/, Stream);
|
|
|
|
if (!M->getDataLayout().empty())
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_DATALAYOUT, M->getDataLayout(),
|
|
|
|
0/*TODO*/, Stream);
|
|
|
|
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;
|
2007-04-22 06:24:45 +00:00
|
|
|
for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
|
|
|
|
GV != E; ++GV) {
|
2007-04-23 16:04:05 +00:00
|
|
|
MaxAlignment = std::max(MaxAlignment, GV->getAlignment());
|
2007-04-23 18:58:34 +00:00
|
|
|
MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV->getType()));
|
2011-08-12 16:45:18 +00:00
|
|
|
if (GV->hasSection()) {
|
|
|
|
// Give section names unique ID's.
|
|
|
|
unsigned &Entry = SectionMap[GV->getSection()];
|
|
|
|
if (!Entry) {
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_SECTIONNAME, GV->getSection(),
|
|
|
|
0/*TODO*/, Stream);
|
|
|
|
Entry = SectionMap.size();
|
|
|
|
}
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
|
|
|
for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
|
2007-04-23 16:04:05 +00:00
|
|
|
MaxAlignment = std::max(MaxAlignment, F->getAlignment());
|
2007-12-10 03:18:06 +00:00
|
|
|
if (F->hasSection()) {
|
|
|
|
// Give section names unique ID's.
|
|
|
|
unsigned &Entry = SectionMap[F->getSection()];
|
|
|
|
if (!Entry) {
|
|
|
|
WriteStringRecord(bitc::MODULE_CODE_SECTIONNAME, F->getSection(),
|
|
|
|
0/*TODO*/, Stream);
|
|
|
|
Entry = SectionMap.size();
|
|
|
|
}
|
|
|
|
}
|
2008-08-17 18:44:35 +00:00
|
|
|
if (F->hasGC()) {
|
|
|
|
// Same for GC names.
|
|
|
|
unsigned &Entry = GCMap[F->getGC()];
|
2007-12-10 03:18:06 +00:00
|
|
|
if (!Entry) {
|
2008-08-17 18:44:35 +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.
|
2008-05-15 20:49:28 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // 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;
|
|
|
|
for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
|
|
|
|
GV != E; ++GV) {
|
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,
|
|
|
|
// unnamed_addr]
|
2007-04-22 06:24:45 +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));
|
|
|
|
Vals.push_back(getEncodedLinkage(GV));
|
|
|
|
Vals.push_back(Log2_32(GV->getAlignment())+1);
|
|
|
|
Vals.push_back(GV->hasSection() ? SectionMap[GV->getSection()] : 0);
|
2009-09-20 02:20:51 +00:00
|
|
|
if (GV->isThreadLocal() ||
|
2011-01-08 16:42:36 +00:00
|
|
|
GV->getVisibility() != GlobalValue::DefaultVisibility ||
|
|
|
|
GV->hasUnnamedAddr()) {
|
2007-04-23 16:04:05 +00:00
|
|
|
Vals.push_back(getEncodedVisibility(GV));
|
|
|
|
Vals.push_back(GV->isThreadLocal());
|
2011-01-08 16:42:36 +00:00
|
|
|
Vals.push_back(GV->hasUnnamedAddr());
|
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.
|
|
|
|
for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
|
2011-12-07 23:57:55 +00:00
|
|
|
// FUNCTION: [type, callingconv, isproto, linkage, paramattrs, alignment,
|
|
|
|
// section, visibility, gc, unnamed_addr]
|
2007-04-22 06:24:45 +00:00
|
|
|
Vals.push_back(VE.getTypeID(F->getType()));
|
|
|
|
Vals.push_back(F->getCallingConv());
|
|
|
|
Vals.push_back(F->isDeclaration());
|
|
|
|
Vals.push_back(getEncodedLinkage(F));
|
2008-09-25 21:00:45 +00:00
|
|
|
Vals.push_back(VE.getAttributeID(F->getAttributes()));
|
2007-04-22 06:24:45 +00:00
|
|
|
Vals.push_back(Log2_32(F->getAlignment())+1);
|
|
|
|
Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0);
|
|
|
|
Vals.push_back(getEncodedVisibility(F));
|
2008-08-17 18:44:35 +00:00
|
|
|
Vals.push_back(F->hasGC() ? GCMap[F->getGC()] : 0);
|
2011-01-08 16:42:36 +00:00
|
|
|
Vals.push_back(F->hasUnnamedAddr());
|
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.
|
|
|
|
for (Module::const_alias_iterator AI = M->alias_begin(), E = M->alias_end();
|
|
|
|
AI != E; ++AI) {
|
2011-12-08 00:11:31 +00:00
|
|
|
// ALIAS: [alias type, aliasee val#, linkage, visibility]
|
2007-04-26 02:46:40 +00:00
|
|
|
Vals.push_back(VE.getTypeID(AI->getType()));
|
|
|
|
Vals.push_back(VE.getValueID(AI->getAliasee()));
|
|
|
|
Vals.push_back(getEncodedLinkage(AI));
|
2008-03-11 21:40:17 +00:00
|
|
|
Vals.push_back(getEncodedVisibility(AI));
|
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;
|
|
|
|
|
|
|
|
if (const OverflowingBinaryOperator *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;
|
2011-02-06 21:44:57 +00:00
|
|
|
} else if (const PossiblyExactOperator *PEO =
|
|
|
|
dyn_cast<PossiblyExactOperator>(V)) {
|
|
|
|
if (PEO->isExact())
|
|
|
|
Flags |= 1 << bitc::PEO_EXACT;
|
2009-07-20 21:19:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return Flags;
|
|
|
|
}
|
2007-04-22 06:24:45 +00:00
|
|
|
|
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,
|
|
|
|
SmallVector<uint64_t, 64> &Record) {
|
2009-12-31 01:22:29 +00:00
|
|
|
for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
|
|
|
|
if (N->getOperand(i)) {
|
|
|
|
Record.push_back(VE.getTypeID(N->getOperand(i)->getType()));
|
|
|
|
Record.push_back(VE.getValueID(N->getOperand(i)));
|
2009-08-04 05:01:35 +00:00
|
|
|
} else {
|
2009-08-13 21:58:54 +00:00
|
|
|
Record.push_back(VE.getTypeID(Type::getVoidTy(N->getContext())));
|
2009-08-04 05:01:35 +00:00
|
|
|
Record.push_back(0);
|
|
|
|
}
|
|
|
|
}
|
2011-06-17 17:56:00 +00:00
|
|
|
unsigned MDCode = N->isFunctionLocal() ? bitc::METADATA_FN_NODE :
|
|
|
|
bitc::METADATA_NODE;
|
2010-01-10 07:14:18 +00:00
|
|
|
Stream.EmitRecord(MDCode, Record, 0);
|
2009-08-04 05:01:35 +00:00
|
|
|
Record.clear();
|
|
|
|
}
|
2009-08-04 02:26:56 +00:00
|
|
|
|
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) {
|
2009-08-04 06:00:18 +00:00
|
|
|
const ValueEnumerator::ValueList &Vals = VE.getMDValues();
|
2009-08-04 05:01:35 +00:00
|
|
|
bool StartedMetadataBlock = false;
|
2009-07-29 18:15:02 +00:00
|
|
|
unsigned MDSAbbrev = 0;
|
|
|
|
SmallVector<uint64_t, 64> Record;
|
2009-08-04 05:01:35 +00:00
|
|
|
for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
if (const MDNode *N = dyn_cast<MDNode>(Vals[i].first)) {
|
2010-01-29 21:19:19 +00:00
|
|
|
if (!N->isFunctionLocal() || !N->getFunction()) {
|
2010-01-13 19:37:33 +00:00
|
|
|
if (!StartedMetadataBlock) {
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
|
|
|
StartedMetadataBlock = true;
|
|
|
|
}
|
|
|
|
WriteMDNode(N, VE, Stream, Record);
|
2009-08-04 05:01:35 +00:00
|
|
|
}
|
|
|
|
} else if (const MDString *MDS = dyn_cast<MDString>(Vals[i].first)) {
|
|
|
|
if (!StartedMetadataBlock) {
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-22 21:10:50 +00:00
|
|
|
// Abbrev for METADATA_STRING.
|
|
|
|
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
|
|
|
|
Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING));
|
2009-07-22 17:43:22 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
|
2009-07-22 21:10:50 +00:00
|
|
|
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
|
|
|
|
MDSAbbrev = Stream.EmitAbbrev(Abbv);
|
2009-08-04 05:01:35 +00:00
|
|
|
StartedMetadataBlock = true;
|
2009-07-29 18:15:02 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-29 18:15:02 +00:00
|
|
|
// Code: [strchar x N]
|
2009-10-19 05:51:03 +00:00
|
|
|
Record.append(MDS->begin(), MDS->end());
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2009-07-29 18:15:02 +00:00
|
|
|
// Emit the finished record.
|
2009-07-23 01:07:34 +00:00
|
|
|
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.
|
|
|
|
for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
|
|
|
|
E = M->named_metadata_end(); I != E; ++I) {
|
|
|
|
const NamedMDNode *NMD = I;
|
|
|
|
if (!StartedMetadataBlock) {
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
|
|
|
StartedMetadataBlock = true;
|
2009-07-29 18:15:02 +00:00
|
|
|
}
|
2010-07-21 23:38:33 +00:00
|
|
|
|
|
|
|
// Write name.
|
|
|
|
StringRef Str = NMD->getName();
|
|
|
|
for (unsigned i = 0, e = Str.size(); i != e; ++i)
|
|
|
|
Record.push_back(Str[i]);
|
|
|
|
Stream.EmitRecord(bitc::METADATA_NAME, Record, 0/*TODO*/);
|
|
|
|
Record.clear();
|
|
|
|
|
|
|
|
// Write named metadata operands.
|
|
|
|
for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
|
|
|
|
Record.push_back(VE.getValueID(NMD->getOperand(i)));
|
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
|
|
|
|
2009-08-04 05:01:35 +00:00
|
|
|
if (StartedMetadataBlock)
|
2009-09-18 19:26:43 +00:00
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
|
|
|
|
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;
|
2010-06-02 23:05:04 +00:00
|
|
|
const SmallVector<const MDNode *, 8> &Vals = VE.getFunctionLocalMDValues();
|
2010-01-14 19:38:44 +00:00
|
|
|
for (unsigned i = 0, e = Vals.size(); i != e; ++i)
|
2010-06-02 23:05:04 +00:00
|
|
|
if (const MDNode *N = Vals[i])
|
2010-01-29 21:19:19 +00:00
|
|
|
if (N->isFunctionLocal() && N->getFunction() == &F) {
|
2010-01-13 19:37:33 +00:00
|
|
|
if (!StartedMetadataBlock) {
|
|
|
|
Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
|
|
|
|
StartedMetadataBlock = true;
|
|
|
|
}
|
|
|
|
WriteMDNode(N, VE, Stream, Record);
|
|
|
|
}
|
2010-06-02 23:05:04 +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]]]
|
2009-12-28 23:41:32 +00:00
|
|
|
SmallVector<std::pair<unsigned, MDNode*>, 4> MDs;
|
|
|
|
|
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);
|
2009-12-28 23:41:32 +00:00
|
|
|
|
|
|
|
// If no metadata, ignore instruction.
|
|
|
|
if (MDs.empty()) continue;
|
|
|
|
|
|
|
|
Record.push_back(VE.getInstructionID(I));
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
|
|
|
|
Record.push_back(MDs[i].first);
|
|
|
|
Record.push_back(VE.getValueID(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]]
|
2009-12-28 20:10:43 +00:00
|
|
|
SmallVector<StringRef, 4> Names;
|
2009-12-29 09:01:33 +00:00
|
|
|
M->getMDKindNames(Names);
|
2009-12-28 20:10:43 +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);
|
|
|
|
|
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());
|
|
|
|
|
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
|
|
|
|
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();
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *LastTy = 0;
|
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()) |
|
2009-10-21 23:28:00 +00:00
|
|
|
unsigned(IA->isAlignStack()) << 1);
|
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)) {
|
|
|
|
if (IV->getBitWidth() <= 64) {
|
2010-08-03 16:57:03 +00:00
|
|
|
uint64_t V = IV->getSExtValue();
|
|
|
|
if ((int64_t)V >= 0)
|
2007-04-24 00:16:04 +00:00
|
|
|
Record.push_back(V << 1);
|
|
|
|
else
|
|
|
|
Record.push_back((-V << 1) | 1);
|
|
|
|
Code = bitc::CST_CODE_INTEGER;
|
2007-05-05 07:36:14 +00:00
|
|
|
AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
|
2007-04-24 00:16:04 +00:00
|
|
|
} else { // Wide integers, > 64 bits in size.
|
2009-09-20 02:20:51 +00:00
|
|
|
// We have an arbitrary precision integer value to write whose
|
|
|
|
// bit width is > 64. However, in canonical unsigned integer
|
2007-04-24 00:16:04 +00:00
|
|
|
// format it is likely that the high bits are going to be zero.
|
|
|
|
// So, we only write the number of active words.
|
2009-09-20 02:20:51 +00:00
|
|
|
unsigned NWords = IV->getValue().getActiveWords();
|
2007-04-24 00:16:04 +00:00
|
|
|
const uint64_t *RawWords = IV->getValue().getRawData();
|
|
|
|
for (unsigned i = 0; i != NWords; ++i) {
|
|
|
|
int64_t V = RawWords[i];
|
|
|
|
if (V >= 0)
|
|
|
|
Record.push_back(V << 1);
|
|
|
|
else
|
|
|
|
Record.push_back((-V << 1) | 1);
|
|
|
|
}
|
|
|
|
Code = bitc::CST_CODE_WIDE_INTEGER;
|
|
|
|
}
|
|
|
|
} 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);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (isCStrChar6)
|
|
|
|
AbbrevToUse = CString6Abbrev;
|
|
|
|
else if (isCStr7)
|
|
|
|
AbbrevToUse = CString7Abbrev;
|
|
|
|
} else if (const ConstantDataSequential *CDS =
|
|
|
|
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)));
|
|
|
|
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)));
|
|
|
|
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
|
|
|
|
/// type ID.
|
2009-01-16 18:40:27 +00:00
|
|
|
static bool PushValueAndType(const Value *V, unsigned InstID,
|
2009-09-20 02:20:51 +00:00
|
|
|
SmallVector<unsigned, 64> &Vals,
|
2007-05-06 00:00:00 +00:00
|
|
|
ValueEnumerator &VE) {
|
|
|
|
unsigned ValID = VE.getValueID(V);
|
|
|
|
Vals.push_back(ValID);
|
|
|
|
if (ValID >= InstID) {
|
|
|
|
Vals.push_back(VE.getTypeID(V->getType()));
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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,
|
2007-04-26 05:53:54 +00:00
|
|
|
SmallVector<unsigned, 64> &Vals) {
|
|
|
|
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;
|
2007-04-26 05:53:54 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1)));
|
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);
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(2)));
|
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);
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1)));
|
|
|
|
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);
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1)));
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(2)));
|
|
|
|
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);
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1)));
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(2)));
|
|
|
|
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);
|
2007-05-01 02:13:26 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1)));
|
|
|
|
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;
|
2009-10-27 19:13:16 +00:00
|
|
|
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)));
|
|
|
|
Vals.push_back(VE.getValueID(II.getCondition()));
|
|
|
|
}
|
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;
|
|
|
|
SwitchInst &SI = cast<SwitchInst>(I);
|
|
|
|
Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));
|
|
|
|
Vals.push_back(VE.getValueID(SI.getCondition()));
|
|
|
|
Vals.push_back(VE.getValueID(SI.getDefaultDest()));
|
|
|
|
for (unsigned i = 0, e = SI.getNumCases(); i != e; ++i) {
|
|
|
|
Vals.push_back(VE.getValueID(SI.getCaseValue(i)));
|
|
|
|
Vals.push_back(VE.getValueID(SI.getCaseSuccessor(i)));
|
|
|
|
}
|
|
|
|
}
|
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()));
|
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(i)));
|
|
|
|
break;
|
|
|
|
|
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)
|
2010-03-24 13:21:49 +00:00
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(i))); // 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;
|
2011-06-20 14:18:48 +00:00
|
|
|
Vals.push_back(VE.getTypeID(PN.getType()));
|
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
|
|
|
|
Vals.push_back(VE.getValueID(PN.getIncomingValue(i)));
|
|
|
|
Vals.push_back(VE.getValueID(PN.getIncomingBlock(i)));
|
|
|
|
}
|
2007-05-01 02:13:26 +00:00
|
|
|
break;
|
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;
|
|
|
|
}
|
|
|
|
|
2007-05-01 02:13:26 +00:00
|
|
|
case Instruction::Alloca:
|
|
|
|
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.
|
|
|
|
Vals.push_back(Log2_32(cast<AllocaInst>(I).getAlignment())+1);
|
|
|
|
break;
|
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
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(0))); // 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
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1))); // cmp.
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(2))); // newval.
|
|
|
|
Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());
|
|
|
|
Vals.push_back(GetEncodedOrdering(
|
|
|
|
cast<AtomicCmpXchgInst>(I).getOrdering()));
|
|
|
|
Vals.push_back(GetEncodedSynchScope(
|
|
|
|
cast<AtomicCmpXchgInst>(I).getSynchScope()));
|
|
|
|
break;
|
|
|
|
case Instruction::AtomicRMW:
|
|
|
|
Code = bitc::FUNC_CODE_INST_ATOMICRMW;
|
|
|
|
PushValueAndType(I.getOperand(0), InstID, Vals, VE); // ptrty + ptr
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(1))); // val.
|
|
|
|
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()));
|
|
|
|
Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()));
|
|
|
|
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.
|
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
|
2010-06-26 09:35:09 +00:00
|
|
|
Vals.push_back(VE.getValueID(CI.getArgOperand(i))); // 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
|
|
|
|
Vals.push_back(VE.getValueID(I.getOperand(0))); // valist.
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
DebugLoc LastDL;
|
|
|
|
|
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);
|
2010-04-03 02:17:50 +00:00
|
|
|
|
2009-12-28 23:41:32 +00:00
|
|
|
if (!I->getType()->isVoidTy())
|
2007-05-06 00:00:00 +00:00
|
|
|
++InstID;
|
2010-04-03 02:17:50 +00:00
|
|
|
|
|
|
|
// If the instruction has metadata, write a metadata attachment later.
|
|
|
|
NeedsMetadataAttachment |= I->hasMetadataOtherThanDebugLoc();
|
|
|
|
|
|
|
|
// 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());
|
|
|
|
|
|
|
|
Vals.push_back(DL.getLine());
|
|
|
|
Vals.push_back(DL.getCol());
|
|
|
|
Vals.push_back(Scope ? VE.getValueID(Scope)+1 : 0);
|
|
|
|
Vals.push_back(IA ? VE.getValueID(IA)+1 : 0);
|
2011-06-17 18:17:37 +00:00
|
|
|
Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
|
2010-04-03 02:17:50 +00:00
|
|
|
Vals.clear();
|
|
|
|
|
|
|
|
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);
|
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
|
|
|
|
// instances: CONSTANTS_BLOCK, FUNCTION_BLOCK and VALUE_SYMTAB_BLOCK. Other
|
|
|
|
// blocks can defined their abbrevs inline.
|
|
|
|
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();
|
|
|
|
}
|
|
|
|
|
2011-12-07 22:49:05 +00:00
|
|
|
// Sort the Users based on the order in which the reader parses the bitcode
|
|
|
|
// file.
|
|
|
|
static bool bitcodereader_order(const User *lhs, const User *rhs) {
|
|
|
|
// TODO: Implement.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void WriteUseList(const Value *V, const ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
|
|
|
|
// One or zero uses can't get out of order.
|
|
|
|
if (V->use_empty() || V->hasNUses(1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Make a copy of the in-memory use-list for sorting.
|
|
|
|
unsigned UseListSize = std::distance(V->use_begin(), V->use_end());
|
|
|
|
SmallVector<const User*, 8> UseList;
|
|
|
|
UseList.reserve(UseListSize);
|
|
|
|
for (Value::const_use_iterator I = V->use_begin(), E = V->use_end();
|
|
|
|
I != E; ++I) {
|
|
|
|
const User *U = *I;
|
|
|
|
UseList.push_back(U);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sort the copy based on the order read by the BitcodeReader.
|
|
|
|
std::sort(UseList.begin(), UseList.end(), bitcodereader_order);
|
|
|
|
|
|
|
|
// TODO: Generate a diff between the BitcodeWriter in-memory use-list and the
|
|
|
|
// sorted list (i.e., the expected BitcodeReader in-memory use-list).
|
|
|
|
|
|
|
|
// TODO: Emit the USELIST_CODE_ENTRYs.
|
|
|
|
}
|
|
|
|
|
|
|
|
static void WriteFunctionUseList(const Function *F, ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
VE.incorporateFunction(*F);
|
|
|
|
|
|
|
|
for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
|
|
|
|
AI != AE; ++AI)
|
|
|
|
WriteUseList(AI, VE, Stream);
|
|
|
|
for (Function::const_iterator BB = F->begin(), FE = F->end(); BB != FE;
|
|
|
|
++BB) {
|
|
|
|
WriteUseList(BB, VE, Stream);
|
|
|
|
for (BasicBlock::const_iterator II = BB->begin(), IE = BB->end(); II != IE;
|
|
|
|
++II) {
|
|
|
|
WriteUseList(II, VE, Stream);
|
|
|
|
for (User::const_op_iterator OI = II->op_begin(), E = II->op_end();
|
|
|
|
OI != E; ++OI) {
|
|
|
|
if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) ||
|
|
|
|
isa<InlineAsm>(*OI))
|
|
|
|
WriteUseList(*OI, VE, Stream);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
VE.purgeFunction();
|
|
|
|
}
|
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
// Emit use-lists.
|
|
|
|
static void WriteModuleUseLists(const Module *M, ValueEnumerator &VE,
|
|
|
|
BitstreamWriter &Stream) {
|
|
|
|
Stream.EnterSubblock(bitc::USELIST_BLOCK_ID, 3);
|
|
|
|
|
2011-12-07 22:49:05 +00:00
|
|
|
// XXX: this modifies the module, but in a way that should never change the
|
|
|
|
// behavior of any pass or codegen in LLVM. The problem is that GVs may
|
|
|
|
// contain entries in the use_list that do not exist in the Module and are
|
|
|
|
// not stored in the .bc file.
|
|
|
|
for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
|
|
|
|
I != E; ++I)
|
|
|
|
I->removeDeadConstantUsers();
|
|
|
|
|
|
|
|
// Write the global variables.
|
|
|
|
for (Module::const_global_iterator GI = M->global_begin(),
|
|
|
|
GE = M->global_end(); GI != GE; ++GI) {
|
|
|
|
WriteUseList(GI, VE, Stream);
|
|
|
|
|
|
|
|
// Write the global variable initializers.
|
|
|
|
if (GI->hasInitializer())
|
|
|
|
WriteUseList(GI->getInitializer(), VE, Stream);
|
|
|
|
}
|
2011-12-07 21:44:12 +00:00
|
|
|
|
2011-12-07 22:49:05 +00:00
|
|
|
// Write the functions.
|
|
|
|
for (Module::const_iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI) {
|
|
|
|
WriteUseList(FI, VE, Stream);
|
|
|
|
if (!FI->isDeclaration())
|
|
|
|
WriteFunctionUseList(FI, VE, Stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Write the aliases.
|
|
|
|
for (Module::const_alias_iterator AI = M->alias_begin(), AE = M->alias_end();
|
|
|
|
AI != AE; ++AI) {
|
|
|
|
WriteUseList(AI, VE, Stream);
|
|
|
|
WriteUseList(AI->getAliasee(), VE, Stream);
|
|
|
|
}
|
2011-12-07 21:44:12 +00:00
|
|
|
|
|
|
|
Stream.ExitBlock();
|
|
|
|
}
|
2007-04-26 03:27:58 +00:00
|
|
|
|
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
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Emit the version number if it is non-zero.
|
|
|
|
if (CurVersion) {
|
2007-04-26 03:27:58 +00:00
|
|
|
SmallVector<unsigned, 1> Vals;
|
|
|
|
Vals.push_back(CurVersion);
|
|
|
|
Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// Analyze the module, enumerating globals, functions, etc.
|
|
|
|
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
|
|
|
|
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
|
|
|
|
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
|
|
|
|
2011-12-07 21:44:12 +00:00
|
|
|
// Emit use-lists.
|
|
|
|
if (EnablePreserveUseListOrdering)
|
|
|
|
WriteModuleUseLists(M, VE, Stream);
|
|
|
|
|
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
|
|
|
|
};
|
|
|
|
|
2011-06-14 01:51:33 +00:00
|
|
|
static void EmitDarwinBCHeader(BitstreamWriter &Stream, 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.
|
|
|
|
unsigned BCOffset = DarwinBCHeaderSize;
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-07-09 05:14:23 +00:00
|
|
|
Stream.Emit(0x0B17C0DE, 32);
|
|
|
|
Stream.Emit(0 , 32); // Version.
|
|
|
|
Stream.Emit(BCOffset , 32);
|
|
|
|
Stream.Emit(0 , 32); // Filled in later.
|
|
|
|
Stream.Emit(CPUType , 32);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// EmitDarwinBCTrailer - Emit the darwin epilog after the bitcode file and
|
|
|
|
/// finalize the header.
|
|
|
|
static void EmitDarwinBCTrailer(BitstreamWriter &Stream, unsigned BufferSize) {
|
|
|
|
// Update the size field in the header.
|
|
|
|
Stream.BackpatchWord(DarwinBCSizeFieldOffset, BufferSize-DarwinBCHeaderSize);
|
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.
|
|
|
|
while (BufferSize & 15) {
|
|
|
|
Stream.Emit(0, 8);
|
|
|
|
++BufferSize;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-05-04 18:26:27 +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) {
|
2007-04-22 06:24:45 +00:00
|
|
|
std::vector<unsigned char> Buffer;
|
|
|
|
BitstreamWriter Stream(Buffer);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
Buffer.reserve(256*1024);
|
2008-12-19 18:37:59 +00:00
|
|
|
|
|
|
|
WriteBitcodeToStream( M, Stream );
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2008-12-19 18:37:59 +00:00
|
|
|
// Write the generated bitstream to "Out".
|
|
|
|
Out.write((char*)&Buffer.front(), Buffer.size());
|
|
|
|
}
|
|
|
|
|
|
|
|
/// WriteBitcodeToStream - Write the specified module to the specified output
|
|
|
|
/// stream.
|
|
|
|
void llvm::WriteBitcodeToStream(const Module *M, BitstreamWriter &Stream) {
|
2010-11-29 23:29:54 +00:00
|
|
|
// If this is darwin or another generic macho target, emit a file header and
|
|
|
|
// trailer if needed.
|
2011-06-14 01:51:33 +00:00
|
|
|
Triple TT(M->getTargetTriple());
|
|
|
|
if (TT.isOSDarwin())
|
|
|
|
EmitDarwinBCHeader(Stream, TT);
|
2009-09-20 02:20:51 +00:00
|
|
|
|
2007-04-22 06:24:45 +00:00
|
|
|
// 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())
|
2008-12-19 18:37:59 +00:00
|
|
|
EmitDarwinBCTrailer(Stream, Stream.getBuffer().size());
|
2007-04-22 06:24:45 +00:00
|
|
|
}
|