am fa5209a2: am 9c459f0c: Merge "Enable emission of debugger-friendly bitcode"
* commit 'fa5209a2bd1e10f675a889c60d8d5a589e860d18':
Enable emission of debugger-friendly bitcode
diff --git a/Android.mk b/Android.mk
index a783ba9..ba2915e 100644
--- a/Android.mk
+++ b/Android.mk
@@ -40,6 +40,7 @@
libLLVMipo \
libLLVMBitWriter \
libLLVMBitWriter_2_9 \
+ libLLVMBitWriter_2_9_func \
libLLVMBitReader \
libLLVMARMCodeGen \
libLLVMARMAsmPrinter \
diff --git a/BitWriter_2_9/BitcodeWriter.cpp b/BitWriter_2_9/BitcodeWriter.cpp
index c4f8e75..15bd108 100644
--- a/BitWriter_2_9/BitcodeWriter.cpp
+++ b/BitWriter_2_9/BitcodeWriter.cpp
@@ -40,6 +40,12 @@
#define FUNC_CODE_INST_CALL_2_7 22
#define FUNC_CODE_DEBUG_LOC_2_7 32
+// Redefine older bitcode opcodes for use here. Note that these come from
+// LLVM 2.7 - 3.0.
+#define TYPE_BLOCK_ID_OLD_3_0 10
+#define TYPE_SYMTAB_BLOCK_ID_OLD_3_0 13
+#define TYPE_CODE_STRUCT_OLD_3_0 10
+
/// 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 {
@@ -162,7 +168,7 @@
static void WriteTypeSymbolTable(const ValueEnumerator &VE,
BitstreamWriter &Stream) {
const ValueEnumerator::TypeList &TypeList = VE.getTypes();
- Stream.EnterSubblock(bitc::TYPE_SYMTAB_BLOCK_ID_OLD, 3);
+ Stream.EnterSubblock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0, 3);
// 7-bit fixed width VST_CODE_ENTRY strings.
BitCodeAbbrev *Abbv = new BitCodeAbbrev();
@@ -235,7 +241,7 @@
static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
const ValueEnumerator::TypeList &TypeList = VE.getTypes();
- Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_OLD, 4 /*count from # abbrevs */);
+ Stream.EnterSubblock(TYPE_BLOCK_ID_OLD_3_0, 4 /*count from # abbrevs */);
SmallVector<uint64_t, 64> TypeVals;
// Abbrev for TYPE_CODE_POINTER.
@@ -248,7 +254,7 @@
// Abbrev for TYPE_CODE_FUNCTION.
Abbv = new BitCodeAbbrev();
- Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION));
+ Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION_OLD));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg
Abbv->Add(BitCodeAbbrevOp(0)); // FIXME: DEAD value, remove in LLVM 3.0
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
@@ -285,7 +291,7 @@
// Abbrev for TYPE_CODE_STRUCT.
Abbv = new BitCodeAbbrev();
- Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_OLD));
+ Abbv->Add(BitCodeAbbrevOp(TYPE_CODE_STRUCT_OLD_3_0));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
@@ -340,7 +346,7 @@
case Type::FunctionTyID: {
FunctionType *FT = cast<FunctionType>(T);
// FUNCTION: [isvararg, attrid, retty, paramty x N]
- Code = bitc::TYPE_CODE_FUNCTION;
+ Code = bitc::TYPE_CODE_FUNCTION_OLD;
TypeVals.push_back(FT->isVarArg());
TypeVals.push_back(0); // FIXME: DEAD: remove in llvm 3.0
TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
diff --git a/BitWriter_2_9_func/Android.mk b/BitWriter_2_9_func/Android.mk
new file mode 100644
index 0000000..638c817
--- /dev/null
+++ b/BitWriter_2_9_func/Android.mk
@@ -0,0 +1,26 @@
+LOCAL_PATH:= $(call my-dir)
+
+LLVM_ROOT_PATH := $(LOCAL_PATH)/../../../../external/llvm
+include $(LLVM_ROOT_PATH)/llvm.mk
+
+LOCAL_CFLAGS += $(local_cflags_for_slang)
+
+bitcode_writer_2_9_func_SRC_FILES := \
+ BitcodeWriter.cpp \
+ BitcodeWriterPass.cpp \
+ ValueEnumerator.cpp
+
+# For the host
+# =====================================================
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := $(bitcode_writer_2_9_func_SRC_FILES)
+
+LOCAL_MODULE:= libLLVMBitWriter_2_9_func
+
+LOCAL_MODULE_TAGS := optional
+
+include $(LLVM_HOST_BUILD_MK)
+include $(LLVM_GEN_INTRINSICS_MK)
+include $(BUILD_HOST_STATIC_LIBRARY)
+
diff --git a/BitWriter_2_9_func/BitcodeWriter.cpp b/BitWriter_2_9_func/BitcodeWriter.cpp
new file mode 100644
index 0000000..68daddb
--- /dev/null
+++ b/BitWriter_2_9_func/BitcodeWriter.cpp
@@ -0,0 +1,1728 @@
+//===--- Bitcode/Writer/BitcodeWriter.cpp - Bitcode Writer ----------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Bitcode writer implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReaderWriter_2_9_func.h"
+#include "llvm/Bitcode/BitstreamWriter.h"
+#include "llvm/Bitcode/LLVMBitCodes.h"
+#include "ValueEnumerator.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/InlineAsm.h"
+#include "llvm/Instructions.h"
+#include "llvm/Module.h"
+#include "llvm/Operator.h"
+#include "llvm/ValueSymbolTable.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Program.h"
+#include <cctype>
+#include <map>
+using namespace llvm;
+
+/// 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,
+
+ // VALUE_SYMTAB_BLOCK abbrev id's.
+ VST_ENTRY_8_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
+ VST_ENTRY_7_ABBREV,
+ VST_ENTRY_6_ABBREV,
+ VST_BBENTRY_6_ABBREV,
+
+ // CONSTANTS_BLOCK abbrev id's.
+ CONSTANTS_SETTYPE_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
+ CONSTANTS_INTEGER_ABBREV,
+ CONSTANTS_CE_CAST_Abbrev,
+ CONSTANTS_NULL_Abbrev,
+
+ // FUNCTION_BLOCK abbrev id's.
+ FUNCTION_INST_LOAD_ABBREV = bitc::FIRST_APPLICATION_ABBREV,
+ FUNCTION_INST_BINOP_ABBREV,
+ FUNCTION_INST_BINOP_FLAGS_ABBREV,
+ FUNCTION_INST_CAST_ABBREV,
+ FUNCTION_INST_RET_VOID_ABBREV,
+ FUNCTION_INST_RET_VAL_ABBREV,
+ FUNCTION_INST_UNREACHABLE_ABBREV
+};
+
+static unsigned GetEncodedCastOpcode(unsigned Opcode) {
+ switch (Opcode) {
+ default: llvm_unreachable("Unknown cast instruction!");
+ 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) {
+ default: llvm_unreachable("Unknown binary instruction!");
+ 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;
+ 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;
+ }
+}
+
+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;
+ }
+}
+
+static unsigned GetEncodedOrdering(AtomicOrdering Ordering) {
+ switch (Ordering) {
+ default: llvm_unreachable("Unknown atomic 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;
+ }
+}
+
+static unsigned GetEncodedSynchScope(SynchronizationScope SynchScope) {
+ switch (SynchScope) {
+ default: llvm_unreachable("Unknown synchronization scope");
+ case SingleThread: return bitc::SYNCHSCOPE_SINGLETHREAD;
+ case CrossThread: return bitc::SYNCHSCOPE_CROSSTHREAD;
+ }
+}
+
+static void WriteStringRecord(unsigned Code, StringRef Str,
+ unsigned AbbrevToUse, BitstreamWriter &Stream) {
+ SmallVector<unsigned, 64> Vals;
+
+ // Code: [strchar x N]
+ for (unsigned i = 0, e = Str.size(); i != e; ++i) {
+ if (AbbrevToUse && !BitCodeAbbrevOp::isChar6(Str[i]))
+ AbbrevToUse = 0;
+ Vals.push_back(Str[i]);
+ }
+
+ // Emit the finished record.
+ Stream.EmitRecord(Code, Vals, AbbrevToUse);
+}
+
+// Emit information about parameter attributes.
+static void WriteAttributeTable(const ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ const std::vector<AttrListPtr> &Attrs = VE.getAttributes();
+ if (Attrs.empty()) return;
+
+ Stream.EnterSubblock(bitc::PARAMATTR_BLOCK_ID, 3);
+
+ SmallVector<uint64_t, 64> Record;
+ for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
+ const AttrListPtr &A = Attrs[i];
+ for (unsigned i = 0, e = A.getNumSlots(); i != e; ++i) {
+ const AttributeWithIndex &PAWI = A.getSlot(i);
+ Record.push_back(PAWI.Index);
+
+ // 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.
+ uint64_t FauxAttr = PAWI.Attrs & 0xffff;
+ if (PAWI.Attrs & Attribute::Alignment)
+ FauxAttr |= (1ull<<16)<<(((PAWI.Attrs & Attribute::Alignment)-1) >> 16);
+ FauxAttr |= (PAWI.Attrs & (0x3FFull << 21)) << 11;
+
+ Record.push_back(FauxAttr);
+ }
+
+ Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record);
+ Record.clear();
+ }
+
+ Stream.ExitBlock();
+}
+
+/// WriteTypeTable - Write out the type table for a module.
+static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
+ const ValueEnumerator::TypeList &TypeList = VE.getTypes();
+
+ Stream.EnterSubblock(bitc::TYPE_BLOCK_ID_NEW, 4 /*count from # abbrevs */);
+ SmallVector<uint64_t, 64> TypeVals;
+
+ // Abbrev for TYPE_CODE_POINTER.
+ BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_POINTER));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(VE.getTypes().size()+1)));
+ Abbv->Add(BitCodeAbbrevOp(0)); // Addrspace = 0
+ unsigned PtrAbbrev = Stream.EmitAbbrev(Abbv);
+
+ // Abbrev for TYPE_CODE_FUNCTION.
+ Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_FUNCTION_OLD));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isvararg
+ Abbv->Add(BitCodeAbbrevOp(0)); // FIXME: DEAD value, remove in LLVM 3.0
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(VE.getTypes().size()+1)));
+ unsigned FunctionAbbrev = Stream.EmitAbbrev(Abbv);
+
+ // 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));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(VE.getTypes().size()+1)));
+ 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.
+ Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_STRUCT_NAMED));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ispacked
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(VE.getTypes().size()+1)));
+ unsigned StructNamedAbbrev = Stream.EmitAbbrev(Abbv);
+
+ // Abbrev for TYPE_CODE_ARRAY.
+ Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::TYPE_CODE_ARRAY));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 8)); // size
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(VE.getTypes().size()+1)));
+ unsigned ArrayAbbrev = Stream.EmitAbbrev(Abbv);
+
+ // Emit an entry count so the reader can reserve space.
+ TypeVals.push_back(TypeList.size());
+ Stream.EmitRecord(bitc::TYPE_CODE_NUMENTRY, TypeVals);
+ TypeVals.clear();
+
+ // Loop over all of the types, emitting each in turn.
+ for (unsigned i = 0, e = TypeList.size(); i != e; ++i) {
+ Type *T = TypeList[i];
+ int AbbrevToUse = 0;
+ unsigned Code = 0;
+
+ switch (T->getTypeID()) {
+ default: llvm_unreachable("Unknown type!");
+ case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break;
+ case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break;
+ case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
+ case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
+ case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
+ case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
+ 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;
+ case Type::IntegerTyID:
+ // INTEGER: [width]
+ Code = bitc::TYPE_CODE_INTEGER;
+ TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
+ break;
+ case Type::PointerTyID: {
+ PointerType *PTy = cast<PointerType>(T);
+ // POINTER: [pointee type, address space]
+ Code = bitc::TYPE_CODE_POINTER;
+ TypeVals.push_back(VE.getTypeID(PTy->getElementType()));
+ unsigned AddressSpace = PTy->getAddressSpace();
+ TypeVals.push_back(AddressSpace);
+ if (AddressSpace == 0) AbbrevToUse = PtrAbbrev;
+ break;
+ }
+ case Type::FunctionTyID: {
+ FunctionType *FT = cast<FunctionType>(T);
+ // FUNCTION: [isvararg, attrid, retty, paramty x N]
+ Code = bitc::TYPE_CODE_FUNCTION_OLD;
+ TypeVals.push_back(FT->isVarArg());
+ TypeVals.push_back(0); // FIXME: DEAD: remove in llvm 3.0
+ 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)));
+ AbbrevToUse = FunctionAbbrev;
+ break;
+ }
+ case Type::StructTyID: {
+ StructType *ST = cast<StructType>(T);
+ // STRUCT: [ispacked, eltty x N]
+ TypeVals.push_back(ST->isPacked());
+ // Output all of the element types.
+ for (StructType::element_iterator I = ST->element_begin(),
+ E = ST->element_end(); I != E; ++I)
+ TypeVals.push_back(VE.getTypeID(*I));
+
+ if (ST->isLiteral()) {
+ 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);
+ }
+ break;
+ }
+ case Type::ArrayTyID: {
+ ArrayType *AT = cast<ArrayType>(T);
+ // ARRAY: [numelts, eltty]
+ Code = bitc::TYPE_CODE_ARRAY;
+ TypeVals.push_back(AT->getNumElements());
+ TypeVals.push_back(VE.getTypeID(AT->getElementType()));
+ AbbrevToUse = ArrayAbbrev;
+ break;
+ }
+ case Type::VectorTyID: {
+ VectorType *VT = cast<VectorType>(T);
+ // 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();
+ }
+
+ Stream.ExitBlock();
+}
+
+static unsigned getEncodedLinkage(const GlobalValue *GV) {
+ switch (GV->getLinkage()) {
+ default: llvm_unreachable("Invalid linkage!");
+ 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;
+ }
+}
+
+static unsigned getEncodedVisibility(const GlobalValue *GV) {
+ switch (GV->getVisibility()) {
+ default: llvm_unreachable("Invalid visibility!");
+ case GlobalValue::DefaultVisibility: return 0;
+ case GlobalValue::HiddenVisibility: return 1;
+ case GlobalValue::ProtectedVisibility: return 2;
+ }
+}
+
+// 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);
+
+ // Emit information about sections and GC, computing how many there are. Also
+ // compute the maximum alignment value.
+ std::map<std::string, unsigned> SectionMap;
+ std::map<std::string, unsigned> GCMap;
+ unsigned MaxAlignment = 0;
+ unsigned MaxGlobalType = 0;
+ for (Module::const_global_iterator GV = M->global_begin(),E = M->global_end();
+ GV != E; ++GV) {
+ MaxAlignment = std::max(MaxAlignment, GV->getAlignment());
+ MaxGlobalType = std::max(MaxGlobalType, VE.getTypeID(GV->getType()));
+ 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();
+ }
+ }
+ }
+ for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
+ MaxAlignment = std::max(MaxAlignment, F->getAlignment());
+ 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();
+ }
+ }
+ if (F->hasGC()) {
+ // Same for GC names.
+ unsigned &Entry = GCMap[F->getGC()];
+ if (!Entry) {
+ WriteStringRecord(bitc::MODULE_CODE_GCNAME, F->getGC(),
+ 0/*TODO*/, Stream);
+ Entry = GCMap.size();
+ }
+ }
+ }
+
+ // Emit abbrev for globals, now that we know # sections and max alignment.
+ unsigned SimpleGVarAbbrev = 0;
+ if (!M->global_empty()) {
+ // Add an abbrev for common globals with no visibility or thread localness.
+ BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::MODULE_CODE_GLOBALVAR));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(MaxGlobalType+1)));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Constant.
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Initializer.
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 4)); // Linkage.
+ if (MaxAlignment == 0) // Alignment.
+ Abbv->Add(BitCodeAbbrevOp(0));
+ else {
+ unsigned MaxEncAlignment = Log2_32(MaxAlignment)+1;
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(MaxEncAlignment+1)));
+ }
+ if (SectionMap.empty()) // Section.
+ Abbv->Add(BitCodeAbbrevOp(0));
+ else
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed,
+ Log2_32_Ceil(SectionMap.size()+1)));
+ // Don't bother emitting vis + thread local.
+ SimpleGVarAbbrev = Stream.EmitAbbrev(Abbv);
+ }
+
+ // 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) {
+ unsigned AbbrevToUse = 0;
+
+ // GLOBALVAR: [type, isconst, initid,
+ // linkage, alignment, section, visibility, threadlocal,
+ // unnamed_addr]
+ 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);
+ if (GV->isThreadLocal() ||
+ GV->getVisibility() != GlobalValue::DefaultVisibility ||
+ GV->hasUnnamedAddr()) {
+ Vals.push_back(getEncodedVisibility(GV));
+ Vals.push_back(GV->isThreadLocal());
+ Vals.push_back(GV->hasUnnamedAddr());
+ } else {
+ AbbrevToUse = SimpleGVarAbbrev;
+ }
+
+ 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) {
+ // FUNCTION: [type, callingconv, isproto, paramattr,
+ // linkage, alignment, section, visibility, gc, unnamed_addr]
+ Vals.push_back(VE.getTypeID(F->getType()));
+ Vals.push_back(F->getCallingConv());
+ Vals.push_back(F->isDeclaration());
+ Vals.push_back(getEncodedLinkage(F));
+ Vals.push_back(VE.getAttributeID(F->getAttributes()));
+ Vals.push_back(Log2_32(F->getAlignment())+1);
+ Vals.push_back(F->hasSection() ? SectionMap[F->getSection()] : 0);
+ Vals.push_back(getEncodedVisibility(F));
+ Vals.push_back(F->hasGC() ? GCMap[F->getGC()] : 0);
+ Vals.push_back(F->hasUnnamedAddr());
+
+ unsigned AbbrevToUse = 0;
+ Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
+ Vals.clear();
+ }
+
+ // Emit the alias information.
+ for (Module::const_alias_iterator AI = M->alias_begin(), E = M->alias_end();
+ AI != E; ++AI) {
+ Vals.push_back(VE.getTypeID(AI->getType()));
+ Vals.push_back(VE.getValueID(AI->getAliasee()));
+ Vals.push_back(getEncodedLinkage(AI));
+ Vals.push_back(getEncodedVisibility(AI));
+ unsigned AbbrevToUse = 0;
+ Stream.EmitRecord(bitc::MODULE_CODE_ALIAS, Vals, AbbrevToUse);
+ Vals.clear();
+ }
+}
+
+static uint64_t GetOptimizationFlags(const Value *V) {
+ uint64_t Flags = 0;
+
+ if (const OverflowingBinaryOperator *OBO =
+ dyn_cast<OverflowingBinaryOperator>(V)) {
+ if (OBO->hasNoSignedWrap())
+ Flags |= 1 << bitc::OBO_NO_SIGNED_WRAP;
+ if (OBO->hasNoUnsignedWrap())
+ Flags |= 1 << bitc::OBO_NO_UNSIGNED_WRAP;
+ } else if (const PossiblyExactOperator *PEO =
+ dyn_cast<PossiblyExactOperator>(V)) {
+ if (PEO->isExact())
+ Flags |= 1 << bitc::PEO_EXACT;
+ }
+
+ return Flags;
+}
+
+static void WriteMDNode(const MDNode *N,
+ const ValueEnumerator &VE,
+ BitstreamWriter &Stream,
+ SmallVector<uint64_t, 64> &Record) {
+ 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)));
+ } else {
+ Record.push_back(VE.getTypeID(Type::getVoidTy(N->getContext())));
+ Record.push_back(0);
+ }
+ }
+ unsigned MDCode = N->isFunctionLocal() ? bitc::METADATA_FN_NODE :
+ bitc::METADATA_NODE;
+ Stream.EmitRecord(MDCode, Record, 0);
+ Record.clear();
+}
+
+static void WriteModuleMetadata(const Module *M,
+ const ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ const ValueEnumerator::ValueList &Vals = VE.getMDValues();
+ bool StartedMetadataBlock = false;
+ unsigned MDSAbbrev = 0;
+ SmallVector<uint64_t, 64> Record;
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
+
+ if (const MDNode *N = dyn_cast<MDNode>(Vals[i].first)) {
+ if (!N->isFunctionLocal() || !N->getFunction()) {
+ if (!StartedMetadataBlock) {
+ Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
+ StartedMetadataBlock = true;
+ }
+ WriteMDNode(N, VE, Stream, Record);
+ }
+ } else if (const MDString *MDS = dyn_cast<MDString>(Vals[i].first)) {
+ if (!StartedMetadataBlock) {
+ Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
+
+ // Abbrev for METADATA_STRING.
+ BitCodeAbbrev *Abbv = new BitCodeAbbrev();
+ Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_STRING));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Array));
+ Abbv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 8));
+ MDSAbbrev = Stream.EmitAbbrev(Abbv);
+ StartedMetadataBlock = true;
+ }
+
+ // Code: [strchar x N]
+ Record.append(MDS->begin(), MDS->end());
+
+ // Emit the finished record.
+ Stream.EmitRecord(bitc::METADATA_STRING, Record, MDSAbbrev);
+ Record.clear();
+ }
+ }
+
+ // 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;
+ }
+
+ // 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)));
+ Stream.EmitRecord(bitc::METADATA_NAMED_NODE, Record, 0);
+ Record.clear();
+ }
+
+ if (StartedMetadataBlock)
+ Stream.ExitBlock();
+}
+
+static void WriteFunctionLocalMetadata(const Function &F,
+ const ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ bool StartedMetadataBlock = false;
+ SmallVector<uint64_t, 64> Record;
+ const SmallVector<const MDNode *, 8> &Vals = VE.getFunctionLocalMDValues();
+ for (unsigned i = 0, e = Vals.size(); i != e; ++i)
+ if (const MDNode *N = Vals[i])
+ if (N->isFunctionLocal() && N->getFunction() == &F) {
+ if (!StartedMetadataBlock) {
+ Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
+ StartedMetadataBlock = true;
+ }
+ WriteMDNode(N, VE, Stream, Record);
+ }
+
+ if (StartedMetadataBlock)
+ Stream.ExitBlock();
+}
+
+static void WriteMetadataAttachment(const Function &F,
+ const ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ Stream.EnterSubblock(bitc::METADATA_ATTACHMENT_ID, 3);
+
+ SmallVector<uint64_t, 64> Record;
+
+ // Write metadata attachments
+ // METADATA_ATTACHMENT - [m x [value, [n x [id, mdnode]]]
+ SmallVector<std::pair<unsigned, MDNode*>, 4> MDs;
+
+ 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) {
+ MDs.clear();
+ I->getAllMetadataOtherThanDebugLoc(MDs);
+
+ // 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));
+ }
+ Stream.EmitRecord(bitc::METADATA_ATTACHMENT, Record, 0);
+ Record.clear();
+ }
+
+ Stream.ExitBlock();
+}
+
+static void WriteModuleMetadataStore(const Module *M, BitstreamWriter &Stream) {
+ SmallVector<uint64_t, 64> Record;
+
+ // Write metadata kinds
+ // METADATA_KIND - [n x [id, name]]
+ SmallVector<StringRef, 4> Names;
+ M->getMDKindNames(Names);
+
+ if (Names.empty()) return;
+
+ Stream.EnterSubblock(bitc::METADATA_BLOCK_ID, 3);
+
+ for (unsigned MDKindID = 0, e = Names.size(); MDKindID != e; ++MDKindID) {
+ Record.push_back(MDKindID);
+ StringRef KName = Names[MDKindID];
+ Record.append(KName.begin(), KName.end());
+
+ Stream.EmitRecord(bitc::METADATA_KIND, Record, 0);
+ Record.clear();
+ }
+
+ Stream.ExitBlock();
+}
+
+static void WriteConstants(unsigned FirstVal, unsigned LastVal,
+ const ValueEnumerator &VE,
+ BitstreamWriter &Stream, bool isGlobal) {
+ if (FirstVal == LastVal) return;
+
+ Stream.EnterSubblock(bitc::CONSTANTS_BLOCK_ID, 4);
+
+ 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);
+
+ // 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);
+ }
+
+ SmallVector<uint64_t, 64> Record;
+
+ const ValueEnumerator::ValueList &Vals = VE.getValues();
+ Type *LastTy = 0;
+ for (unsigned i = FirstVal; i != LastVal; ++i) {
+ const Value *V = Vals[i].first;
+ // If we need to switch types, do so now.
+ if (V->getType() != LastTy) {
+ LastTy = V->getType();
+ Record.push_back(VE.getTypeID(LastTy));
+ Stream.EmitRecord(bitc::CST_CODE_SETTYPE, Record,
+ CONSTANTS_SETTYPE_ABBREV);
+ Record.clear();
+ }
+
+ if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
+ Record.push_back(unsigned(IA->hasSideEffects()) |
+ unsigned(IA->isAlignStack()) << 1);
+
+ // 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]);
+
+ // 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();
+ 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) {
+ uint64_t V = IV->getSExtValue();
+ if ((int64_t)V >= 0)
+ Record.push_back(V << 1);
+ else
+ Record.push_back((-V << 1) | 1);
+ Code = bitc::CST_CODE_INTEGER;
+ AbbrevToUse = CONSTANTS_INTEGER_ABBREV;
+ } else { // Wide integers, > 64 bits in size.
+ // We have an arbitrary precision integer value to write whose
+ // bit width is > 64. However, in canonical unsigned integer
+ // format it is likely that the high bits are going to be zero.
+ // So, we only write the number of active words.
+ unsigned NWords = IV->getValue().getActiveWords();
+ const uint64_t *RawWords = IV->getValue().getRawData();
+ for (unsigned i = 0; i != NWords; ++i) {
+ 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;
+ Type *Ty = CFP->getType();
+ if (Ty->isFloatTy() || Ty->isDoubleTy()) {
+ Record.push_back(CFP->getValueAPF().bitcastToAPInt().getZExtValue());
+ } else if (Ty->isX86_FP80Ty()) {
+ // api needed to prevent premature destruction
+ // bits are not in the same order as a normal i80 APInt, compensate.
+ APInt api = CFP->getValueAPF().bitcastToAPInt();
+ const uint64_t *p = api.getRawData();
+ Record.push_back((p[1] << 48) | (p[0] >> 16));
+ Record.push_back(p[0] & 0xffffLL);
+ } else if (Ty->isFP128Ty() || Ty->isPPC_FP128Ty()) {
+ APInt api = CFP->getValueAPF().bitcastToAPInt();
+ const uint64_t *p = api.getRawData();
+ Record.push_back(p[0]);
+ Record.push_back(p[1]);
+ } else {
+ assert (0 && "Unknown FP type!");
+ }
+ } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+ const ConstantArray *CA = cast<ConstantArray>(C);
+ // Emit constant strings specially.
+ unsigned NumOps = CA->getNumOperands();
+ // If this is a null-terminated string, use the denser CSTRING encoding.
+ if (CA->getOperand(NumOps-1)->isNullValue()) {
+ Code = bitc::CST_CODE_CSTRING;
+ --NumOps; // 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 != NumOps; ++i) {
+ unsigned char V = cast<ConstantInt>(CA->getOperand(i))->getZExtValue();
+ 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 (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
+ isa<ConstantVector>(V)) {
+ Code = bitc::CST_CODE_AGGREGATE;
+ for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
+ Record.push_back(VE.getValueID(C->getOperand(i)));
+ AbbrevToUse = AggregateAbbrev;
+ } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
+ 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)));
+ AbbrevToUse = CONSTANTS_CE_CAST_Abbrev;
+ } 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)));
+ uint64_t Flags = GetOptimizationFlags(CE);
+ if (Flags != 0)
+ Record.push_back(Flags);
+ }
+ break;
+ case Instruction::GetElementPtr:
+ Code = bitc::CST_CODE_CE_GEP;
+ if (cast<GEPOperator>(C)->isInBounds())
+ Code = bitc::CST_CODE_CE_INBOUNDS_GEP;
+ 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:
+ // 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()));
+ }
+ 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:
+ Code = bitc::CST_CODE_CE_CMP;
+ 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;
+ }
+ } 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()));
+ } else {
+#ifndef NDEBUG
+ C->dump();
+#endif
+ llvm_unreachable("Unknown constant!");
+ }
+ Stream.EmitRecord(Code, Record, AbbrevToUse);
+ Record.clear();
+ }
+
+ Stream.ExitBlock();
+}
+
+static void WriteModuleConstants(const ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ const ValueEnumerator::ValueList &Vals = VE.getValues();
+
+ // 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)) {
+ WriteConstants(i, Vals.size(), VE, Stream, true);
+ return;
+ }
+ }
+}
+
+/// 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.
+static bool PushValueAndType(const Value *V, unsigned InstID,
+ SmallVector<unsigned, 64> &Vals,
+ 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;
+}
+
+/// WriteInstruction - Emit an instruction to the specified stream.
+static void WriteInstruction(const Instruction &I, unsigned InstID,
+ ValueEnumerator &VE, BitstreamWriter &Stream,
+ SmallVector<unsigned, 64> &Vals) {
+ unsigned Code = 0;
+ unsigned AbbrevToUse = 0;
+ VE.setInstructionID(&I);
+ switch (I.getOpcode()) {
+ default:
+ if (Instruction::isCast(I.getOpcode())) {
+ Code = bitc::FUNC_CODE_INST_CAST;
+ if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE))
+ AbbrevToUse = FUNCTION_INST_CAST_ABBREV;
+ Vals.push_back(VE.getTypeID(I.getType()));
+ Vals.push_back(GetEncodedCastOpcode(I.getOpcode()));
+ } else {
+ assert(isa<BinaryOperator>(I) && "Unknown instruction!");
+ Code = bitc::FUNC_CODE_INST_BINOP;
+ if (!PushValueAndType(I.getOperand(0), InstID, Vals, VE))
+ AbbrevToUse = FUNCTION_INST_BINOP_ABBREV;
+ Vals.push_back(VE.getValueID(I.getOperand(1)));
+ Vals.push_back(GetEncodedBinaryOpcode(I.getOpcode()));
+ uint64_t Flags = GetOptimizationFlags(&I);
+ if (Flags != 0) {
+ if (AbbrevToUse == FUNCTION_INST_BINOP_ABBREV)
+ AbbrevToUse = FUNCTION_INST_BINOP_FLAGS_ABBREV;
+ Vals.push_back(Flags);
+ }
+ }
+ break;
+
+ case Instruction::GetElementPtr:
+ Code = bitc::FUNC_CODE_INST_GEP;
+ if (cast<GEPOperator>(&I)->isInBounds())
+ Code = bitc::FUNC_CODE_INST_INBOUNDS_GEP;
+ for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
+ PushValueAndType(I.getOperand(i), InstID, Vals, VE);
+ break;
+ case Instruction::ExtractValue: {
+ Code = bitc::FUNC_CODE_INST_EXTRACTVAL;
+ 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);
+ break;
+ }
+ case Instruction::InsertValue: {
+ Code = bitc::FUNC_CODE_INST_INSERTVAL;
+ 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);
+ break;
+ }
+ case Instruction::Select:
+ Code = bitc::FUNC_CODE_INST_VSELECT;
+ PushValueAndType(I.getOperand(1), InstID, Vals, VE);
+ Vals.push_back(VE.getValueID(I.getOperand(2)));
+ PushValueAndType(I.getOperand(0), InstID, Vals, VE);
+ break;
+ case Instruction::ExtractElement:
+ Code = bitc::FUNC_CODE_INST_EXTRACTELT;
+ PushValueAndType(I.getOperand(0), InstID, Vals, VE);
+ Vals.push_back(VE.getValueID(I.getOperand(1)));
+ break;
+ case Instruction::InsertElement:
+ Code = bitc::FUNC_CODE_INST_INSERTELT;
+ PushValueAndType(I.getOperand(0), InstID, Vals, VE);
+ 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;
+ PushValueAndType(I.getOperand(0), InstID, Vals, VE);
+ Vals.push_back(VE.getValueID(I.getOperand(1)));
+ Vals.push_back(VE.getValueID(I.getOperand(2)));
+ break;
+ case Instruction::ICmp:
+ case Instruction::FCmp:
+ // compare returning Int1Ty or vector of Int1Ty
+ Code = bitc::FUNC_CODE_INST_CMP2;
+ PushValueAndType(I.getOperand(0), InstID, Vals, VE);
+ Vals.push_back(VE.getValueID(I.getOperand(1)));
+ Vals.push_back(cast<CmpInst>(I).getPredicate());
+ break;
+
+ case Instruction::Ret:
+ {
+ 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);
+ }
+ }
+ break;
+ case Instruction::Br:
+ {
+ Code = bitc::FUNC_CODE_INST_BR;
+ BranchInst &II = cast<BranchInst>(I);
+ 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()));
+ }
+ }
+ break;
+ case Instruction::Switch:
+ Code = bitc::FUNC_CODE_INST_SWITCH;
+ 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;
+ case Instruction::IndirectBr:
+ Code = bitc::FUNC_CODE_INST_INDIRECTBR;
+ 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;
+
+ case Instruction::Invoke: {
+ const InvokeInst *II = cast<InvokeInst>(&I);
+ const Value *Callee(II->getCalledValue());
+ PointerType *PTy = cast<PointerType>(Callee->getType());
+ FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
+ Code = bitc::FUNC_CODE_INST_INVOKE;
+
+ Vals.push_back(VE.getAttributeID(II->getAttributes()));
+ Vals.push_back(II->getCallingConv());
+ Vals.push_back(VE.getValueID(II->getNormalDest()));
+ Vals.push_back(VE.getValueID(II->getUnwindDest()));
+ PushValueAndType(Callee, InstID, Vals, VE);
+
+ // Emit value #'s for the fixed parameters.
+ for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
+ Vals.push_back(VE.getValueID(I.getOperand(i))); // fixed param.
+
+ // Emit type/value pairs for varargs params.
+ if (FTy->isVarArg()) {
+ for (unsigned i = FTy->getNumParams(), e = I.getNumOperands()-3;
+ i != e; ++i)
+ PushValueAndType(I.getOperand(i), InstID, Vals, VE); // vararg
+ }
+ break;
+ }
+ case Instruction::Resume:
+ Code = bitc::FUNC_CODE_INST_RESUME;
+ PushValueAndType(I.getOperand(0), InstID, Vals, VE);
+ break;
+ case Instruction::Unwind:
+ Code = bitc::FUNC_CODE_INST_UNWIND;
+ break;
+ case Instruction::Unreachable:
+ Code = bitc::FUNC_CODE_INST_UNREACHABLE;
+ AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
+ break;
+
+ case Instruction::PHI: {
+ const PHINode &PN = cast<PHINode>(I);
+ Code = bitc::FUNC_CODE_INST_PHI;
+ 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)));
+ }
+ break;
+ }
+
+ 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;
+ }
+
+ case Instruction::Alloca:
+ Code = bitc::FUNC_CODE_INST_ALLOCA;
+ Vals.push_back(VE.getTypeID(I.getType()));
+ Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
+ Vals.push_back(VE.getValueID(I.getOperand(0))); // size.
+ Vals.push_back(Log2_32(cast<AllocaInst>(I).getAlignment())+1);
+ break;
+
+ case Instruction::Load:
+ 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;
+ }
+ Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);
+ Vals.push_back(cast<LoadInst>(I).isVolatile());
+ if (cast<LoadInst>(I).isAtomic()) {
+ Vals.push_back(GetEncodedOrdering(cast<LoadInst>(I).getOrdering()));
+ Vals.push_back(GetEncodedSynchScope(cast<LoadInst>(I).getSynchScope()));
+ }
+ break;
+ case Instruction::Store:
+ if (cast<StoreInst>(I).isAtomic())
+ Code = bitc::FUNC_CODE_INST_STOREATOMIC;
+ else
+ Code = bitc::FUNC_CODE_INST_STORE;
+ PushValueAndType(I.getOperand(1), InstID, Vals, VE); // ptrty + ptr
+ Vals.push_back(VE.getValueID(I.getOperand(0))); // val.
+ Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
+ Vals.push_back(cast<StoreInst>(I).isVolatile());
+ if (cast<StoreInst>(I).isAtomic()) {
+ Vals.push_back(GetEncodedOrdering(cast<StoreInst>(I).getOrdering()));
+ Vals.push_back(GetEncodedSynchScope(cast<StoreInst>(I).getSynchScope()));
+ }
+ break;
+ 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;
+ 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;
+ case Instruction::Call: {
+ const CallInst &CI = cast<CallInst>(I);
+ PointerType *PTy = cast<PointerType>(CI.getCalledValue()->getType());
+ FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
+
+ Code = bitc::FUNC_CODE_INST_CALL;
+
+ Vals.push_back(VE.getAttributeID(CI.getAttributes()));
+ Vals.push_back((CI.getCallingConv() << 1) | unsigned(CI.isTailCall()));
+ PushValueAndType(CI.getCalledValue(), InstID, Vals, VE); // Callee
+
+ // Emit value #'s for the fixed parameters.
+ for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
+ Vals.push_back(VE.getValueID(CI.getArgOperand(i))); // fixed param.
+
+ // Emit type/value pairs for varargs params.
+ if (FTy->isVarArg()) {
+ for (unsigned i = FTy->getNumParams(), e = CI.getNumArgOperands();
+ i != e; ++i)
+ PushValueAndType(CI.getArgOperand(i), InstID, Vals, VE); // varargs
+ }
+ break;
+ }
+ 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;
+ }
+
+ Stream.EmitRecord(Code, Vals, AbbrevToUse);
+ Vals.clear();
+}
+
+// Emit names for globals/functions etc.
+static void WriteValueSymbolTable(const ValueSymbolTable &VST,
+ const ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ if (VST.empty()) return;
+ Stream.EnterSubblock(bitc::VALUE_SYMTAB_BLOCK_ID, 4);
+
+ // 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;
+
+ for (ValueSymbolTable::const_iterator SI = VST.begin(), SE = VST.end();
+ SI != SE; ++SI) {
+
+ const ValueName &Name = *SI;
+
+ // Figure out the encoding to use for the name.
+ bool is7Bit = true;
+ bool isChar6 = true;
+ for (const char *C = Name.getKeyData(), *E = C+Name.getKeyLength();
+ C != E; ++C) {
+ if (isChar6)
+ isChar6 = BitCodeAbbrevOp::isChar6(*C);
+ if ((unsigned char)*C & 128) {
+ is7Bit = false;
+ break; // don't bother scanning the rest.
+ }
+ }
+
+ unsigned AbbrevToUse = VST_ENTRY_8_ABBREV;
+
+ // VST_ENTRY: [valueid, namechar x N]
+ // VST_BBENTRY: [bbid, namechar x N]
+ unsigned Code;
+ if (isa<BasicBlock>(SI->getValue())) {
+ Code = bitc::VST_CODE_BBENTRY;
+ if (isChar6)
+ AbbrevToUse = VST_BBENTRY_6_ABBREV;
+ } else {
+ Code = bitc::VST_CODE_ENTRY;
+ if (isChar6)
+ AbbrevToUse = VST_ENTRY_6_ABBREV;
+ else if (is7Bit)
+ AbbrevToUse = VST_ENTRY_7_ABBREV;
+ }
+
+ NameVals.push_back(VE.getValueID(SI->getValue()));
+ for (const char *P = Name.getKeyData(),
+ *E = Name.getKeyData()+Name.getKeyLength(); P != E; ++P)
+ NameVals.push_back((unsigned char)*P);
+
+ // Emit the finished record.
+ Stream.EmitRecord(Code, NameVals, AbbrevToUse);
+ NameVals.clear();
+ }
+ Stream.ExitBlock();
+}
+
+/// WriteFunction - Emit a function body to the module stream.
+static void WriteFunction(const Function &F, ValueEnumerator &VE,
+ BitstreamWriter &Stream) {
+ Stream.EnterSubblock(bitc::FUNCTION_BLOCK_ID, 4);
+ VE.incorporateFunction(F);
+
+ SmallVector<unsigned, 64> Vals;
+
+ // 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();
+
+ // If there are function-local constants, emit them now.
+ unsigned CstStart, CstEnd;
+ VE.getFunctionConstantRange(CstStart, CstEnd);
+ WriteConstants(CstStart, CstEnd, VE, Stream, false);
+
+ // If there is function-local metadata, emit it now.
+ WriteFunctionLocalMetadata(F, VE, Stream);
+
+ // Keep a running idea of what the instruction ID is.
+ unsigned InstID = CstEnd;
+
+ bool NeedsMetadataAttachment = false;
+
+ DebugLoc LastDL;
+
+ // Finally, emit all the instructions, in order.
+ 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) {
+ WriteInstruction(*I, InstID, VE, Stream, Vals);
+
+ if (!I->getType()->isVoidTy())
+ ++InstID;
+
+ // 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);
+ Stream.EmitRecord(bitc::FUNC_CODE_DEBUG_LOC, Vals);
+ Vals.clear();
+
+ LastDL = DL;
+ }
+ }
+
+ // Emit names for all the instructions etc.
+ WriteValueSymbolTable(F.getValueSymbolTable(), VE, Stream);
+
+ if (NeedsMetadataAttachment)
+ WriteMetadataAttachment(F, VE, Stream);
+ VE.purgeFunction();
+ Stream.ExitBlock();
+}
+
+// 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);
+
+ { // 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));
+ if (Stream.EmitBlockInfoAbbrev(bitc::VALUE_SYMTAB_BLOCK_ID,
+ Abbv) != VST_ENTRY_8_ABBREV)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+
+
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+ // FIXME: This should only use space for first class types!
+
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+ { // 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)
+ llvm_unreachable("Unexpected abbrev ordering!");
+ }
+
+ Stream.ExitBlock();
+}
+
+
+/// WriteModule - Emit the specified module to the bitstream.
+static void WriteModule(const Module *M, BitstreamWriter &Stream) {
+ Stream.EnterSubblock(bitc::MODULE_BLOCK_ID, 3);
+
+ // Emit the version number if it is non-zero.
+ if (CurVersion) {
+ SmallVector<unsigned, 1> Vals;
+ Vals.push_back(CurVersion);
+ Stream.EmitRecord(bitc::MODULE_CODE_VERSION, Vals);
+ }
+
+ // Analyze the module, enumerating globals, functions, etc.
+ ValueEnumerator VE(M);
+
+ // Emit blockinfo, which defines the standard abbreviations etc.
+ WriteBlockInfo(VE, Stream);
+
+ // Emit information about parameter attributes.
+ WriteAttributeTable(VE, Stream);
+
+ // Emit information describing all of the types in the module.
+ WriteTypeTable(VE, Stream);
+
+ // Emit top-level description of module, including target triple, inline asm,
+ // descriptors for global variables, and function prototype info.
+ WriteModuleInfo(M, VE, Stream);
+
+ // Emit constants.
+ WriteModuleConstants(VE, Stream);
+
+ // Emit metadata.
+ WriteModuleMetadata(M, VE, Stream);
+
+ // Emit function bodies.
+ for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F)
+ if (!F->isDeclaration())
+ WriteFunction(*F, VE, Stream);
+
+ // Emit metadata.
+ WriteModuleMetadataStore(M, Stream);
+
+ // Emit names for globals/functions etc.
+ WriteValueSymbolTable(M->getValueSymbolTable(), VE, Stream);
+
+ Stream.ExitBlock();
+}
+
+/// 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.
+///
+/// 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
+};
+
+static void EmitDarwinBCHeader(BitstreamWriter &Stream, const Triple &TT) {
+ unsigned CPUType = ~0U;
+
+ // Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*, arm-*, thumb-*,
+ // 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.
+ enum {
+ DARWIN_CPU_ARCH_ABI64 = 0x01000000,
+ DARWIN_CPU_TYPE_X86 = 7,
+ DARWIN_CPU_TYPE_ARM = 12,
+ DARWIN_CPU_TYPE_POWERPC = 18
+ };
+
+ Triple::ArchType Arch = TT.getArch();
+ if (Arch == Triple::x86_64)
+ CPUType = DARWIN_CPU_TYPE_X86 | DARWIN_CPU_ARCH_ABI64;
+ else if (Arch == Triple::x86)
+ CPUType = DARWIN_CPU_TYPE_X86;
+ else if (Arch == Triple::ppc)
+ CPUType = DARWIN_CPU_TYPE_POWERPC;
+ else if (Arch == Triple::ppc64)
+ CPUType = DARWIN_CPU_TYPE_POWERPC | DARWIN_CPU_ARCH_ABI64;
+ else if (Arch == Triple::arm || Arch == Triple::thumb)
+ CPUType = DARWIN_CPU_TYPE_ARM;
+
+ // Traditional Bitcode starts after header.
+ unsigned BCOffset = DarwinBCHeaderSize;
+
+ 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);
+
+ // If the file is not a multiple of 16 bytes, insert dummy padding.
+ while (BufferSize & 15) {
+ Stream.Emit(0, 8);
+ ++BufferSize;
+ }
+}
+
+
+/// WriteBitcodeToFile - Write the specified module to the specified output
+/// stream.
+void llvm_2_9_func::WriteBitcodeToFile(const Module *M, raw_ostream &Out) {
+ std::vector<unsigned char> Buffer;
+ BitstreamWriter Stream(Buffer);
+
+ Buffer.reserve(256*1024);
+
+ WriteBitcodeToStream( M, Stream );
+
+ // 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_2_9_func::WriteBitcodeToStream(const Module *M, BitstreamWriter &Stream) {
+ // If this is darwin or another generic macho target, emit a file header and
+ // trailer if needed.
+ Triple TT(M->getTargetTriple());
+ if (TT.isOSDarwin())
+ EmitDarwinBCHeader(Stream, TT);
+
+ // 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);
+
+ if (TT.isOSDarwin())
+ EmitDarwinBCTrailer(Stream, Stream.getBuffer().size());
+}
diff --git a/BitWriter_2_9_func/BitcodeWriterPass.cpp b/BitWriter_2_9_func/BitcodeWriterPass.cpp
new file mode 100644
index 0000000..adc9dc0
--- /dev/null
+++ b/BitWriter_2_9_func/BitcodeWriterPass.cpp
@@ -0,0 +1,41 @@
+//===--- Bitcode/Writer/BitcodeWriterPass.cpp - Bitcode Writer ------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// BitcodeWriterPass implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ReaderWriter_2_9_func.h"
+#include "llvm/Pass.h"
+using namespace llvm;
+
+namespace {
+ class WriteBitcodePass : public ModulePass {
+ raw_ostream &OS; // raw_ostream to print on
+ public:
+ static char ID; // Pass identification, replacement for typeid
+ explicit WriteBitcodePass(raw_ostream &o)
+ : ModulePass(ID), OS(o) {}
+
+ const char *getPassName() const { return "Bitcode Writer"; }
+
+ bool runOnModule(Module &M) {
+ llvm_2_9_func::WriteBitcodeToFile(&M, OS);
+ return false;
+ }
+ };
+}
+
+char WriteBitcodePass::ID = 0;
+
+/// createBitcodeWriterPass - Create and return a pass that writes the module
+/// to the specified ostream.
+llvm::ModulePass *llvm_2_9_func::createBitcodeWriterPass(llvm::raw_ostream &Str) {
+ return new WriteBitcodePass(Str);
+}
diff --git a/BitWriter_2_9_func/ReaderWriter_2_9_func.h b/BitWriter_2_9_func/ReaderWriter_2_9_func.h
new file mode 100644
index 0000000..326e11a
--- /dev/null
+++ b/BitWriter_2_9_func/ReaderWriter_2_9_func.h
@@ -0,0 +1,147 @@
+//===-- llvm/Bitcode/ReaderWriter.h - Bitcode reader/writers ----*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This header defines interfaces to read and write LLVM bitcode files/streams.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_BITCODE_2_9_FUNC_H
+#define LLVM_BITCODE_2_9_FUNC_H
+
+#include <string>
+
+namespace llvm {
+ class Module;
+ class MemoryBuffer;
+ class ModulePass;
+ class BitstreamWriter;
+ class LLVMContext;
+ class raw_ostream;
+} // End llvm namespace
+
+namespace llvm_2_9_func {
+ /// getLazyBitcodeModule - Read the header of the specified bitcode buffer
+ /// and prepare for lazy deserialization of function bodies. If successful,
+ /// this takes ownership of 'buffer' and returns a non-null pointer. On
+ /// error, this returns null, *does not* take ownership of Buffer, and fills
+ /// in *ErrMsg with an error description if ErrMsg is non-null.
+ llvm::Module *getLazyBitcodeModule(llvm::MemoryBuffer *Buffer,
+ llvm::LLVMContext& Context,
+ std::string *ErrMsg = 0);
+
+ /// getBitcodeTargetTriple - Read the header of the specified bitcode
+ /// buffer and extract just the triple information. If successful,
+ /// this returns a string and *does not* take ownership
+ /// of 'buffer'. On error, this returns "", and fills in *ErrMsg
+ /// if ErrMsg is non-null.
+ std::string getBitcodeTargetTriple(llvm::MemoryBuffer *Buffer,
+ llvm::LLVMContext& Context,
+ std::string *ErrMsg = 0);
+
+ /// ParseBitcodeFile - Read the specified bitcode file, returning the module.
+ /// If an error occurs, this returns null and fills in *ErrMsg if it is
+ /// non-null. This method *never* takes ownership of Buffer.
+ llvm::Module *ParseBitcodeFile(llvm::MemoryBuffer *Buffer, llvm::LLVMContext& Context,
+ std::string *ErrMsg = 0);
+
+ /// WriteBitcodeToFile - Write the specified module to the specified
+ /// raw output stream. For streams where it matters, the given stream
+ /// should be in "binary" mode.
+ void WriteBitcodeToFile(const llvm::Module *M, llvm::raw_ostream &Out);
+
+ /// WriteBitcodeToStream - Write the specified module to the specified
+ /// raw output stream.
+ void WriteBitcodeToStream(const llvm::Module *M, llvm::BitstreamWriter &Stream);
+
+ /// createBitcodeWriterPass - Create and return a pass that writes the module
+ /// to the specified ostream.
+ llvm::ModulePass *createBitcodeWriterPass(llvm::raw_ostream &Str);
+
+
+ /// isBitcodeWrapper - Return true if the given bytes are the magic bytes
+ /// for an LLVM IR bitcode wrapper.
+ ///
+ static inline bool isBitcodeWrapper(const unsigned char *BufPtr,
+ const unsigned char *BufEnd) {
+ // See if you can find the hidden message in the magic bytes :-).
+ // (Hint: it's a little-endian encoding.)
+ return BufPtr != BufEnd &&
+ BufPtr[0] == 0xDE &&
+ BufPtr[1] == 0xC0 &&
+ BufPtr[2] == 0x17 &&
+ BufPtr[3] == 0x0B;
+ }
+
+ /// isRawBitcode - Return true if the given bytes are the magic bytes for
+ /// raw LLVM IR bitcode (without a wrapper).
+ ///
+ static inline bool isRawBitcode(const unsigned char *BufPtr,
+ const unsigned char *BufEnd) {
+ // These bytes sort of have a hidden message, but it's not in
+ // little-endian this time, and it's a little redundant.
+ return BufPtr != BufEnd &&
+ BufPtr[0] == 'B' &&
+ BufPtr[1] == 'C' &&
+ BufPtr[2] == 0xc0 &&
+ BufPtr[3] == 0xde;
+ }
+
+ /// isBitcode - Return true if the given bytes are the magic bytes for
+ /// LLVM IR bitcode, either with or without a wrapper.
+ ///
+ static bool inline isBitcode(const unsigned char *BufPtr,
+ const unsigned char *BufEnd) {
+ return isBitcodeWrapper(BufPtr, BufEnd) ||
+ isRawBitcode(BufPtr, BufEnd);
+ }
+
+ /// SkipBitcodeWrapperHeader - Some systems wrap bc files with a special
+ /// header for padding or other reasons. The format of this header is:
+ ///
+ /// 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.
+ /// ... potentially other gunk ...
+ /// };
+ ///
+ /// This function is called when we find a file with a matching magic number.
+ /// In this case, skip down to the subsection of the file that is actually a
+ /// BC file.
+ static inline bool SkipBitcodeWrapperHeader(unsigned char *&BufPtr,
+ unsigned char *&BufEnd) {
+ enum {
+ KnownHeaderSize = 4*4, // Size of header we read.
+ OffsetField = 2*4, // Offset in bytes to Offset field.
+ SizeField = 3*4 // Offset in bytes to Size field.
+ };
+
+ // Must contain the header!
+ if (BufEnd-BufPtr < KnownHeaderSize) return true;
+
+ unsigned Offset = ( BufPtr[OffsetField ] |
+ (BufPtr[OffsetField+1] << 8) |
+ (BufPtr[OffsetField+2] << 16) |
+ (BufPtr[OffsetField+3] << 24));
+ unsigned Size = ( BufPtr[SizeField ] |
+ (BufPtr[SizeField +1] << 8) |
+ (BufPtr[SizeField +2] << 16) |
+ (BufPtr[SizeField +3] << 24));
+
+ // Verify that Offset+Size fits in the file.
+ if (Offset+Size > unsigned(BufEnd-BufPtr))
+ return true;
+ BufPtr += Offset;
+ BufEnd = BufPtr+Size;
+ return false;
+ }
+} // End llvm_2_9_func namespace
+
+#endif
diff --git a/BitWriter_2_9_func/ValueEnumerator.cpp b/BitWriter_2_9_func/ValueEnumerator.cpp
new file mode 100644
index 0000000..9ae9905
--- /dev/null
+++ b/BitWriter_2_9_func/ValueEnumerator.cpp
@@ -0,0 +1,494 @@
+//===-- ValueEnumerator.cpp - Number values and types for bitcode writer --===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the ValueEnumerator class.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ValueEnumerator.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Constants.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Module.h"
+#include "llvm/ValueSymbolTable.h"
+#include "llvm/Instructions.h"
+#include <algorithm>
+using namespace llvm;
+
+static bool isIntegerValue(const std::pair<const Value*, unsigned> &V) {
+ return V.first->getType()->isIntegerTy();
+}
+
+/// ValueEnumerator - Enumerate module-level information.
+ValueEnumerator::ValueEnumerator(const Module *M) {
+ // Enumerate the global variables.
+ for (Module::const_global_iterator I = M->global_begin(),
+ E = M->global_end(); I != E; ++I)
+ EnumerateValue(I);
+
+ // Enumerate the functions.
+ for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
+ EnumerateValue(I);
+ EnumerateAttributes(cast<Function>(I)->getAttributes());
+ }
+
+ // Enumerate the aliases.
+ for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
+ I != E; ++I)
+ EnumerateValue(I);
+
+ // Remember what is the cutoff between globalvalue's and other constants.
+ unsigned FirstConstant = Values.size();
+
+ // Enumerate the global variable initializers.
+ for (Module::const_global_iterator I = M->global_begin(),
+ E = M->global_end(); I != E; ++I)
+ if (I->hasInitializer())
+ EnumerateValue(I->getInitializer());
+
+ // Enumerate the aliasees.
+ for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
+ I != E; ++I)
+ EnumerateValue(I->getAliasee());
+
+ // Insert constants and metadata that are named at module level into the slot
+ // pool so that the module symbol table can refer to them...
+ EnumerateValueSymbolTable(M->getValueSymbolTable());
+ EnumerateNamedMetadata(M);
+
+ SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
+
+ // Enumerate types used by function bodies and argument lists.
+ for (Module::const_iterator F = M->begin(), E = M->end(); F != E; ++F) {
+
+ for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
+ I != E; ++I)
+ EnumerateType(I->getType());
+
+ 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){
+ for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
+ OI != E; ++OI) {
+ if (MDNode *MD = dyn_cast<MDNode>(*OI))
+ if (MD->isFunctionLocal() && MD->getFunction())
+ // These will get enumerated during function-incorporation.
+ continue;
+ EnumerateOperandType(*OI);
+ }
+ EnumerateType(I->getType());
+ if (const CallInst *CI = dyn_cast<CallInst>(I))
+ EnumerateAttributes(CI->getAttributes());
+ else if (const InvokeInst *II = dyn_cast<InvokeInst>(I))
+ EnumerateAttributes(II->getAttributes());
+
+ // Enumerate metadata attached with this instruction.
+ MDs.clear();
+ I->getAllMetadataOtherThanDebugLoc(MDs);
+ for (unsigned i = 0, e = MDs.size(); i != e; ++i)
+ EnumerateMetadata(MDs[i].second);
+
+ if (!I->getDebugLoc().isUnknown()) {
+ MDNode *Scope, *IA;
+ I->getDebugLoc().getScopeAndInlinedAt(Scope, IA, I->getContext());
+ if (Scope) EnumerateMetadata(Scope);
+ if (IA) EnumerateMetadata(IA);
+ }
+ }
+ }
+
+ // Optimize constant ordering.
+ OptimizeConstants(FirstConstant, Values.size());
+}
+
+
+unsigned ValueEnumerator::getInstructionID(const Instruction *Inst) const {
+ InstructionMapType::const_iterator I = InstructionMap.find(Inst);
+ assert(I != InstructionMap.end() && "Instruction is not mapped!");
+ return I->second;
+}
+
+void ValueEnumerator::setInstructionID(const Instruction *I) {
+ InstructionMap[I] = InstructionCount++;
+}
+
+unsigned ValueEnumerator::getValueID(const Value *V) const {
+ if (isa<MDNode>(V) || isa<MDString>(V)) {
+ ValueMapType::const_iterator I = MDValueMap.find(V);
+ assert(I != MDValueMap.end() && "Value not in slotcalculator!");
+ return I->second-1;
+ }
+
+ ValueMapType::const_iterator I = ValueMap.find(V);
+ assert(I != ValueMap.end() && "Value not in slotcalculator!");
+ return I->second-1;
+}
+
+// Optimize constant ordering.
+namespace {
+ struct CstSortPredicate {
+ ValueEnumerator &VE;
+ explicit CstSortPredicate(ValueEnumerator &ve) : VE(ve) {}
+ bool operator()(const std::pair<const Value*, unsigned> &LHS,
+ const std::pair<const Value*, unsigned> &RHS) {
+ // Sort by plane.
+ if (LHS.first->getType() != RHS.first->getType())
+ return VE.getTypeID(LHS.first->getType()) <
+ VE.getTypeID(RHS.first->getType());
+ // Then by frequency.
+ return LHS.second > RHS.second;
+ }
+ };
+}
+
+/// OptimizeConstants - Reorder constant pool for denser encoding.
+void ValueEnumerator::OptimizeConstants(unsigned CstStart, unsigned CstEnd) {
+ if (CstStart == CstEnd || CstStart+1 == CstEnd) return;
+
+ CstSortPredicate P(*this);
+ std::stable_sort(Values.begin()+CstStart, Values.begin()+CstEnd, P);
+
+ // Ensure that integer constants are at the start of the constant pool. This
+ // is important so that GEP structure indices come before gep constant exprs.
+ std::partition(Values.begin()+CstStart, Values.begin()+CstEnd,
+ isIntegerValue);
+
+ // Rebuild the modified portion of ValueMap.
+ for (; CstStart != CstEnd; ++CstStart)
+ ValueMap[Values[CstStart].first] = CstStart+1;
+}
+
+
+/// EnumerateValueSymbolTable - Insert all of the values in the specified symbol
+/// table into the values table.
+void ValueEnumerator::EnumerateValueSymbolTable(const ValueSymbolTable &VST) {
+ for (ValueSymbolTable::const_iterator VI = VST.begin(), VE = VST.end();
+ VI != VE; ++VI)
+ EnumerateValue(VI->getValue());
+}
+
+/// EnumerateNamedMetadata - Insert all of the values referenced by
+/// named metadata in the specified module.
+void ValueEnumerator::EnumerateNamedMetadata(const Module *M) {
+ for (Module::const_named_metadata_iterator I = M->named_metadata_begin(),
+ E = M->named_metadata_end(); I != E; ++I)
+ EnumerateNamedMDNode(I);
+}
+
+void ValueEnumerator::EnumerateNamedMDNode(const NamedMDNode *MD) {
+ for (unsigned i = 0, e = MD->getNumOperands(); i != e; ++i)
+ EnumerateMetadata(MD->getOperand(i));
+}
+
+/// EnumerateMDNodeOperands - Enumerate all non-function-local values
+/// and types referenced by the given MDNode.
+void ValueEnumerator::EnumerateMDNodeOperands(const MDNode *N) {
+ for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
+ if (Value *V = N->getOperand(i)) {
+ if (isa<MDNode>(V) || isa<MDString>(V))
+ EnumerateMetadata(V);
+ else if (!isa<Instruction>(V) && !isa<Argument>(V))
+ EnumerateValue(V);
+ } else
+ EnumerateType(Type::getVoidTy(N->getContext()));
+ }
+}
+
+void ValueEnumerator::EnumerateMetadata(const Value *MD) {
+ assert((isa<MDNode>(MD) || isa<MDString>(MD)) && "Invalid metadata kind");
+
+ // Enumerate the type of this value.
+ EnumerateType(MD->getType());
+
+ const MDNode *N = dyn_cast<MDNode>(MD);
+
+ // In the module-level pass, skip function-local nodes themselves, but
+ // do walk their operands.
+ if (N && N->isFunctionLocal() && N->getFunction()) {
+ EnumerateMDNodeOperands(N);
+ return;
+ }
+
+ // Check to see if it's already in!
+ unsigned &MDValueID = MDValueMap[MD];
+ if (MDValueID) {
+ // Increment use count.
+ MDValues[MDValueID-1].second++;
+ return;
+ }
+ MDValues.push_back(std::make_pair(MD, 1U));
+ MDValueID = MDValues.size();
+
+ // Enumerate all non-function-local operands.
+ if (N)
+ EnumerateMDNodeOperands(N);
+}
+
+/// EnumerateFunctionLocalMetadataa - Incorporate function-local metadata
+/// information reachable from the given MDNode.
+void ValueEnumerator::EnumerateFunctionLocalMetadata(const MDNode *N) {
+ assert(N->isFunctionLocal() && N->getFunction() &&
+ "EnumerateFunctionLocalMetadata called on non-function-local mdnode!");
+
+ // Enumerate the type of this value.
+ EnumerateType(N->getType());
+
+ // Check to see if it's already in!
+ unsigned &MDValueID = MDValueMap[N];
+ if (MDValueID) {
+ // Increment use count.
+ MDValues[MDValueID-1].second++;
+ return;
+ }
+ MDValues.push_back(std::make_pair(N, 1U));
+ MDValueID = MDValues.size();
+
+ // To incoroporate function-local information visit all function-local
+ // MDNodes and all function-local values they reference.
+ for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
+ if (Value *V = N->getOperand(i)) {
+ if (MDNode *O = dyn_cast<MDNode>(V)) {
+ if (O->isFunctionLocal() && O->getFunction())
+ EnumerateFunctionLocalMetadata(O);
+ } else if (isa<Instruction>(V) || isa<Argument>(V))
+ EnumerateValue(V);
+ }
+
+ // Also, collect all function-local MDNodes for easy access.
+ FunctionLocalMDs.push_back(N);
+}
+
+void ValueEnumerator::EnumerateValue(const Value *V) {
+ assert(!V->getType()->isVoidTy() && "Can't insert void values!");
+ assert(!isa<MDNode>(V) && !isa<MDString>(V) &&
+ "EnumerateValue doesn't handle Metadata!");
+
+ // Check to see if it's already in!
+ unsigned &ValueID = ValueMap[V];
+ if (ValueID) {
+ // Increment use count.
+ Values[ValueID-1].second++;
+ return;
+ }
+
+ // Enumerate the type of this value.
+ EnumerateType(V->getType());
+
+ if (const Constant *C = dyn_cast<Constant>(V)) {
+ if (isa<GlobalValue>(C)) {
+ // Initializers for globals are handled explicitly elsewhere.
+ } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
+ // Do not enumerate the initializers for an array of simple characters.
+ // The initializers just pollute the value table, and we emit the strings
+ // specially.
+ } else if (C->getNumOperands()) {
+ // If a constant has operands, enumerate them. This makes sure that if a
+ // constant has uses (for example an array of const ints), that they are
+ // inserted also.
+
+ // We prefer to enumerate them with values before we enumerate the user
+ // itself. This makes it more likely that we can avoid forward references
+ // in the reader. We know that there can be no cycles in the constants
+ // graph that don't go through a global variable.
+ for (User::const_op_iterator I = C->op_begin(), E = C->op_end();
+ I != E; ++I)
+ if (!isa<BasicBlock>(*I)) // Don't enumerate BB operand to BlockAddress.
+ EnumerateValue(*I);
+
+ // Finally, add the value. Doing this could make the ValueID reference be
+ // dangling, don't reuse it.
+ Values.push_back(std::make_pair(V, 1U));
+ ValueMap[V] = Values.size();
+ return;
+ }
+ }
+
+ // Add the value.
+ Values.push_back(std::make_pair(V, 1U));
+ ValueID = Values.size();
+}
+
+
+void ValueEnumerator::EnumerateType(Type *Ty) {
+ unsigned *TypeID = &TypeMap[Ty];
+
+ // We've already seen this type.
+ if (*TypeID)
+ return;
+
+ // If it is a non-anonymous struct, mark the type as being visited so that we
+ // don't recursively visit it. This is safe because we allow forward
+ // references of these in the bitcode reader.
+ if (StructType *STy = dyn_cast<StructType>(Ty))
+ if (!STy->isLiteral())
+ *TypeID = ~0U;
+
+ // Enumerate all of the subtypes before we enumerate this type. This ensures
+ // that the type will be enumerated in an order that can be directly built.
+ for (Type::subtype_iterator I = Ty->subtype_begin(), E = Ty->subtype_end();
+ I != E; ++I)
+ EnumerateType(*I);
+
+ // Refresh the TypeID pointer in case the table rehashed.
+ TypeID = &TypeMap[Ty];
+
+ // Check to see if we got the pointer another way. This can happen when
+ // enumerating recursive types that hit the base case deeper than they start.
+ //
+ // If this is actually a struct that we are treating as forward ref'able,
+ // then emit the definition now that all of its contents are available.
+ if (*TypeID && *TypeID != ~0U)
+ return;
+
+ // Add this type now that its contents are all happily enumerated.
+ Types.push_back(Ty);
+
+ *TypeID = Types.size();
+}
+
+// Enumerate the types for the specified value. If the value is a constant,
+// walk through it, enumerating the types of the constant.
+void ValueEnumerator::EnumerateOperandType(const Value *V) {
+ EnumerateType(V->getType());
+
+ if (const Constant *C = dyn_cast<Constant>(V)) {
+ // If this constant is already enumerated, ignore it, we know its type must
+ // be enumerated.
+ if (ValueMap.count(V)) return;
+
+ // This constant may have operands, make sure to enumerate the types in
+ // them.
+ for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
+ const Value *Op = C->getOperand(i);
+
+ // Don't enumerate basic blocks here, this happens as operands to
+ // blockaddress.
+ if (isa<BasicBlock>(Op)) continue;
+
+ EnumerateOperandType(Op);
+ }
+
+ if (const MDNode *N = dyn_cast<MDNode>(V)) {
+ for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i)
+ if (Value *Elem = N->getOperand(i))
+ EnumerateOperandType(Elem);
+ }
+ } else if (isa<MDString>(V) || isa<MDNode>(V))
+ EnumerateMetadata(V);
+}
+
+void ValueEnumerator::EnumerateAttributes(const AttrListPtr &PAL) {
+ if (PAL.isEmpty()) return; // null is always 0.
+ // Do a lookup.
+ unsigned &Entry = AttributeMap[PAL.getRawPointer()];
+ if (Entry == 0) {
+ // Never saw this before, add it.
+ Attributes.push_back(PAL);
+ Entry = Attributes.size();
+ }
+}
+
+void ValueEnumerator::incorporateFunction(const Function &F) {
+ InstructionCount = 0;
+ NumModuleValues = Values.size();
+ NumModuleMDValues = MDValues.size();
+
+ // Adding function arguments to the value table.
+ for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end();
+ I != E; ++I)
+ EnumerateValue(I);
+
+ FirstFuncConstantID = Values.size();
+
+ // Add all function-level constants to the value table.
+ 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)
+ for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
+ OI != E; ++OI) {
+ if ((isa<Constant>(*OI) && !isa<GlobalValue>(*OI)) ||
+ isa<InlineAsm>(*OI))
+ EnumerateValue(*OI);
+ }
+ BasicBlocks.push_back(BB);
+ ValueMap[BB] = BasicBlocks.size();
+ }
+
+ // Optimize the constant layout.
+ OptimizeConstants(FirstFuncConstantID, Values.size());
+
+ // Add the function's parameter attributes so they are available for use in
+ // the function's instruction.
+ EnumerateAttributes(F.getAttributes());
+
+ FirstInstID = Values.size();
+
+ SmallVector<MDNode *, 8> FnLocalMDVector;
+ // Add all of the instructions.
+ 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) {
+ for (User::const_op_iterator OI = I->op_begin(), E = I->op_end();
+ OI != E; ++OI) {
+ if (MDNode *MD = dyn_cast<MDNode>(*OI))
+ if (MD->isFunctionLocal() && MD->getFunction())
+ // Enumerate metadata after the instructions they might refer to.
+ FnLocalMDVector.push_back(MD);
+ }
+
+ SmallVector<std::pair<unsigned, MDNode*>, 8> MDs;
+ I->getAllMetadataOtherThanDebugLoc(MDs);
+ for (unsigned i = 0, e = MDs.size(); i != e; ++i) {
+ MDNode *N = MDs[i].second;
+ if (N->isFunctionLocal() && N->getFunction())
+ FnLocalMDVector.push_back(N);
+ }
+
+ if (!I->getType()->isVoidTy())
+ EnumerateValue(I);
+ }
+ }
+
+ // Add all of the function-local metadata.
+ for (unsigned i = 0, e = FnLocalMDVector.size(); i != e; ++i)
+ EnumerateFunctionLocalMetadata(FnLocalMDVector[i]);
+}
+
+void ValueEnumerator::purgeFunction() {
+ /// Remove purged values from the ValueMap.
+ for (unsigned i = NumModuleValues, e = Values.size(); i != e; ++i)
+ ValueMap.erase(Values[i].first);
+ for (unsigned i = NumModuleMDValues, e = MDValues.size(); i != e; ++i)
+ MDValueMap.erase(MDValues[i].first);
+ for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i)
+ ValueMap.erase(BasicBlocks[i]);
+
+ Values.resize(NumModuleValues);
+ MDValues.resize(NumModuleMDValues);
+ BasicBlocks.clear();
+ FunctionLocalMDs.clear();
+}
+
+static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
+ DenseMap<const BasicBlock*, unsigned> &IDMap) {
+ unsigned Counter = 0;
+ for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
+ IDMap[BB] = ++Counter;
+}
+
+/// getGlobalBasicBlockID - This returns the function-specific ID for the
+/// specified basic block. This is relatively expensive information, so it
+/// should only be used by rare constructs such as address-of-label.
+unsigned ValueEnumerator::getGlobalBasicBlockID(const BasicBlock *BB) const {
+ unsigned &Idx = GlobalBasicBlockIDs[BB];
+ if (Idx != 0)
+ return Idx-1;
+
+ IncorporateFunctionInfoGlobalBBIDs(BB->getParent(), GlobalBasicBlockIDs);
+ return getGlobalBasicBlockID(BB);
+}
+
diff --git a/BitWriter_2_9_func/ValueEnumerator.h b/BitWriter_2_9_func/ValueEnumerator.h
new file mode 100644
index 0000000..b6fc920
--- /dev/null
+++ b/BitWriter_2_9_func/ValueEnumerator.h
@@ -0,0 +1,153 @@
+//===-- Bitcode/Writer/ValueEnumerator.h - Number values --------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class gives values and types Unique ID's.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef VALUE_ENUMERATOR_H
+#define VALUE_ENUMERATOR_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Attributes.h"
+#include <vector>
+
+namespace llvm {
+
+class Type;
+class Value;
+class Instruction;
+class BasicBlock;
+class Function;
+class Module;
+class MDNode;
+class NamedMDNode;
+class AttrListPtr;
+class ValueSymbolTable;
+class MDSymbolTable;
+
+class ValueEnumerator {
+public:
+ typedef std::vector<Type*> TypeList;
+
+ // For each value, we remember its Value* and occurrence frequency.
+ typedef std::vector<std::pair<const Value*, unsigned> > ValueList;
+private:
+ typedef DenseMap<Type*, unsigned> TypeMapType;
+ TypeMapType TypeMap;
+ TypeList Types;
+
+ typedef DenseMap<const Value*, unsigned> ValueMapType;
+ ValueMapType ValueMap;
+ ValueList Values;
+ ValueList MDValues;
+ SmallVector<const MDNode *, 8> FunctionLocalMDs;
+ ValueMapType MDValueMap;
+
+ typedef DenseMap<void*, unsigned> AttributeMapType;
+ AttributeMapType AttributeMap;
+ std::vector<AttrListPtr> Attributes;
+
+ /// GlobalBasicBlockIDs - This map memoizes the basic block ID's referenced by
+ /// the "getGlobalBasicBlockID" method.
+ mutable DenseMap<const BasicBlock*, unsigned> GlobalBasicBlockIDs;
+
+ typedef DenseMap<const Instruction*, unsigned> InstructionMapType;
+ InstructionMapType InstructionMap;
+ unsigned InstructionCount;
+
+ /// BasicBlocks - This contains all the basic blocks for the currently
+ /// incorporated function. Their reverse mapping is stored in ValueMap.
+ std::vector<const BasicBlock*> BasicBlocks;
+
+ /// When a function is incorporated, this is the size of the Values list
+ /// before incorporation.
+ unsigned NumModuleValues;
+
+ /// When a function is incorporated, this is the size of the MDValues list
+ /// before incorporation.
+ unsigned NumModuleMDValues;
+
+ unsigned FirstFuncConstantID;
+ unsigned FirstInstID;
+
+ ValueEnumerator(const ValueEnumerator &); // DO NOT IMPLEMENT
+ void operator=(const ValueEnumerator &); // DO NOT IMPLEMENT
+public:
+ ValueEnumerator(const Module *M);
+
+ unsigned getValueID(const Value *V) const;
+
+ unsigned getTypeID(Type *T) const {
+ TypeMapType::const_iterator I = TypeMap.find(T);
+ assert(I != TypeMap.end() && "Type not in ValueEnumerator!");
+ return I->second-1;
+ }
+
+ unsigned getInstructionID(const Instruction *I) const;
+ void setInstructionID(const Instruction *I);
+
+ unsigned getAttributeID(const AttrListPtr &PAL) const {
+ if (PAL.isEmpty()) return 0; // Null maps to zero.
+ AttributeMapType::const_iterator I = AttributeMap.find(PAL.getRawPointer());
+ assert(I != AttributeMap.end() && "Attribute not in ValueEnumerator!");
+ return I->second;
+ }
+
+ /// getFunctionConstantRange - Return the range of values that corresponds to
+ /// function-local constants.
+ void getFunctionConstantRange(unsigned &Start, unsigned &End) const {
+ Start = FirstFuncConstantID;
+ End = FirstInstID;
+ }
+
+ const ValueList &getValues() const { return Values; }
+ const ValueList &getMDValues() const { return MDValues; }
+ const SmallVector<const MDNode *, 8> &getFunctionLocalMDValues() const {
+ return FunctionLocalMDs;
+ }
+ const TypeList &getTypes() const { return Types; }
+ const std::vector<const BasicBlock*> &getBasicBlocks() const {
+ return BasicBlocks;
+ }
+ const std::vector<AttrListPtr> &getAttributes() const {
+ return Attributes;
+ }
+
+ /// getGlobalBasicBlockID - This returns the function-specific ID for the
+ /// specified basic block. This is relatively expensive information, so it
+ /// should only be used by rare constructs such as address-of-label.
+ unsigned getGlobalBasicBlockID(const BasicBlock *BB) const;
+
+ /// incorporateFunction/purgeFunction - If you'd like to deal with a function,
+ /// use these two methods to get its data into the ValueEnumerator!
+ ///
+ void incorporateFunction(const Function &F);
+ void purgeFunction();
+
+private:
+ void OptimizeConstants(unsigned CstStart, unsigned CstEnd);
+
+ void EnumerateMDNodeOperands(const MDNode *N);
+ void EnumerateMetadata(const Value *MD);
+ void EnumerateFunctionLocalMetadata(const MDNode *N);
+ void EnumerateNamedMDNode(const NamedMDNode *NMD);
+ void EnumerateValue(const Value *V);
+ void EnumerateType(Type *T);
+ void EnumerateOperandType(const Value *V);
+ void EnumerateAttributes(const AttrListPtr &PAL);
+
+ void EnumerateValueSymbolTable(const ValueSymbolTable &ST);
+ void EnumerateNamedMetadata(const Module *M);
+};
+
+} // End llvm namespace
+
+#endif
diff --git a/RSCCOptions.td b/RSCCOptions.td
index 77b0361..5e137c1 100644
--- a/RSCCOptions.td
+++ b/RSCCOptions.td
@@ -83,6 +83,9 @@
MetaVarName<"<value>">, HelpText<"<value> should be 'ar' or 'jc'">;
def _bitcode_storage : Separate<"-s">, Alias<bitcode_storage>;
+def W : Joined<"-W">;
+def w : Flag<"-w">, HelpText<"Suppress all warnings">;
+
//===----------------------------------------------------------------------===//
// Dependency Output Options
//===----------------------------------------------------------------------===//
diff --git a/llvm-rs-cc.cpp b/llvm-rs-cc.cpp
index b8e3d59..d6a3b8d 100644
--- a/llvm-rs-cc.cpp
+++ b/llvm-rs-cc.cpp
@@ -29,6 +29,7 @@
#include "clang/Frontend/DiagnosticOptions.h"
#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Frontend/Utils.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
@@ -44,6 +45,7 @@
#include "slang.h"
#include "slang_assert.h"
+#include "slang_diagnostic_buffer.h"
#include "slang_rs.h"
#include "slang_rs_reflect_utils.h"
@@ -182,6 +184,11 @@
DiagEngine.Report(clang::diag::err_drv_missing_argument)
<< Args->getArgString(MissingArgIndex) << MissingArgCount;
+ clang::DiagnosticOptions DiagOpts;
+ DiagOpts.IgnoreWarnings = Args->hasArg(OPT_w);
+ DiagOpts.Warnings = Args->getAllArgValues(OPT_W);
+ clang::ProcessWarningOptions(DiagEngine, DiagOpts);
+
// Issue errors on unknown arguments.
for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
ie = Args->filtered_end(); it != ie; ++it)
@@ -360,6 +367,8 @@
OS << ".\n";
return;
}
+#undef wrap_str
+#undef str
int main(int argc, const char **argv) {
std::set<std::string> SavedStrings;
@@ -376,24 +385,22 @@
Argv0 = llvm::sys::path::stem(ArgVector[0]);
// Setup diagnostic engine
- clang::TextDiagnosticPrinter *DiagClient =
- new clang::TextDiagnosticPrinter(llvm::errs(), clang::DiagnosticOptions());
- DiagClient->setPrefix(Argv0);
+ slang::DiagnosticBuffer *DiagClient = new slang::DiagnosticBuffer();
llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagIDs(
new clang::DiagnosticIDs());
clang::DiagnosticsEngine DiagEngine(DiagIDs, DiagClient, true);
- clang::Diagnostic Diags(&DiagEngine);
-
slang::Slang::GlobalInitialization();
ParseArguments(ArgVector, Inputs, Opts, DiagEngine);
// Exits when there's any error occurred during parsing the arguments
- if (DiagEngine.hasErrorOccurred())
+ if (DiagEngine.hasErrorOccurred()) {
+ llvm::errs() << DiagClient->str();
return 1;
+ }
if (Opts.mShowHelp) {
llvm::OwningPtr<OptTable> OptTbl(createRSCCOptTable());
@@ -410,6 +417,7 @@
// No input file
if (Inputs.empty()) {
DiagEngine.Report(clang::diag::err_drv_no_input_files);
+ llvm::errs() << DiagClient->str();
return 1;
}
@@ -419,7 +427,8 @@
llvm::OwningPtr<slang::SlangRS> Compiler(new slang::SlangRS());
- Compiler->init(Opts.mTriple, Opts.mCPU, Opts.mFeatures);
+ Compiler->init(Opts.mTriple, Opts.mCPU, Opts.mFeatures, &DiagEngine,
+ DiagClient);
for (int i = 0, e = Inputs.size(); i != e; i++) {
const char *InputFile = Inputs[i];
diff --git a/slang.cpp b/slang.cpp
index 45dc277..1c33f4d 100644
--- a/slang.cpp
+++ b/slang.cpp
@@ -117,8 +117,7 @@
OpenOutputFile(const char *OutputFile,
unsigned Flags,
std::string* Error,
- clang::DiagnosticsEngine *DiagEngine)
-{
+ clang::DiagnosticsEngine *DiagEngine) {
slangAssert((OutputFile != NULL) && (Error != NULL) &&
(DiagEngine != NULL) && "Invalid parameter!");
@@ -156,6 +155,7 @@
LangOpts.RTTI = 0; // Turn off the RTTI information support
LangOpts.NeXTRuntime = 0; // Turn off the NeXT runtime uses
LangOpts.C99 = 1;
+ LangOpts.CharIsSigned = 1; // Signed char is our default.
CodeGenOpts.OptimizationLevel = 3;
@@ -171,16 +171,6 @@
exit(1);
}
-void Slang::createDiagnostic() {
- mDiagClient = new DiagnosticBuffer();
-
- mDiagIDs = new clang::DiagnosticIDs();
- mDiagEngine = new clang::DiagnosticsEngine(mDiagIDs, mDiagClient, true);
- mDiag.reset(new clang::Diagnostic(mDiagEngine.getPtr()));
-
- initDiagnostic();
-}
-
void Slang::createTarget(const std::string &Triple, const std::string &CPU,
const std::vector<std::string> &Features) {
if (!Triple.empty())
@@ -209,7 +199,8 @@
void Slang::createPreprocessor() {
// Default only search header file in current dir
- clang::HeaderSearch *HeaderInfo = new clang::HeaderSearch(*mFileMgr);
+ clang::HeaderSearch *HeaderInfo = new clang::HeaderSearch(*mFileMgr,
+ *mDiagEngine);
mPP.reset(new clang::Preprocessor(*mDiagEngine,
LangOpts,
@@ -256,7 +247,7 @@
clang::ASTConsumer *
Slang::createBackend(const clang::CodeGenOptions& CodeGenOpts,
llvm::raw_ostream *OS, OutputType OT) {
- return new Backend(mDiagEngine.getPtr(), CodeGenOpts, mTargetOpts,
+ return new Backend(mDiagEngine, CodeGenOpts, mTargetOpts,
&mPragmas, OS, OT);
}
@@ -265,12 +256,17 @@
}
void Slang::init(const std::string &Triple, const std::string &CPU,
- const std::vector<std::string> &Features) {
+ const std::vector<std::string> &Features,
+ clang::DiagnosticsEngine *DiagEngine,
+ DiagnosticBuffer *DiagClient) {
if (mInitialized)
return;
- createDiagnostic();
- llvm::install_fatal_error_handler(LLVMErrorHandler, mDiagEngine.getPtr());
+ mDiagEngine = DiagEngine;
+ mDiagClient = DiagClient;
+ mDiag.reset(new clang::Diagnostic(mDiagEngine));
+ initDiagnostic();
+ llvm::install_fatal_error_handler(LLVMErrorHandler, mDiagEngine);
createTarget(Triple, CPU, Features);
createFileManager();
@@ -279,10 +275,10 @@
mInitialized = true;
}
-clang::ModuleKey Slang::loadModule(clang::SourceLocation ImportLoc,
- clang::IdentifierInfo &ModuleName,
- clang::SourceLocation ModuleNameLoc) {
- //FIXME: Don't we have to implement this?
+clang::Module *Slang::loadModule(clang::SourceLocation ImportLoc,
+ clang::ModuleIdPath Path,
+ clang::Module::NameVisibilityKind Visibility,
+ bool IsInclusionDirective) {
slangAssert(0 && "Not implemented");
return NULL;
}
@@ -333,7 +329,7 @@
case OT_Dependency:
case OT_Assembly:
case OT_LLVMAssembly: {
- OS = OpenOutputFile(OutputFile, 0, &Error, mDiagEngine.getPtr());
+ OS = OpenOutputFile(OutputFile, 0, &Error, mDiagEngine);
break;
}
case OT_Nothing: {
@@ -342,7 +338,7 @@
case OT_Object:
case OT_Bitcode: {
OS = OpenOutputFile(OutputFile, llvm::raw_fd_ostream::F_Binary,
- &Error, mDiagEngine.getPtr());
+ &Error, mDiagEngine);
break;
}
default: {
@@ -364,7 +360,7 @@
llvm::sys::Path OutputFilePath(OutputFile);
std::string Error;
- mDOS.reset(OpenOutputFile(OutputFile, 0, &Error, mDiagEngine.getPtr()));
+ mDOS.reset(OpenOutputFile(OutputFile, 0, &Error, mDiagEngine));
if (!Error.empty() || (mDOS.get() == NULL))
return false;
diff --git a/slang.h b/slang.h
index 440278e..16f851e 100644
--- a/slang.h
+++ b/slang.h
@@ -51,7 +51,7 @@
class SourceManager;
class TargetInfo;
class TargetOptions;
-}
+} // namespace clang
namespace slang {
@@ -81,19 +81,13 @@
// Diagnostics Mediator (An interface for both Producer and Consumer)
llvm::OwningPtr<clang::Diagnostic> mDiag;
- // Diagnostics ID
- llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> mDiagIDs;
-
// Diagnostics Engine (Producer and Diagnostics Reporter)
- llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> mDiagEngine;
+ clang::DiagnosticsEngine *mDiagEngine;
// Diagnostics Consumer
// NOTE: The ownership is taken by mDiagEngine after creation.
DiagnosticBuffer *mDiagClient;
- void createDiagnostic();
-
-
// The target being compiled for
clang::TargetOptions mTargetOpts;
llvm::OwningPtr<clang::TargetInfo> mTarget;
@@ -175,11 +169,14 @@
Slang();
void init(const std::string &Triple, const std::string &CPU,
- const std::vector<std::string> &Features);
+ const std::vector<std::string> &Features,
+ clang::DiagnosticsEngine *DiagEngine,
+ DiagnosticBuffer *DiagClient);
- virtual clang::ModuleKey loadModule(clang::SourceLocation ImportLoc,
- clang::IdentifierInfo &ModuleName,
- clang::SourceLocation ModuleNameLoc);
+ virtual clang::Module *loadModule(clang::SourceLocation ImportLoc,
+ clang::ModuleIdPath Path,
+ clang::Module::NameVisibilityKind VK,
+ bool IsInclusionDirective);
bool setInputSource(llvm::StringRef InputFile, const char *Text,
size_t TextLength);
diff --git a/slang_backend.cpp b/slang_backend.cpp
index 7809a77..9281f39 100644
--- a/slang_backend.cpp
+++ b/slang_backend.cpp
@@ -56,6 +56,7 @@
#include "slang_assert.h"
#include "BitWriter_2_9/ReaderWriter_2_9.h"
+#include "BitWriter_2_9_func/ReaderWriter_2_9_func.h"
namespace slang {
@@ -121,17 +122,20 @@
return false;
}
- llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim;
+ // Target Machine Options
+ llvm::TargetOptions Options;
+
+ Options.NoFramePointerElim = mCodeGenOpts.DisableFPElim;
// Use hardware FPU.
//
// FIXME: Need to detect the CPU capability and decide whether to use softfp.
// To use softfp, change following 2 lines to
//
- // llvm::FloatABIType = llvm::FloatABI::Soft;
- // llvm::UseSoftFloat = true;
- llvm::FloatABIType = llvm::FloatABI::Hard;
- llvm::UseSoftFloat = false;
+ // Options.FloatABIType = llvm::FloatABI::Soft;
+ // Options.UseSoftFloat = true;
+ Options.FloatABIType = llvm::FloatABI::Hard;
+ Options.UseSoftFloat = false;
// BCC needs all unknown symbols resolved at compilation time. So we don't
// need any relocation model.
@@ -164,17 +168,17 @@
llvm::TargetMachine *TM =
TargetInfo->createTargetMachine(Triple, mTargetOpts.CPU, FeaturesStr,
- RM, CM);
+ Options, RM, CM);
// Register scheduler
llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);
// Register allocation policy:
// createFastRegisterAllocator: fast but bad quality
- // createLinearScanRegisterAllocator: not so fast but good quality
+ // createGreedyRegisterAllocator: not so fast but good quality
llvm::RegisterRegAlloc::setDefault((mCodeGenOpts.OptimizationLevel == 0) ?
llvm::createFastRegisterAllocator :
- llvm::createLinearScanRegisterAllocator);
+ llvm::createGreedyRegisterAllocator);
llvm::CodeGenOpt::Level OptLevel = llvm::CodeGenOpt::Default;
if (mCodeGenOpts.OptimizationLevel == 0) {
@@ -248,9 +252,8 @@
return;
}
-void Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
- mGen->HandleTopLevelDecl(D);
- return;
+bool Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
+ return mGen->HandleTopLevelDecl(D);
}
void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) {
@@ -345,11 +348,29 @@
llvm::PassManager *BCEmitPM = new llvm::PassManager();
std::string BCStr;
llvm::raw_string_ostream Bitcode(BCStr);
- if (getTargetAPI() < SLANG_ICS_TARGET_API) {
- // Pre-ICS targets must use the LLVM 2.9 BitcodeWriter
- BCEmitPM->add(llvm_2_9::createBitcodeWriterPass(Bitcode));
- } else {
- BCEmitPM->add(llvm::createBitcodeWriterPass(Bitcode));
+ unsigned int TargetAPI = getTargetAPI();
+ switch (TargetAPI) {
+ case SLANG_HC_TARGET_API:
+ case SLANG_HC_MR1_TARGET_API:
+ case SLANG_HC_MR2_TARGET_API: {
+ // Pre-ICS targets must use the LLVM 2.9 BitcodeWriter
+ BCEmitPM->add(llvm_2_9::createBitcodeWriterPass(Bitcode));
+ break;
+ }
+ case SLANG_ICS_TARGET_API:
+ case SLANG_ICS_MR1_TARGET_API: {
+ // ICS targets must use the LLVM 2.9_func BitcodeWriter
+ BCEmitPM->add(llvm_2_9_func::createBitcodeWriterPass(Bitcode));
+ break;
+ }
+ default: {
+ if (TargetAPI < SLANG_MINIMUM_TARGET_API ||
+ TargetAPI > SLANG_MAXIMUM_TARGET_API) {
+ slangAssert(false && "Invalid target API value");
+ }
+ BCEmitPM->add(llvm::createBitcodeWriterPass(Bitcode));
+ break;
+ }
}
BCEmitPM->run(*mpModule);
diff --git a/slang_backend.h b/slang_backend.h
index 93b4a9b..69721fe 100644
--- a/slang_backend.h
+++ b/slang_backend.h
@@ -116,7 +116,7 @@
// called by the parser to process every top-level Decl*. Note that D can be
// the head of a chain of Decls (e.g. for `int a, b` the chain will have two
// elements). Use Decl::getNextDeclarator() to walk the chain.
- virtual void HandleTopLevelDecl(clang::DeclGroupRef D);
+ virtual bool HandleTopLevelDecl(clang::DeclGroupRef D);
// HandleTranslationUnit - This method is called when the ASTs for entire
// translation unit have been parsed.
diff --git a/slang_diagnostic_buffer.cpp b/slang_diagnostic_buffer.cpp
index f9849bf..5b7adaf 100644
--- a/slang_diagnostic_buffer.cpp
+++ b/slang_diagnostic_buffer.cpp
@@ -39,9 +39,8 @@
}
void DiagnosticBuffer::HandleDiagnostic(
- clang::DiagnosticsEngine::Level DiagLevel,
- clang::Diagnostic const &Info) {
-
+ clang::DiagnosticsEngine::Level DiagLevel,
+ clang::Diagnostic const &Info) {
clang::SourceLocation const &SrcLoc = Info.getLocation();
// 100 is enough for storing general diagnosis message
diff --git a/slang_diagnostic_buffer.h b/slang_diagnostic_buffer.h
index e4eeaab..e065927 100644
--- a/slang_diagnostic_buffer.h
+++ b/slang_diagnostic_buffer.h
@@ -38,7 +38,7 @@
public:
DiagnosticBuffer();
- DiagnosticBuffer(DiagnosticBuffer const &src);
+ explicit DiagnosticBuffer(DiagnosticBuffer const &src);
virtual ~DiagnosticBuffer();
@@ -58,6 +58,6 @@
}
};
-}
+} // namespace slang
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_DIAGNOSTIC_BUFFER_H_ NOLINT
diff --git a/slang_pragma_recorder.h b/slang_pragma_recorder.h
index 5b9cdda..3b3f447 100644
--- a/slang_pragma_recorder.h
+++ b/slang_pragma_recorder.h
@@ -49,6 +49,6 @@
clang::PragmaIntroducerKind Introducer,
clang::Token &FirstToken);
};
-}
+} // namespace slang
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_PRAGMA_RECORDER_H_ NOLINT
diff --git a/slang_rs.h b/slang_rs.h
index c7e4c2d..b2ef41d 100644
--- a/slang_rs.h
+++ b/slang_rs.h
@@ -144,6 +144,6 @@
virtual ~SlangRS();
};
-}
+} // namespace slang
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_H_ NOLINT
diff --git a/slang_rs_backend.cpp b/slang_rs_backend.cpp
index 6602130..ba9c26b 100644
--- a/slang_rs_backend.cpp
+++ b/slang_rs_backend.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2010, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -60,7 +60,8 @@
mAllowRSPrefix(AllowRSPrefix),
mExportVarMetadata(NULL),
mExportFuncMetadata(NULL),
- mExportForEachMetadata(NULL),
+ mExportForEachNameMetadata(NULL),
+ mExportForEachSignatureMetadata(NULL),
mExportTypeMetadata(NULL),
mRSObjectSlotsMetadata(NULL),
mRSOptimizationMetadata(NULL),
@@ -78,7 +79,7 @@
return;
}
-void RSBackend::HandleTopLevelDecl(clang::DeclGroupRef D) {
+bool RSBackend::HandleTopLevelDecl(clang::DeclGroupRef D) {
// Disallow user-defined functions with prefix "rs"
if (!mAllowRSPrefix) {
// Iterate all function declarations in the program.
@@ -107,8 +108,7 @@
}
}
- Backend::HandleTopLevelDecl(D);
- return;
+ return Backend::HandleTopLevelDecl(D);
}
namespace {
@@ -161,13 +161,13 @@
int version = mContext->getVersion();
if (version == 0) {
// Not setting a version is an error
- mDiagEngine.Report(mDiagEngine.getCustomDiagID(
- clang::DiagnosticsEngine::Error,
- "Missing pragma for version in source file"));
- } else if (version > 1) {
- mDiagEngine.Report(mDiagEngine.getCustomDiagID(
- clang::DiagnosticsEngine::Error,
- "Pragma for version in source file must be set to 1"));
+ mDiagEngine.Report(
+ mSourceMgr.getLocForEndOfFile(mSourceMgr.getMainFileID()),
+ mDiagEngine.getCustomDiagID(
+ clang::DiagnosticsEngine::Error,
+ "missing pragma for version in source file"));
+ } else {
+ slangAssert(version == 1);
}
// Create a static global destructor if necessary (to handle RS object
@@ -418,10 +418,16 @@
// Dump export function info
if (mContext->hasExportForEach()) {
- if (mExportForEachMetadata == NULL)
- mExportForEachMetadata =
+ if (mExportForEachNameMetadata == NULL) {
+ mExportForEachNameMetadata =
+ M->getOrInsertNamedMetadata(RS_EXPORT_FOREACH_NAME_MN);
+ }
+ if (mExportForEachSignatureMetadata == NULL) {
+ mExportForEachSignatureMetadata =
M->getOrInsertNamedMetadata(RS_EXPORT_FOREACH_MN);
+ }
+ llvm::SmallVector<llvm::Value*, 1> ExportForEachName;
llvm::SmallVector<llvm::Value*, 1> ExportForEachInfo;
for (RSContext::const_export_foreach_iterator
@@ -431,11 +437,18 @@
I++) {
const RSExportForEach *EFE = *I;
+ ExportForEachName.push_back(
+ llvm::MDString::get(mLLVMContext, EFE->getName().c_str()));
+
+ mExportForEachNameMetadata->addOperand(
+ llvm::MDNode::get(mLLVMContext, ExportForEachName));
+ ExportForEachName.clear();
+
ExportForEachInfo.push_back(
llvm::MDString::get(mLLVMContext,
- llvm::utostr_32(EFE->getMetadataEncoding())));
+ llvm::utostr_32(EFE->getSignatureMetadata())));
- mExportForEachMetadata->addOperand(
+ mExportForEachSignatureMetadata->addOperand(
llvm::MDNode::get(mLLVMContext, ExportForEachInfo));
ExportForEachInfo.clear();
}
diff --git a/slang_rs_backend.h b/slang_rs_backend.h
index 1982223..58e4535 100644
--- a/slang_rs_backend.h
+++ b/slang_rs_backend.h
@@ -1,5 +1,5 @@
/*
- * Copyright 2010, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -49,7 +49,8 @@
llvm::NamedMDNode *mExportVarMetadata;
llvm::NamedMDNode *mExportFuncMetadata;
- llvm::NamedMDNode *mExportForEachMetadata;
+ llvm::NamedMDNode *mExportForEachNameMetadata;
+ llvm::NamedMDNode *mExportForEachSignatureMetadata;
llvm::NamedMDNode *mExportTypeMetadata;
llvm::NamedMDNode *mExportElementMetadata;
llvm::NamedMDNode *mRSObjectSlotsMetadata;
@@ -64,7 +65,7 @@
return mContext->getTargetAPI();
}
- virtual void HandleTopLevelDecl(clang::DeclGroupRef D);
+ virtual bool HandleTopLevelDecl(clang::DeclGroupRef D);
virtual void HandleTranslationUnitPre(clang::ASTContext &C);
@@ -83,6 +84,6 @@
virtual ~RSBackend();
};
-}
+} // namespace slang
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_BACKEND_H_ NOLINT
diff --git a/slang_rs_context.cpp b/slang_rs_context.cpp
index 980038c..242ecb1 100644
--- a/slang_rs_context.cpp
+++ b/slang_rs_context.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2010, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -116,20 +116,17 @@
return false;
}
- if (RSExportForEach::isRSForEachFunc(mTargetAPI, FD)) {
+ if (RSExportForEach::isSpecialRSFunc(mTargetAPI, FD)) {
+ // Do not reflect specialized functions like init, dtor, or graphics root.
+ return RSExportForEach::validateSpecialFuncDecl(mTargetAPI,
+ getDiagnostics(), FD);
+ } else if (RSExportForEach::isRSForEachFunc(mTargetAPI, FD)) {
RSExportForEach *EFE = RSExportForEach::Create(this, FD);
if (EFE == NULL)
return false;
else
mExportForEach.push_back(EFE);
return true;
- } else if (RSExportForEach::isSpecialRSFunc(FD)) {
- // Do not reflect specialized RS functions like init or graphics root.
- if (!RSExportForEach::validateSpecialFuncDecl(mTargetAPI,
- getDiagnostics(), FD)) {
- return false;
- }
- return true;
}
RSExportFunc *EF = RSExportFunc::Create(this, FD);
@@ -186,6 +183,42 @@
return (ET != NULL);
}
+
+// Possibly re-order ForEach exports (maybe generating a dummy "root" function).
+// We require "root" to be listed as slot 0 of our exported compute kernels,
+// so this only needs to be created if we have other non-root kernels.
+void RSContext::cleanupForEach() {
+ bool foundNonRoot = false;
+ ExportForEachList::iterator begin = mExportForEach.begin();
+
+ for (ExportForEachList::iterator I = begin, E = mExportForEach.end();
+ I != E;
+ I++) {
+ RSExportForEach *EFE = *I;
+ if (!EFE->getName().compare("root")) {
+ if (I == begin) {
+ // Nothing to do, since it is the first function
+ return;
+ }
+
+ mExportForEach.erase(I);
+ mExportForEach.push_front(EFE);
+ return;
+ } else {
+ foundNonRoot = true;
+ }
+ }
+
+ // If we found a non-root kernel, but no root() function, we need to add a
+ // dummy version (so that script->script calls of rsForEach don't behave
+ // erratically).
+ if (foundNonRoot) {
+ RSExportForEach *DummyRoot = RSExportForEach::CreateDummyRoot(this);
+ mExportForEach.push_front(DummyRoot);
+ }
+}
+
+
bool RSContext::processExport() {
bool valid = true;
@@ -217,6 +250,10 @@
}
}
+ if (valid) {
+ cleanupForEach();
+ }
+
// Finally, export type forcely set to be exported by user
for (NeedExportTypeSet::const_iterator EI = mNeedExportTypes.begin(),
EE = mNeedExportTypes.end();
@@ -258,9 +295,14 @@
((OutputPackageName.empty()) ? mReflectJavaPackageName :
OutputPackageName);
if (PackageName.empty()) {
- std::cerr << "Error: Missing \"#pragma rs "
- << "java_package_name(com.foo.bar)\" in "
- << InputFileName << std::endl;
+ clang::DiagnosticsEngine *DiagEngine = getDiagnostics();
+ const clang::SourceManager *SM = getSourceManager();
+ DiagEngine->Report(
+ SM->getLocForEndOfFile(SM->getMainFileID()),
+ DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
+ "missing \"#pragma rs "
+ "java_package_name(com.foo.bar)\" "
+ "in source file"));
return false;
}
diff --git a/slang_rs_context.h b/slang_rs_context.h
index 030338b..4024300 100644
--- a/slang_rs_context.h
+++ b/slang_rs_context.h
@@ -89,6 +89,8 @@
bool processExportFunc(const clang::FunctionDecl *FD);
bool processExportType(const llvm::StringRef &Name);
+ void cleanupForEach();
+
ExportVarList mExportVars;
ExportFuncList mExportFuncs;
ExportForEachList mExportForEach;
diff --git a/slang_rs_export_foreach.cpp b/slang_rs_export_foreach.cpp
index 0dbf954..3b759b4 100644
--- a/slang_rs_export_foreach.cpp
+++ b/slang_rs_export_foreach.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2011, The Android Open Source Project
+ * Copyright 2011-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -59,20 +59,30 @@
clang::ASTContext &C = Context->getASTContext();
clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
- if (!isRootRSFunc(FD)) {
- slangAssert(false && "must be called on compute root function!");
- }
-
numParams = FD->getNumParams();
slangAssert(numParams > 0);
- // Compute root functions are required to return a void type for now
+ if (Context->getTargetAPI() < SLANG_JB_TARGET_API) {
+ if (!isRootRSFunc(FD)) {
+ DiagEngine->Report(
+ clang::FullSourceLoc(FD->getLocation(), DiagEngine->getSourceManager()),
+ DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
+ "Non-root compute kernel %0() is "
+ "not supported in SDK levels %1-%2"))
+ << FD->getName()
+ << SLANG_MINIMUM_TARGET_API
+ << (SLANG_JB_TARGET_API - 1);
+ return false;
+ }
+ }
+
+ // Compute kernel functions are required to return a void type for now
if (FD->getResultType().getCanonicalType() != C.VoidTy) {
DiagEngine->Report(
clang::FullSourceLoc(FD->getLocation(), DiagEngine->getSourceManager()),
DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
- "compute root() is required to return a "
- "void type"));
+ "Compute kernel %0() is required to return a "
+ "void type")) << FD->getName();
valid = false;
}
@@ -104,8 +114,8 @@
clang::FullSourceLoc(FD->getLocation(),
DiagEngine->getSourceManager()),
DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
- "Compute root() must have at least one "
- "parameter for in or out"));
+ "Compute kernel %0() must have at least one "
+ "parameter for in or out")) << FD->getName();
valid = false;
}
@@ -128,9 +138,9 @@
clang::FullSourceLoc(PVD->getLocation(),
DiagEngine->getSourceManager()),
DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
- "Unexpected root() parameter '%0' "
- "of type '%1'"))
- << PVD->getName() << PVD->getType().getAsString();
+ "Unexpected kernel %0() parameter '%1' "
+ "of type '%2'"))
+ << FD->getName() << PVD->getName() << PVD->getType().getAsString();
valid = false;
} else {
llvm::StringRef ParamName = PVD->getName();
@@ -162,9 +172,9 @@
clang::FullSourceLoc(PVD->getLocation(),
DiagEngine->getSourceManager()),
DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
- "Unexpected root() parameter '%0' "
- "of type '%1'"))
- << PVD->getName() << PVD->getType().getAsString();
+ "Unexpected kernel %0() parameter '%1' "
+ "of type '%2'"))
+ << FD->getName() << PVD->getName() << PVD->getType().getAsString();
valid = false;
}
}
@@ -173,36 +183,36 @@
i++;
}
- mMetadataEncoding = 0;
+ mSignatureMetadata = 0;
if (valid) {
// Set up the bitwise metadata encoding for runtime argument passing.
- mMetadataEncoding |= (mIn ? 0x01 : 0);
- mMetadataEncoding |= (mOut ? 0x02 : 0);
- mMetadataEncoding |= (mUsrData ? 0x04 : 0);
- mMetadataEncoding |= (mX ? 0x08 : 0);
- mMetadataEncoding |= (mY ? 0x10 : 0);
+ mSignatureMetadata |= (mIn ? 0x01 : 0);
+ mSignatureMetadata |= (mOut ? 0x02 : 0);
+ mSignatureMetadata |= (mUsrData ? 0x04 : 0);
+ mSignatureMetadata |= (mX ? 0x08 : 0);
+ mSignatureMetadata |= (mY ? 0x10 : 0);
}
if (Context->getTargetAPI() < SLANG_ICS_TARGET_API) {
// APIs before ICS cannot skip between parameters. It is ok, however, for
// them to omit further parameters (i.e. skipping X is ok if you skip Y).
- if (mMetadataEncoding != 0x1f && // In, Out, UsrData, X, Y
- mMetadataEncoding != 0x0f && // In, Out, UsrData, X
- mMetadataEncoding != 0x07 && // In, Out, UsrData
- mMetadataEncoding != 0x03 && // In, Out
- mMetadataEncoding != 0x01) { // In
+ if (mSignatureMetadata != 0x1f && // In, Out, UsrData, X, Y
+ mSignatureMetadata != 0x0f && // In, Out, UsrData, X
+ mSignatureMetadata != 0x07 && // In, Out, UsrData
+ mSignatureMetadata != 0x03 && // In, Out
+ mSignatureMetadata != 0x01) { // In
DiagEngine->Report(
clang::FullSourceLoc(FD->getLocation(),
DiagEngine->getSourceManager()),
DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
- "Compute root() targeting SDK levels "
- "%0-%1 may not skip parameters"))
- << SLANG_MINIMUM_TARGET_API << (SLANG_ICS_TARGET_API-1);
+ "Compute kernel %0() targeting SDK levels "
+ "%1-%2 may not skip parameters"))
+ << FD->getName() << SLANG_MINIMUM_TARGET_API
+ << (SLANG_ICS_TARGET_API - 1);
valid = false;
}
}
-
return valid;
}
@@ -214,7 +224,7 @@
slangAssert(!Name.empty() && "Function must have a name");
- FE = new RSExportForEach(Context, Name, FD);
+ FE = new RSExportForEach(Context, Name);
if (!FE->validateAndConstructParams(Context, FD)) {
return NULL;
@@ -293,30 +303,64 @@
return FE;
}
-bool RSExportForEach::isRSForEachFunc(int targetAPI,
- const clang::FunctionDecl *FD) {
- // We currently support only compute root() being exported via forEach
+RSExportForEach *RSExportForEach::CreateDummyRoot(RSContext *Context) {
+ slangAssert(Context);
+ llvm::StringRef Name = "root";
+ RSExportForEach *FE = new RSExportForEach(Context, Name);
+ FE->mDummyRoot = true;
+ return FE;
+}
+
+bool RSExportForEach::isGraphicsRootRSFunc(int targetAPI,
+ const clang::FunctionDecl *FD) {
if (!isRootRSFunc(FD)) {
return false;
}
if (FD->getNumParams() == 0) {
- // Graphics compute function
- return false;
+ // Graphics root function
+ return true;
}
- // Handle legacy graphics root functions.
+ // Check for legacy graphics root function (with single parameter).
if ((targetAPI < SLANG_ICS_TARGET_API) && (FD->getNumParams() == 1)) {
- const clang::ParmVarDecl *PVD = FD->getParamDecl(0);
- clang::QualType QT = PVD->getType().getCanonicalType();
const clang::QualType &IntType = FD->getASTContext().IntTy;
- if ((FD->getResultType().getCanonicalType() == IntType) &&
- (QT == IntType)) {
- return false;
+ if (FD->getResultType().getCanonicalType() == IntType) {
+ return true;
}
}
- return true;
+ return false;
+}
+
+bool RSExportForEach::isRSForEachFunc(int targetAPI,
+ const clang::FunctionDecl *FD) {
+ if (isGraphicsRootRSFunc(targetAPI, FD)) {
+ return false;
+ }
+
+ // Check if first parameter is a pointer (which is required for ForEach).
+ unsigned int numParams = FD->getNumParams();
+
+ if (numParams > 0) {
+ const clang::ParmVarDecl *PVD = FD->getParamDecl(0);
+ clang::QualType QT = PVD->getType().getCanonicalType();
+
+ if (QT->isPointerType()) {
+ return true;
+ }
+
+ // Any non-graphics root() is automatically a ForEach candidate.
+ // At this point, however, we know that it is not going to be a valid
+ // compute root() function (due to not having a pointer parameter). We
+ // still want to return true here, so that we can issue appropriate
+ // diagnostics.
+ if (isRootRSFunc(FD)) {
+ return true;
+ }
+ }
+
+ return false;
}
bool
@@ -326,26 +370,34 @@
slangAssert(DiagEngine && FD);
bool valid = true;
const clang::ASTContext &C = FD->getASTContext();
+ const clang::QualType &IntType = FD->getASTContext().IntTy;
- if (isRootRSFunc(FD)) {
- unsigned int numParams = FD->getNumParams();
- if (numParams == 0) {
- // Graphics root function, so verify that it returns an int
- if (FD->getResultType().getCanonicalType() != C.IntTy) {
+ if (isGraphicsRootRSFunc(targetAPI, FD)) {
+ if ((targetAPI < SLANG_ICS_TARGET_API) && (FD->getNumParams() == 1)) {
+ // Legacy graphics root function
+ const clang::ParmVarDecl *PVD = FD->getParamDecl(0);
+ clang::QualType QT = PVD->getType().getCanonicalType();
+ if (QT != IntType) {
DiagEngine->Report(
- clang::FullSourceLoc(FD->getLocation(),
+ clang::FullSourceLoc(PVD->getLocation(),
DiagEngine->getSourceManager()),
DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
- "root(void) is required to return "
- "an int for graphics usage"));
+ "invalid parameter type for legacy "
+ "graphics root() function: %0"))
+ << PVD->getType();
valid = false;
}
- } else if ((targetAPI < SLANG_ICS_TARGET_API) && (numParams == 1)) {
- // Legacy graphics root function
- // This has already been validated in isRSForEachFunc().
- } else {
- slangAssert(false &&
- "Should not call validateSpecialFuncDecl() on compute root()");
+ }
+
+ // Graphics root function, so verify that it returns an int
+ if (FD->getResultType().getCanonicalType() != IntType) {
+ DiagEngine->Report(
+ clang::FullSourceLoc(FD->getLocation(),
+ DiagEngine->getSourceManager()),
+ DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error,
+ "root() is required to return "
+ "an int for graphics usage"));
+ valid = false;
}
} else if (isInitRSFunc(FD) || isDtorRSFunc(FD)) {
if (FD->getNumParams() != 0) {
diff --git a/slang_rs_export_foreach.h b/slang_rs_export_foreach.h
index bb9c1a0..c8b1dd0 100644
--- a/slang_rs_export_foreach.h
+++ b/slang_rs_export_foreach.h
@@ -1,5 +1,5 @@
/*
- * Copyright 2011, The Android Open Source Project
+ * Copyright 2011-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -43,7 +43,7 @@
RSExportType *mOutType;
size_t numParams;
- unsigned int mMetadataEncoding;
+ unsigned int mSignatureMetadata;
const clang::ParmVarDecl *mIn;
const clang::ParmVarDecl *mOut;
@@ -53,14 +53,15 @@
const clang::ParmVarDecl *mZ;
const clang::ParmVarDecl *mAr;
+ bool mDummyRoot;
+
// TODO(all): Add support for LOD/face when we have them
- RSExportForEach(RSContext *Context, const llvm::StringRef &Name,
- const clang::FunctionDecl *FD)
+ RSExportForEach(RSContext *Context, const llvm::StringRef &Name)
: RSExportable(Context, RSExportable::EX_FOREACH),
mName(Name.data(), Name.size()), mParamPacketType(NULL), mInType(NULL),
- mOutType(NULL), numParams(0), mMetadataEncoding(0),
+ mOutType(NULL), numParams(0), mSignatureMetadata(0),
mIn(NULL), mOut(NULL), mUsrData(NULL),
- mX(NULL), mY(NULL), mZ(NULL), mAr(NULL) {
+ mX(NULL), mY(NULL), mZ(NULL), mAr(NULL), mDummyRoot(false) {
return;
}
@@ -71,6 +72,8 @@
static RSExportForEach *Create(RSContext *Context,
const clang::FunctionDecl *FD);
+ static RSExportForEach *CreateDummyRoot(RSContext *Context);
+
inline const std::string &getName() const {
return mName;
}
@@ -103,8 +106,12 @@
return mParamPacketType;
}
- inline unsigned int getMetadataEncoding() const {
- return mMetadataEncoding;
+ inline unsigned int getSignatureMetadata() const {
+ return mSignatureMetadata;
+ }
+
+ inline bool isDummyRoot() const {
+ return mDummyRoot;
}
typedef RSExportRecordType::const_field_iterator const_param_iterator;
@@ -148,10 +155,15 @@
return Name.equals(FuncDtor);
}
+ static bool isGraphicsRootRSFunc(int targetAPI,
+ const clang::FunctionDecl *FD);
+
static bool isRSForEachFunc(int targetAPI, const clang::FunctionDecl *FD);
- inline static bool isSpecialRSFunc(const clang::FunctionDecl *FD) {
- return isRootRSFunc(FD) || isInitRSFunc(FD) || isDtorRSFunc(FD);
+ inline static bool isSpecialRSFunc(int targetAPI,
+ const clang::FunctionDecl *FD) {
+ return isGraphicsRootRSFunc(targetAPI, FD) || isInitRSFunc(FD) ||
+ isDtorRSFunc(FD);
}
static bool validateSpecialFuncDecl(int targetAPI,
diff --git a/slang_rs_export_type.cpp b/slang_rs_export_type.cpp
index 0c28e30..753e6de 100644
--- a/slang_rs_export_type.cpp
+++ b/slang_rs_export_type.cpp
@@ -116,12 +116,11 @@
}
static const clang::Type *TypeExportableHelper(
- clang::Type const *T,
- llvm::SmallPtrSet<clang::Type const *, 8> &SPS,
- clang::DiagnosticsEngine *DiagEngine,
- clang::VarDecl const *VD,
- clang::RecordDecl const *TopLevelRecord)
-{
+ clang::Type const *T,
+ llvm::SmallPtrSet<clang::Type const *, 8> &SPS,
+ clang::DiagnosticsEngine *DiagEngine,
+ clang::VarDecl const *VD,
+ clang::RecordDecl const *TopLevelRecord) {
// Normalize first
if ((T = GET_CANONICAL_TYPE(T)) == NULL)
return NULL;
diff --git a/slang_rs_export_var.cpp b/slang_rs_export_var.cpp
index 5145a3a..5fbf107 100644
--- a/slang_rs_export_var.cpp
+++ b/slang_rs_export_var.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2010, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -20,45 +20,84 @@
#include "llvm/ADT/APSInt.h"
-#include "slang_assert.h"
#include "slang_rs_context.h"
#include "slang_rs_export_type.h"
namespace slang {
+namespace {
+
+static clang::DiagnosticBuilder ReportVarError(RSContext *Context,
+ const clang::SourceLocation Loc,
+ const char *Message) {
+ clang::DiagnosticsEngine *DiagEngine = Context->getDiagnostics();
+ const clang::SourceManager *SM = Context->getSourceManager();
+ return DiagEngine->Report(clang::FullSourceLoc(Loc, *SM),
+ DiagEngine->getCustomDiagID(clang::DiagnosticsEngine::Error, Message));
+}
+
+} // namespace
+
RSExportVar::RSExportVar(RSContext *Context,
const clang::VarDecl *VD,
const RSExportType *ET)
: RSExportable(Context, RSExportable::EX_VAR),
mName(VD->getName().data(), VD->getName().size()),
mET(ET),
- mIsConst(false) {
+ mIsConst(false),
+ mArraySize(0),
+ mNumInits(0) {
// mInit - Evaluate initializer expression
const clang::Expr *Initializer = VD->getAnyInitializer();
if (Initializer != NULL) {
switch (ET->getClass()) {
case RSExportType::ExportClassPrimitive:
case RSExportType::ExportClassVector: {
- Initializer->Evaluate(mInit, Context->getASTContext());
+ Initializer->EvaluateAsRValue(mInit, Context->getASTContext());
break;
}
case RSExportType::ExportClassPointer: {
- if (Initializer->isNullPointerConstant
- (Context->getASTContext(),
- clang::Expr::NPC_ValueDependentIsNotNull)
- )
+ if (Initializer->isNullPointerConstant(Context->getASTContext(),
+ clang::Expr::NPC_ValueDependentIsNotNull)) {
mInit.Val = clang::APValue(llvm::APSInt(1));
- else
- Initializer->Evaluate(mInit, Context->getASTContext());
+ } else {
+ if (!Initializer->EvaluateAsRValue(mInit, Context->getASTContext())) {
+ ReportVarError(Context, Initializer->getExprLoc(),
+ "initializer is not an R-value");
+ }
+ }
break;
}
+ case RSExportType::ExportClassConstantArray: {
+ const clang::InitListExpr *IList =
+ static_cast<const clang::InitListExpr*>(Initializer);
+ if (!IList) {
+ ReportVarError(Context, VD->getLocation(),
+ "Unable to find initializer list");
+ break;
+ }
+ const RSExportConstantArrayType *ECAT =
+ static_cast<const RSExportConstantArrayType*>(ET);
+ mArraySize = ECAT->getSize();
+ mNumInits = IList->getNumInits();
+ for (unsigned int i = 0; i < mNumInits; i++) {
+ clang::Expr::EvalResult tempInit;
+ if (!IList->getInit(i)->EvaluateAsRValue(tempInit,
+ Context->getASTContext())) {
+ ReportVarError(Context, IList->getInit(i)->getExprLoc(),
+ "initializer is not an R-value");
+ }
+ mInitArray.push_back(tempInit);
+ }
+ break;
+ }
+ case RSExportType::ExportClassMatrix:
case RSExportType::ExportClassRecord: {
- // No action
- fprintf(stderr, "RSExportVar::RSExportVar : Reflection of initializer "
- "to variable '%s' (of type '%s') is unsupported "
- "currently.\n",
- mName.c_str(),
- ET->getName().c_str());
+ ReportVarError(Context, VD->getLocation(),
+ "Reflection of initializer to variable '%0' (of type "
+ "'%1') is unsupported currently.")
+ << mName
+ << ET->getName();
break;
}
default: {
diff --git a/slang_rs_export_var.h b/slang_rs_export_var.h
index 61d997a..221551f 100644
--- a/slang_rs_export_var.h
+++ b/slang_rs_export_var.h
@@ -1,5 +1,5 @@
/*
- * Copyright 2010, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@
#include "llvm/ADT/StringRef.h"
+#include "slang_assert.h"
#include "slang_rs_exportable.h"
namespace clang {
@@ -43,6 +44,10 @@
clang::Expr::EvalResult mInit;
+ size_t mArraySize;
+ size_t mNumInits;
+ llvm::SmallVector<clang::Expr::EvalResult, 0> mInitArray;
+
RSExportVar(RSContext *Context,
const clang::VarDecl *VD,
const RSExportType *ET);
@@ -53,6 +58,13 @@
inline bool isConst() const { return mIsConst; }
inline const clang::APValue &getInit() const { return mInit.Val; }
+
+ inline size_t getArraySize() const { return mArraySize; }
+ inline size_t getNumInits() const { return mNumInits; }
+ inline const clang::APValue &getInitArray(unsigned int i) const {
+ slangAssert(i < mNumInits);
+ return mInitArray[i].Val;
+ }
}; // RSExportVar
} // namespace slang
diff --git a/slang_rs_exportable.h b/slang_rs_exportable.h
index 0a2c066..04b5f88 100644
--- a/slang_rs_exportable.h
+++ b/slang_rs_exportable.h
@@ -59,6 +59,6 @@
virtual ~RSExportable() { }
};
-}
+} // namespace slang
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_EXPORTABLE_H_ NOLINT
diff --git a/slang_rs_metadata.h b/slang_rs_metadata.h
index a0d3540..4d2bd0d 100644
--- a/slang_rs_metadata.h
+++ b/slang_rs_metadata.h
@@ -1,5 +1,5 @@
/*
- * Copyright 2010, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -29,6 +29,8 @@
#define RS_OBJECT_SLOTS_MN "#rs_object_slots"
+#define RS_EXPORT_FOREACH_NAME_MN "#rs_export_foreach_name"
+
#define RS_EXPORT_FOREACH_MN "#rs_export_foreach"
#define OPTIMIZATION_LEVEL_MN "#optimization_level"
diff --git a/slang_rs_metadata_spec_encoder.cpp b/slang_rs_metadata_spec_encoder.cpp
index 45c54e5..2e51325 100644
--- a/slang_rs_metadata_spec_encoder.cpp
+++ b/slang_rs_metadata_spec_encoder.cpp
@@ -110,7 +110,8 @@
int finalize();
};
-}
+
+} // namespace
RSMetadataEncoderInternal::RSMetadataEncoderInternal(llvm::Module *M)
: mModule(M),
diff --git a/slang_rs_object_ref_count.cpp b/slang_rs_object_ref_count.cpp
index f4ce728..bb37a03 100644
--- a/slang_rs_object_ref_count.cpp
+++ b/slang_rs_object_ref_count.cpp
@@ -1110,7 +1110,7 @@
RSExportPrimitiveType::DataTypeRSFont)->getASTContext();
clang::SourceLocation Loc = AS->getExprLoc();
- clang::SourceLocation StartLoc = AS->getExprLoc();
+ clang::SourceLocation StartLoc = AS->getLHS()->getExprLoc();
clang::Stmt *UpdatedStmt = NULL;
if (!RSExportPrimitiveType::IsRSObjectType(QT.getTypePtr())) {
@@ -1344,6 +1344,7 @@
case RSExportPrimitiveType::DataTypeRSSampler:
case RSExportPrimitiveType::DataTypeRSScript:
case RSExportPrimitiveType::DataTypeRSMesh:
+ case RSExportPrimitiveType::DataTypeRSPath:
case RSExportPrimitiveType::DataTypeRSProgramFragment:
case RSExportPrimitiveType::DataTypeRSProgramVertex:
case RSExportPrimitiveType::DataTypeRSProgramRaster:
@@ -1399,7 +1400,7 @@
clang::Expr *InitExpr =
new(C) clang::InitListExpr(C, Loc, InitVals, N * N, Loc);
InitExpr->setType(C.getConstantArrayType(FloatTy,
- llvm::APInt(32, 4),
+ llvm::APInt(32, N * N),
clang::ArrayType::Normal,
/* EltTypeQuals = */0));
diff --git a/slang_rs_pragma_handler.cpp b/slang_rs_pragma_handler.cpp
index 077ddab..597136d 100644
--- a/slang_rs_pragma_handler.cpp
+++ b/slang_rs_pragma_handler.cpp
@@ -140,7 +140,17 @@
class RSVersionPragmaHandler : public RSPragmaHandler {
private:
- void handleInt(const int v) {
+ void handleInt(clang::Preprocessor &PP,
+ clang::Token &Tok,
+ const int v) {
+ if (v != 1) {
+ PP.Diag(Tok,
+ PP.getDiagnostics().getCustomDiagID(
+ clang::DiagnosticsEngine::Error,
+ "pragma for version in source file must be set to 1"));
+ mContext->setVersion(1);
+ return;
+ }
std::stringstream ss;
ss << v;
mContext->addPragma(this->getName(), ss.str());
@@ -218,8 +228,13 @@
// Should be end immediately
if (PragmaToken.isNot(clang::tok::eod))
- fprintf(stderr, "RSPragmaHandler::handleNonParamPragma: "
- "expected a clang::tok::eod\n");
+ if (PragmaToken.isNot(clang::tok::r_paren)) {
+ PP.Diag(PragmaToken,
+ PP.getDiagnostics().getCustomDiagID(
+ clang::DiagnosticsEngine::Error,
+ "expected a ')'"));
+ return;
+ }
return;
}
@@ -239,17 +254,22 @@
if (PragmaToken.isNot(clang::tok::r_paren)) {
// Eat the whole string literal
clang::StringLiteralParser StringLiteral(&PragmaToken, 1, PP);
- if (StringLiteral.hadError)
- fprintf(stderr, "RSPragmaHandler::handleOptionalStringLiteralParamPragma"
- ": illegal string literal\n");
- else
+ if (StringLiteral.hadError) {
+ // Diagnostics will be generated automatically
+ return;
+ } else {
this->handleItem(std::string(StringLiteral.GetString()));
+ }
// The current token should be clang::tok::r_para
PP.LexUnexpandedToken(PragmaToken);
- if (PragmaToken.isNot(clang::tok::r_paren))
- fprintf(stderr, "RSPragmaHandler::handleOptionalStringLiteralParamPragma"
- ": expected a ')'\n");
+ if (PragmaToken.isNot(clang::tok::r_paren)) {
+ PP.Diag(PragmaToken,
+ PP.getDiagnostics().getCustomDiagID(
+ clang::DiagnosticsEngine::Error,
+ "expected a ')'"));
+ return;
+ }
} else {
// If no argument, remove the license
this->handleItem("");
@@ -264,8 +284,11 @@
PP.LexUnexpandedToken(PragmaToken);
// Now, the current token must be clang::tok::lpara
- if (PragmaToken.isNot(clang::tok::l_paren))
+ if (PragmaToken.isNot(clang::tok::l_paren)) {
+ // If no argument, set the version to 0
+ this->handleInt(PP, PragmaToken, 0);
return;
+ }
PP.LexUnexpandedToken(PragmaToken);
if (PragmaToken.is(clang::tok::numeric_constant)) {
@@ -273,22 +296,25 @@
PragmaToken.getLiteralData() + PragmaToken.getLength(),
PragmaToken.getLocation(), PP);
if (NumericLiteral.hadError) {
- fprintf(stderr, "RSPragmaHandler::handleIntegerParamPragma"
- ": illegal numeric literal\n");
+ // Diagnostics will be generated automatically
+ return;
} else {
llvm::APInt Val(32, 0);
NumericLiteral.GetIntegerValue(Val);
- this->handleInt(static_cast<int>(Val.getSExtValue()));
+ this->handleInt(PP, PragmaToken, static_cast<int>(Val.getSExtValue()));
}
PP.LexUnexpandedToken(PragmaToken);
} else {
// If no argument, set the version to 0
- this->handleInt(0);
+ this->handleInt(PP, PragmaToken, 0);
}
if (PragmaToken.isNot(clang::tok::r_paren)) {
- fprintf(stderr, "RSPragmaHandler::handleIntegerParamPragma"
- ": expected a ')'\n");
+ PP.Diag(PragmaToken,
+ PP.getDiagnostics().getCustomDiagID(
+ clang::DiagnosticsEngine::Error,
+ "expected a ')'"));
+ return;
}
do {
diff --git a/slang_rs_pragma_handler.h b/slang_rs_pragma_handler.h
index 1865db7..09d7fab 100644
--- a/slang_rs_pragma_handler.h
+++ b/slang_rs_pragma_handler.h
@@ -45,7 +45,8 @@
}
virtual void handleItem(const std::string &Item) { return; }
- virtual void handleInt(const int v) { return; }
+ virtual void handleInt(clang::Preprocessor &PP, clang::Token &Tok,
+ const int v) { return; }
// Handle pragma like #pragma rs [name] ([item #1],[item #2],...,[item #i])
void handleItemListPragma(clang::Preprocessor &PP,
diff --git a/slang_rs_reflect_utils.cpp b/slang_rs_reflect_utils.cpp
index 29c3998..f36b6ad 100644
--- a/slang_rs_reflect_utils.cpp
+++ b/slang_rs_reflect_utils.cpp
@@ -267,4 +267,4 @@
fclose(pfout);
return ret;
}
-}
+} // namespace slang
diff --git a/slang_rs_reflect_utils.h b/slang_rs_reflect_utils.h
index d2a831e..f6cfd57 100644
--- a/slang_rs_reflect_utils.h
+++ b/slang_rs_reflect_utils.h
@@ -77,6 +77,6 @@
// Generate the bit code accessor Java source file.
static bool GenerateBitCodeAccessor(const BitCodeAccessorContext &context);
};
-}
+} // namespace slang
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_REFLECT_UTILS_H_ NOLINT
diff --git a/slang_rs_reflection.cpp b/slang_rs_reflection.cpp
index 5266c1b..7d4c6b1 100644
--- a/slang_rs_reflection.cpp
+++ b/slang_rs_reflection.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright 2010-2011, The Android Open Source Project
+ * Copyright 2010-2012, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
#include <cctype>
#include <algorithm>
+#include <sstream>
#include <string>
#include <utility>
@@ -47,9 +48,11 @@
#define RS_TYPE_ITEM_BUFFER_NAME "mItemArray"
#define RS_TYPE_ITEM_BUFFER_PACKER_NAME "mIOBuffer"
+#define RS_TYPE_ELEMENT_REF_NAME "mElementCache"
#define RS_EXPORT_VAR_INDEX_PREFIX "mExportVarIdx_"
#define RS_EXPORT_VAR_PREFIX "mExportVar_"
+#define RS_EXPORT_VAR_CONST_PREFIX "const_"
#define RS_EXPORT_FUNC_INDEX_PREFIX "mExportFuncIdx_"
#define RS_EXPORT_FOREACH_INDEX_PREFIX "mExportForEachIdx_"
@@ -102,6 +105,7 @@
"Sampler", // RSExportPrimitiveType::DataTypeRSSampler
"Script", // RSExportPrimitiveType::DataTypeRSScript
"Mesh", // RSExportPrimitiveType::DataTypeRSMesh
+ "Path", // RSExportPrimitiveType::DataTypeRSPath
"ProgramFragment", // RSExportPrimitiveType::DataTypeRSProgramFragment
"ProgramVertex", // RSExportPrimitiveType::DataTypeRSProgramVertex
"ProgramRaster", // RSExportPrimitiveType::DataTypeRSProgramRaster
@@ -302,6 +306,7 @@
"addObj", // RSExportPrimitiveType::DataTypeRSSampler
"addObj", // RSExportPrimitiveType::DataTypeRSScript
"addObj", // RSExportPrimitiveType::DataTypeRSMesh
+ "addObj", // RSExportPrimitiveType::DataTypeRSPath
"addObj", // RSExportPrimitiveType::DataTypeRSProgramFragment
"addObj", // RSExportPrimitiveType::DataTypeRSProgramVertex
"addObj", // RSExportPrimitiveType::DataTypeRSProgramRaster
@@ -317,7 +322,7 @@
return NULL;
}
-static std::string GetTypeName(const RSExportType *ET) {
+static std::string GetTypeName(const RSExportType *ET, bool Brackets = true) {
switch (ET->getClass()) {
case RSExportType::ExportClassPrimitive: {
return GetPrimitiveTypeName(
@@ -342,7 +347,9 @@
const RSExportConstantArrayType* CAT =
static_cast<const RSExportConstantArrayType*>(ET);
std::string ElementTypeName = GetTypeName(CAT->getElementType());
- ElementTypeName.append("[]");
+ if (Brackets) {
+ ElementTypeName.append("[]");
+ }
return ElementTypeName;
}
case RSExportType::ExportClassRecord: {
@@ -418,6 +425,7 @@
"Element.SAMPLER", // RSExportPrimitiveType::DataTypeRSSampler
"Element.SCRIPT", // RSExportPrimitiveType::DataTypeRSScript
"Element.MESH", // RSExportPrimitiveType::DataTypeRSMesh
+ "Element.PATH", // RSExportPrimitiveType::DataTypeRSPath
"Element.PROGRAM_FRAGMENT",
// RSExportPrimitiveType::DataTypeRSProgramFragment
"Element.PROGRAM_VERTEX",
@@ -540,6 +548,8 @@
"Element.DataType.RS_SCRIPT",
// RSExportPrimitiveType::DataTypeRSMesh
"Element.DataType.RS_MESH",
+ // RSExportPrimitiveType::DataTypeRSPath
+ "Element.DataType.RS_PATH",
// RSExportPrimitiveType::DataTypeRSProgramFragment
"Element.DataType.RS_PROGRAM_FRAGMENT",
// RSExportPrimitiveType::DataTypeRSProgramVertex
@@ -589,6 +599,7 @@
"SAMPLER", // RSExportPrimitiveType::DataTypeRSSampler
"SCRIPT", // RSExportPrimitiveType::DataTypeRSScript
"MESH", // RSExportPrimitiveType::DataTypeRSMesh
+ "PATH", // RSExportPrimitiveType::DataTypeRSPath
"PROGRAM_FRAGMENT", // RSExportPrimitiveType::DataTypeRSProgramFragment
"PROGRAM_VERTEX", // RSExportPrimitiveType::DataTypeRSProgramVertex
"PROGRAM_RASTER", // RSExportPrimitiveType::DataTypeRSProgramRaster
@@ -665,8 +676,23 @@
I != E;
I++) {
const RSExportVar *EV = *I;
- if (!EV->getInit().isUninit())
+ if (!EV->getInit().isUninit()) {
genInitExportVariable(C, EV->getType(), EV->getName(), EV->getInit());
+ } else if (EV->getArraySize()) {
+ // Always create an initial zero-init array object.
+ C.indent() << RS_EXPORT_VAR_PREFIX << EV->getName() << " = new "
+ << GetTypeName(EV->getType(), false) << "["
+ << EV->getArraySize() << "];" << std::endl;
+ size_t NumInits = EV->getNumInits();
+ const RSExportConstantArrayType *ECAT =
+ static_cast<const RSExportConstantArrayType*>(EV->getType());
+ const RSExportType *ET = ECAT->getElementType();
+ for (size_t i = 0; i < NumInits; i++) {
+ std::stringstream Name;
+ Name << EV->getName() << "[" << i << "]";
+ genInitExportVariable(C, ET, Name.str(), EV->getInitArray(i));
+ }
+ }
}
for (RSContext::const_export_foreach_iterator
@@ -713,13 +739,7 @@
return;
}
-void RSReflection::genInitPrimitiveExportVariable(
- Context &C,
- const std::string &VarName,
- const clang::APValue &Val) {
- slangAssert(!Val.isUninit() && "Not a valid initializer");
-
- C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
+void RSReflection::genInitValue(Context &C, const clang::APValue &Val) {
switch (Val.getKind()) {
case clang::APValue::Int: {
llvm::APInt api = Val.getInt();
@@ -751,6 +771,16 @@
slangAssert(false && "Unknown kind of initializer");
}
}
+}
+
+void RSReflection::genInitPrimitiveExportVariable(
+ Context &C,
+ const std::string &VarName,
+ const clang::APValue &Val) {
+ slangAssert(!Val.isUninit() && "Not a valid initializer");
+
+ C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
+ genInitValue(C, Val);
C.out() << ";" << std::endl;
return;
@@ -805,10 +835,14 @@
}
break;
}
+ case clang::APValue::MemberPointer:
case clang::APValue::Uninitialized:
case clang::APValue::ComplexInt:
case clang::APValue::ComplexFloat:
- case clang::APValue::LValue: {
+ case clang::APValue::LValue:
+ case clang::APValue::Array:
+ case clang::APValue::Struct:
+ case clang::APValue::Union: {
slangAssert(false && "Unexpected type of value of initializer.");
}
}
@@ -943,6 +977,15 @@
}
void RSReflection::genExportForEach(Context &C, const RSExportForEach *EF) {
+ if (EF->isDummyRoot()) {
+ // Skip reflection for dummy root() kernels. Note that we have to
+ // advance the next slot number for ForEach, however.
+ C.indent() << "//private final static int "RS_EXPORT_FOREACH_INDEX_PREFIX
+ << EF->getName() << " = " << C.getNextExportForEachSlot() << ";"
+ << std::endl;
+ return;
+ }
+
C.indent() << "private final static int "RS_EXPORT_FOREACH_INDEX_PREFIX
<< EF->getName() << " = " << C.getNextExportForEachSlot() << ";"
<< std::endl;
@@ -1169,8 +1212,20 @@
C.indent() << "private " << TypeName << " "RS_EXPORT_VAR_PREFIX
<< EV->getName() << ";" << std::endl;
- // set_*()
- if (!EV->isConst()) {
+ if (EV->isConst()) {
+ C.indent() << "public final static " << TypeName
+ << " " RS_EXPORT_VAR_CONST_PREFIX << EV->getName() << " = ";
+ const clang::APValue &Val = EV->getInit();
+ if (EPT->getType() == RSExportPrimitiveType::DataTypeBoolean) {
+ slangAssert((Val.getKind() == clang::APValue::Int) &&
+ "Bool type has wrong initial APValue");
+ C.out() << ((Val.getInt().getSExtValue() == 0) ? "false" : "true");
+ } else {
+ genInitValue(C, Val);
+ }
+ C.out() << ";" << std::endl;
+ } else {
+ // set_*()
C.startFunction(Context::AM_Public,
false,
"void",
@@ -1616,6 +1671,9 @@
";" << std::endl;
C.indent() << "private FieldPacker "RS_TYPE_ITEM_BUFFER_PACKER_NAME";"
<< std::endl;
+ C.indent() << "private static java.lang.ref.WeakReference<Element> "
+ RS_TYPE_ELEMENT_REF_NAME
+ " = new java.lang.ref.WeakReference<Element>(null);" << std::endl;
genTypeClassConstructor(C, ERT);
genTypeClassCopyToArrayLocal(C, ERT);
@@ -1685,9 +1743,35 @@
"createElement",
1,
"RenderScript", RenderScriptVar);
- genBuildElement(C, "eb", ERT, RenderScriptVar, /* IsInline = */false);
+
+ // TODO(all): Fix weak-refs + multi-context issue.
+ // C.indent() << "Element e = " << RS_TYPE_ELEMENT_REF_NAME
+ // << ".get();" << std::endl;
+ // C.indent() << "if (e != null) return e;" << std::endl;
+ genBuildElement(C, "eb", ERT, RenderScriptVar, /* IsInline = */true);
+ C.indent() << "return eb.create();" << std::endl;
+ // C.indent() << "e = eb.create();" << std::endl;
+ // C.indent() << RS_TYPE_ELEMENT_REF_NAME
+ // << " = new java.lang.ref.WeakReference<Element>(e);"
+ // << std::endl;
+ // C.indent() << "return e;" << std::endl;
C.endFunction();
+
+ // private with element
+ C.startFunction(Context::AM_Private,
+ false,
+ NULL,
+ C.getClassName(),
+ 1,
+ "RenderScript", RenderScriptVar);
+ C.indent() << RS_TYPE_ITEM_BUFFER_NAME" = null;" << std::endl;
+ C.indent() << RS_TYPE_ITEM_BUFFER_PACKER_NAME" = null;" << std::endl;
+ C.indent() << "mElement = createElement(" << RenderScriptVar << ");"
+ << std::endl;
+ C.endFunction();
+
+ // 1D without usage
C.startFunction(Context::AM_Public,
false,
NULL,
@@ -1704,6 +1788,7 @@
C.indent() << "init(" << RenderScriptVar << ", count);" << std::endl;
C.endFunction();
+ // 1D with usage
C.startFunction(Context::AM_Public,
false,
NULL,
@@ -1721,9 +1806,109 @@
C.indent() << "init(" << RenderScriptVar << ", count, usages);" << std::endl;
C.endFunction();
- return;
+
+ // create1D with usage
+ C.startFunction(Context::AM_Public,
+ true,
+ C.getClassName().c_str(),
+ "create1D",
+ 3,
+ "RenderScript", RenderScriptVar,
+ "int", "dimX",
+ "int", "usages");
+ C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "("
+ << RenderScriptVar << ");" << std::endl;
+ C.indent() << "obj.mAllocation = Allocation.createSized("
+ "rs, obj.mElement, dimX, usages);" << std::endl;
+ C.indent() << "return obj;" << std::endl;
+ C.endFunction();
+
+ // create1D without usage
+ C.startFunction(Context::AM_Public,
+ true,
+ C.getClassName().c_str(),
+ "create1D",
+ 2,
+ "RenderScript", RenderScriptVar,
+ "int", "dimX");
+ C.indent() << "return create1D(" << RenderScriptVar
+ << ", dimX, Allocation.USAGE_SCRIPT);" << std::endl;
+ C.endFunction();
+
+
+ // create2D without usage
+ C.startFunction(Context::AM_Public,
+ true,
+ C.getClassName().c_str(),
+ "create2D",
+ 3,
+ "RenderScript", RenderScriptVar,
+ "int", "dimX",
+ "int", "dimY");
+ C.indent() << "return create2D(" << RenderScriptVar
+ << ", dimX, dimY, Allocation.USAGE_SCRIPT);" << std::endl;
+ C.endFunction();
+
+ // create2D with usage
+ C.startFunction(Context::AM_Public,
+ true,
+ C.getClassName().c_str(),
+ "create2D",
+ 4,
+ "RenderScript", RenderScriptVar,
+ "int", "dimX",
+ "int", "dimY",
+ "int", "usages");
+
+ C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "("
+ << RenderScriptVar << ");" << std::endl;
+ C.indent() << "Type.Builder b = new Type.Builder(rs, obj.mElement);"
+ << std::endl;
+ C.indent() << "b.setX(dimX);" << std::endl;
+ C.indent() << "b.setY(dimY);" << std::endl;
+ C.indent() << "Type t = b.create();" << std::endl;
+ C.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);"
+ << std::endl;
+ C.indent() << "return obj;" << std::endl;
+ C.endFunction();
+
+
+ // createTypeBuilder
+ C.startFunction(Context::AM_Public,
+ true,
+ "Type.Builder",
+ "createTypeBuilder",
+ 1,
+ "RenderScript", RenderScriptVar);
+ C.indent() << "Element e = createElement(" << RenderScriptVar << ");"
+ << std::endl;
+ C.indent() << "return new Type.Builder(rs, e);" << std::endl;
+ C.endFunction();
+
+ // createCustom with usage
+ C.startFunction(Context::AM_Public,
+ true,
+ C.getClassName().c_str(),
+ "createCustom",
+ 3,
+ "RenderScript", RenderScriptVar,
+ "Type.Builder", "tb",
+ "int", "usages");
+ C.indent() << C.getClassName() << " obj = new " << C.getClassName() << "("
+ << RenderScriptVar << ");" << std::endl;
+ C.indent() << "Type t = tb.create();" << std::endl;
+ C.indent() << "if (t.getElement() != obj.mElement) {" << std::endl;
+ C.indent() << " throw new RSIllegalArgumentException("
+ "\"Type.Builder did not match expected element type.\");"
+ << std::endl;
+ C.indent() << "}" << std::endl;
+ C.indent() << "obj.mAllocation = Allocation.createTyped(rs, t, usages);"
+ << std::endl;
+ C.indent() << "return obj;" << std::endl;
+ C.endFunction();
}
+
void RSReflection::genTypeClassCopyToArray(Context &C,
const RSExportRecordType *ERT) {
C.startFunction(Context::AM_Private,
@@ -2093,11 +2278,14 @@
EB_ADD(NewElementBuilderName << ".create()");
}
- // There is padding within the field type
- genAddPaddingToElementBuiler(C,
- (FieldAllocSize - FieldStoreSize),
- ElementBuilderName,
- RenderScriptVar);
+ if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) {
+ // There is padding within the field type. This is only necessary
+ // for HC-targeted APIs.
+ genAddPaddingToElementBuiler(C,
+ (FieldAllocSize - FieldStoreSize),
+ ElementBuilderName,
+ RenderScriptVar);
+ }
Pos = FieldOffset + FieldAllocSize;
}
@@ -2145,6 +2333,13 @@
const std::string &OutputBCFileName) {
Context *C = NULL;
std::string ResourceId = "";
+ std::string PaddingPrefix = "";
+
+ if (mRSContext->getTargetAPI() < SLANG_ICS_TARGET_API) {
+ PaddingPrefix = "#padding_";
+ } else {
+ PaddingPrefix = "#rs_padding_";
+ }
if (!GetClassNameFromFileName(OutputBCFileName, ResourceId))
return false;
@@ -2154,10 +2349,10 @@
if (OutputPackageName.empty() || OutputPackageName == "-")
C = new Context(OutputPathBase, InputFileName, "<Package Name>",
- ResourceId, true);
+ ResourceId, PaddingPrefix, true);
else
C = new Context(OutputPathBase, InputFileName, OutputPackageName,
- ResourceId, false);
+ ResourceId, PaddingPrefix, false);
if (C != NULL) {
std::string ErrorMsg, ScriptClassName;
@@ -2209,7 +2404,7 @@
/************************** RSReflection::Context **************************/
const char *const RSReflection::Context::ApacheLicenseNote =
"/*\n"
- " * Copyright (C) 2011 The Android Open Source Project\n"
+ " * Copyright (C) 2011-2012 The Android Open Source Project\n"
" *\n"
" * Licensed under the Apache License, Version 2.0 (the \"License\");\n"
" * you may not use this file except in compliance with the License.\n"
diff --git a/slang_rs_reflection.h b/slang_rs_reflection.h
index 4e75208..139cb71 100644
--- a/slang_rs_reflection.h
+++ b/slang_rs_reflection.h
@@ -59,6 +59,7 @@
std::string mPackageName;
std::string mResourceId;
+ std::string mPaddingPrefix;
std::string mClassName;
@@ -112,12 +113,14 @@
const std::string &InputRSFile,
const std::string &PackageName,
const std::string &ResourceId,
+ const std::string &PaddingPrefix,
bool UseStdout)
: mVerbose(true),
mOutputPathBase(OutputPathBase),
mInputRSFile(InputRSFile),
mPackageName(PackageName),
mResourceId(ResourceId),
+ mPaddingPrefix(PaddingPrefix),
mLicenseNote(ApacheLicenseNote),
mUseStdout(UseStdout) {
clear();
@@ -155,7 +158,7 @@
// Will remove later due to field name information is not necessary for
// C-reflect-to-Java
inline std::string createPaddingField() {
- return "#padding_" + llvm::itostr(mPaddingFieldIndex++);
+ return mPaddingPrefix + llvm::itostr(mPaddingFieldIndex++);
}
inline void setLicenseNote(const std::string &LicenseNote) {
@@ -218,16 +221,17 @@
std::string &ErrorMsg);
void genScriptClassConstructor(Context &C);
- void genInitBoolExportVariable(Context &C,
- const std::string &VarName,
- const clang::APValue &Val);
- void genInitPrimitiveExportVariable(Context &C,
- const std::string &VarName,
- const clang::APValue &Val);
- void genInitExportVariable(Context &C,
- const RSExportType *ET,
- const std::string &VarName,
- const clang::APValue &Val);
+ static void genInitBoolExportVariable(Context &C,
+ const std::string &VarName,
+ const clang::APValue &Val);
+ static void genInitPrimitiveExportVariable(Context &C,
+ const std::string &VarName,
+ const clang::APValue &Val);
+ static void genInitExportVariable(Context &C,
+ const RSExportType *ET,
+ const std::string &VarName,
+ const clang::APValue &Val);
+ static void genInitValue(Context &C, const clang::APValue &Val);
void genExportVariable(Context &C, const RSExportVar *EV);
void genPrimitiveTypeExportVariable(Context &C, const RSExportVar *EV);
void genPointerTypeExportVariable(Context &C, const RSExportVar *EV);
diff --git a/slang_rs_type_spec.h b/slang_rs_type_spec.h
index bd7b157..6e0a3a1 100644
--- a/slang_rs_type_spec.h
+++ b/slang_rs_type_spec.h
@@ -56,6 +56,7 @@
ENUM_RS_OBJECT_DATA_TYPE(RSSampler, "rs_sampler") \
ENUM_RS_OBJECT_DATA_TYPE(RSScript, "rs_script") \
ENUM_RS_OBJECT_DATA_TYPE(RSMesh, "rs_mesh") \
+ ENUM_RS_OBJECT_DATA_TYPE(RSPath, "rs_path") \
ENUM_RS_OBJECT_DATA_TYPE(RSProgramFragment, "rs_program_fragment") \
ENUM_RS_OBJECT_DATA_TYPE(RSProgramVertex, "rs_program_vertex") \
ENUM_RS_OBJECT_DATA_TYPE(RSProgramRaster, "rs_program_raster") \
diff --git a/slang_utils.h b/slang_utils.h
index 4d8e862..9a123e3 100644
--- a/slang_utils.h
+++ b/slang_utils.h
@@ -33,6 +33,6 @@
static bool CreateDirectoryWithParents(llvm::StringRef Dir,
std::string* Error);
};
-}
+} // namespace slang
#endif // _COMPILE_SLANG_SLANG_UTILS_H_ NOLINT
diff --git a/slang_version.h b/slang_version.h
index bea18a4..2d9f74f 100644
--- a/slang_version.h
+++ b/slang_version.h
@@ -18,16 +18,20 @@
#define _FRAMEWORKS_COMPILE_SLANG_SLANG_VERSION_H_
// API levels used by the standard Android SDK.
-//
-// 11 - Honeycomb
-// 12 - Honeycomb MR1
-// 13 - Honeycomb MR2
-// 14 - Ice Cream Sandwich
-// ...
-#define SLANG_MINIMUM_TARGET_API 11
-#define SLANG_MAXIMUM_TARGET_API RS_VERSION
+// MR -> Maintenance Release
+// HC -> Honeycomb
+// ICS -> Ice Cream Sandwich
+// JB -> Jelly Bean
+enum SlangTargetAPI {
+ SLANG_MINIMUM_TARGET_API = 11,
+ SLANG_HC_TARGET_API = 11,
+ SLANG_HC_MR1_TARGET_API = 12,
+ SLANG_HC_MR2_TARGET_API = 13,
+ SLANG_ICS_TARGET_API = 14,
+ SLANG_ICS_MR1_TARGET_API = 15,
+ SLANG_JB_TARGET_API = 16,
+ SLANG_MAXIMUM_TARGET_API = RS_VERSION
+};
// Note that RS_VERSION is defined at build time (see Android.mk for details).
-#define SLANG_ICS_TARGET_API 14
-
#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_VERSION_H_ NOLINT
diff --git a/tests/F_Werror/Werror.rs b/tests/F_Werror/Werror.rs
new file mode 100644
index 0000000..f069d88
--- /dev/null
+++ b/tests/F_Werror/Werror.rs
@@ -0,0 +1,7 @@
+// -Werror
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+static int foo() {
+}
+
diff --git a/tests/F_Werror/stderr.txt.expect b/tests/F_Werror/stderr.txt.expect
new file mode 100644
index 0000000..b58dd9f
--- /dev/null
+++ b/tests/F_Werror/stderr.txt.expect
@@ -0,0 +1 @@
+Werror.rs:6:1: error: control reaches end of non-void function
diff --git a/tests/F_Werror/stdout.txt.expect b/tests/F_Werror/stdout.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/F_Werror/stdout.txt.expect
diff --git a/tests/F_bad_version_pragma/bad_version_pragma.rs b/tests/F_bad_version_pragma/bad_version_pragma.rs
index be8c0ef..10bdf7e 100644
--- a/tests/F_bad_version_pragma/bad_version_pragma.rs
+++ b/tests/F_bad_version_pragma/bad_version_pragma.rs
@@ -1,7 +1,6 @@
#pragma version(2000)
+#pragma version
+#pragma version(1
+#pragma version(1a)
#pragma rs java_package_name(foo)
-int root(int num) {
- return 10;
-}
-
diff --git a/tests/F_bad_version_pragma/stderr.txt.expect b/tests/F_bad_version_pragma/stderr.txt.expect
index b90b0b0..68fc9ac 100644
--- a/tests/F_bad_version_pragma/stderr.txt.expect
+++ b/tests/F_bad_version_pragma/stderr.txt.expect
@@ -1 +1,4 @@
-error: Pragma for version in source file must be set to 1
+bad_version_pragma.rs:1:17: error: pragma for version in source file must be set to 1
+bad_version_pragma.rs:2:16: error: pragma for version in source file must be set to 1
+bad_version_pragma.rs:3:18: error: expected a ')'
+bad_version_pragma.rs:4:18: error: invalid digit 'a' in decimal constant
diff --git a/tests/F_global_init/global_init.rs b/tests/F_global_init/global_init.rs
new file mode 100644
index 0000000..8d35184
--- /dev/null
+++ b/tests/F_global_init/global_init.rs
@@ -0,0 +1,20 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+int ia[4] = {0, 1};
+int i = 2;
+int2 i2 = {3, 4};
+float fa[4] = {0.0, 1.0, 2.9999};
+char ca[2] = {'a', 7};
+bool ba[2] = {false, true};
+
+const int ic = 99;
+
+int ica[2] = {ic, 1000};
+
+struct s {
+ int i;
+};
+
+struct s myS = {9};
+
diff --git a/tests/F_global_init/stderr.txt.expect b/tests/F_global_init/stderr.txt.expect
new file mode 100644
index 0000000..19360f4
--- /dev/null
+++ b/tests/F_global_init/stderr.txt.expect
@@ -0,0 +1 @@
+global_init.rs:19:10: error: Reflection of initializer to variable 'myS' (of type 's') is unsupported currently.
diff --git a/tests/F_global_init/stdout.txt.expect b/tests/F_global_init/stdout.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/F_global_init/stdout.txt.expect
diff --git a/tests/F_multi_export_errors/stderr.txt.expect b/tests/F_multi_export_errors/stderr.txt.expect
index f982c30..a39a137 100644
--- a/tests/F_multi_export_errors/stderr.txt.expect
+++ b/tests/F_multi_export_errors/stderr.txt.expect
@@ -1,3 +1,3 @@
multi_export_errors.rs:4:5: error: init(void) is required to have a void return type
-multi_export_errors.rs:8:6: error: root(void) is required to return an int for graphics usage
+multi_export_errors.rs:8:6: error: root() is required to return an int for graphics usage
multi_export_errors.rs:11:5: error: invokable non-static functions are required to return void
diff --git a/tests/F_no_java_package_name/stderr.txt.expect b/tests/F_no_java_package_name/stderr.txt.expect
index 50a184c..cbf8c5f 100644
--- a/tests/F_no_java_package_name/stderr.txt.expect
+++ b/tests/F_no_java_package_name/stderr.txt.expect
@@ -1 +1 @@
-Error: Missing "#pragma rs java_package_name(com.foo.bar)" in no_java_package_name.rs
+no_java_package_name.rs:6:1: error: missing "#pragma rs java_package_name(com.foo.bar)" in source file
diff --git a/tests/F_no_version_pragma/stderr.txt.expect b/tests/F_no_version_pragma/stderr.txt.expect
index f858520..e326847 100644
--- a/tests/F_no_version_pragma/stderr.txt.expect
+++ b/tests/F_no_version_pragma/stderr.txt.expect
@@ -1 +1 @@
-error: Missing pragma for version in source file
+no_version_pragma.rs:7:1: error: missing pragma for version in source file
diff --git a/tests/F_root_11_ox/stderr.txt.expect b/tests/F_root_11_ox/stderr.txt.expect
index 2e5e9de..1d3fc08 100644
--- a/tests/F_root_11_ox/stderr.txt.expect
+++ b/tests/F_root_11_ox/stderr.txt.expect
@@ -1 +1 @@
-root_11_ox.rs:5:6: error: Compute root() targeting SDK levels 11-13 may not skip parameters
+root_11_ox.rs:5:6: error: Compute kernel root() targeting SDK levels 11-13 may not skip parameters
diff --git a/tests/F_root_compute_int_in/stderr.txt.expect b/tests/F_root_compute_int_in/stderr.txt.expect
index 863bf84..2c0bd7f 100644
--- a/tests/F_root_compute_int_in/stderr.txt.expect
+++ b/tests/F_root_compute_int_in/stderr.txt.expect
@@ -1,2 +1,2 @@
-root_compute_int_in.rs:4:6: error: Compute root() must have at least one parameter for in or out
-root_compute_int_in.rs:4:21: error: Unexpected root() parameter 'in' of type 'const int'
+root_compute_int_in.rs:4:6: error: Compute kernel root() must have at least one parameter for in or out
+root_compute_int_in.rs:4:21: error: Unexpected kernel root() parameter 'in' of type 'const int'
diff --git a/tests/F_root_compute_non_const_usrData/stderr.txt.expect b/tests/F_root_compute_non_const_usrData/stderr.txt.expect
index 7cd483c..6cafd50 100644
--- a/tests/F_root_compute_non_const_usrData/stderr.txt.expect
+++ b/tests/F_root_compute_non_const_usrData/stderr.txt.expect
@@ -1 +1 @@
-root_compute_non_const_usrData.rs:4:44: error: Unexpected root() parameter 'usrData' of type 'void *'
+root_compute_non_const_usrData.rs:4:44: error: Unexpected kernel root() parameter 'usrData' of type 'void *'
diff --git a/tests/F_root_compute_non_ptr_usrData/stderr.txt.expect b/tests/F_root_compute_non_ptr_usrData/stderr.txt.expect
index de0e320..7bfda65 100644
--- a/tests/F_root_compute_non_ptr_usrData/stderr.txt.expect
+++ b/tests/F_root_compute_non_ptr_usrData/stderr.txt.expect
@@ -1 +1 @@
-root_compute_non_ptr_usrData.rs:4:48: error: Unexpected root() parameter 'usrData' of type 'const int'
+root_compute_non_ptr_usrData.rs:4:48: error: Unexpected kernel root() parameter 'usrData' of type 'const int'
diff --git a/tests/F_root_compute_non_uint32_t_xyzar/stderr.txt.expect b/tests/F_root_compute_non_uint32_t_xyzar/stderr.txt.expect
index 11b29e2..5c24e8c 100644
--- a/tests/F_root_compute_non_uint32_t_xyzar/stderr.txt.expect
+++ b/tests/F_root_compute_non_uint32_t_xyzar/stderr.txt.expect
@@ -1,4 +1,4 @@
-root_compute_non_uint32_t_xyzar.rs:5:15: error: Unexpected root() parameter 'x' of type 'int'
-root_compute_non_uint32_t_xyzar.rs:5:24: error: Unexpected root() parameter 'y' of type 'float'
-root_compute_non_uint32_t_xyzar.rs:5:34: error: Unexpected root() parameter 'z' of type 'double'
-root_compute_non_uint32_t_xyzar.rs:5:43: error: Unexpected root() parameter 'ar' of type 'uchar'
+root_compute_non_uint32_t_xyzar.rs:5:15: error: Unexpected kernel root() parameter 'x' of type 'int'
+root_compute_non_uint32_t_xyzar.rs:5:24: error: Unexpected kernel root() parameter 'y' of type 'float'
+root_compute_non_uint32_t_xyzar.rs:5:34: error: Unexpected kernel root() parameter 'z' of type 'double'
+root_compute_non_uint32_t_xyzar.rs:5:43: error: Unexpected kernel root() parameter 'ar' of type 'uchar'
diff --git a/tests/F_root_compute_non_void_ret/stderr.txt.expect b/tests/F_root_compute_non_void_ret/stderr.txt.expect
index f7eaec7..a371330 100644
--- a/tests/F_root_compute_non_void_ret/stderr.txt.expect
+++ b/tests/F_root_compute_non_void_ret/stderr.txt.expect
@@ -1 +1 @@
-root_compute_non_void_ret.rs:4:5: error: compute root() is required to return a void type
+root_compute_non_void_ret.rs:4:5: error: Compute kernel root() is required to return a void type
diff --git a/tests/F_root_compute_really_bad/stderr.txt.expect b/tests/F_root_compute_really_bad/stderr.txt.expect
index 821274c..458f529 100644
--- a/tests/F_root_compute_really_bad/stderr.txt.expect
+++ b/tests/F_root_compute_really_bad/stderr.txt.expect
@@ -1,10 +1,10 @@
-root_compute_really_bad.rs:4:5: error: compute root() is required to return a void type
-root_compute_really_bad.rs:4:5: error: Compute root() must have at least one parameter for in or out
-root_compute_really_bad.rs:4:14: error: Unexpected root() parameter 'ain' of type 'int'
-root_compute_really_bad.rs:4:23: error: Unexpected root() parameter 'aout' of type 'int'
-root_compute_really_bad.rs:4:33: error: Unexpected root() parameter 'usrData' of type 'int'
-root_compute_really_bad.rs:4:48: error: Unexpected root() parameter 'x1' of type 'float'
-root_compute_really_bad.rs:4:59: error: Unexpected root() parameter 'y1' of type 'double'
+root_compute_really_bad.rs:4:5: error: Compute kernel root() is required to return a void type
+root_compute_really_bad.rs:4:5: error: Compute kernel root() must have at least one parameter for in or out
+root_compute_really_bad.rs:4:14: error: Unexpected kernel root() parameter 'ain' of type 'int'
+root_compute_really_bad.rs:4:23: error: Unexpected kernel root() parameter 'aout' of type 'int'
+root_compute_really_bad.rs:4:33: error: Unexpected kernel root() parameter 'usrData' of type 'int'
+root_compute_really_bad.rs:4:48: error: Unexpected kernel root() parameter 'x1' of type 'float'
+root_compute_really_bad.rs:4:59: error: Unexpected kernel root() parameter 'y1' of type 'double'
root_compute_really_bad.rs:5:31: error: Duplicate parameter entry (by position/name): 'x'
-root_compute_really_bad.rs:6:19: error: Unexpected root() parameter 'extra1' of type 'uint32_t'
-root_compute_really_bad.rs:6:36: error: Unexpected root() parameter 'extra2' of type 'uint32_t'
+root_compute_really_bad.rs:6:19: error: Unexpected kernel root() parameter 'extra1' of type 'uint32_t'
+root_compute_really_bad.rs:6:36: error: Unexpected kernel root() parameter 'extra2' of type 'uint32_t'
diff --git a/tests/F_root_compute_too_many_args/stderr.txt.expect b/tests/F_root_compute_too_many_args/stderr.txt.expect
index 70f9499..dc393be 100644
--- a/tests/F_root_compute_too_many_args/stderr.txt.expect
+++ b/tests/F_root_compute_too_many_args/stderr.txt.expect
@@ -1,2 +1,2 @@
-root_compute_too_many_args.rs:6:20: error: Unexpected root() parameter 'extra1' of type 'uint32_t'
-root_compute_too_many_args.rs:6:37: error: Unexpected root() parameter 'extra2' of type 'uint32_t'
+root_compute_too_many_args.rs:6:20: error: Unexpected kernel root() parameter 'extra1' of type 'uint32_t'
+root_compute_too_many_args.rs:6:37: error: Unexpected kernel root() parameter 'extra2' of type 'uint32_t'
diff --git a/tests/F_root_graphics/stderr.txt.expect b/tests/F_root_graphics/stderr.txt.expect
index cf56bad..6b1e04d 100644
--- a/tests/F_root_graphics/stderr.txt.expect
+++ b/tests/F_root_graphics/stderr.txt.expect
@@ -1 +1 @@
-root_graphics.rs:4:6: error: root(void) is required to return an int for graphics usage
+root_graphics.rs:4:6: error: root() is required to return an int for graphics usage
diff --git a/tests/F_root_graphics_13/stderr.txt.expect b/tests/F_root_graphics_13/stderr.txt.expect
index 5670930..74e9ee0 100644
--- a/tests/F_root_graphics_13/stderr.txt.expect
+++ b/tests/F_root_graphics_13/stderr.txt.expect
@@ -1,3 +1 @@
-root_graphics_13.rs:5:5: error: compute root() is required to return a void type
-root_graphics_13.rs:5:5: error: Compute root() must have at least one parameter for in or out
-root_graphics_13.rs:5:5: error: Compute root() targeting SDK levels 11-13 may not skip parameters
+root_graphics_13.rs:5:23: error: invalid parameter type for legacy graphics root() function: 'unsigned int'
diff --git a/tests/F_set_target_api_10/stderr.txt.expect b/tests/F_set_target_api_10/stderr.txt.expect
index 2fcb56b..791030f 100644
--- a/tests/F_set_target_api_10/stderr.txt.expect
+++ b/tests/F_set_target_api_10/stderr.txt.expect
@@ -1 +1 @@
-error: target API level '10' is out of range ('11' - '15')
+error: target API level '10' is out of range ('11' - '16')
diff --git a/tests/F_set_target_api_9000/stderr.txt.expect b/tests/F_set_target_api_9000/stderr.txt.expect
index c1bdd4a..aa95e63 100644
--- a/tests/F_set_target_api_9000/stderr.txt.expect
+++ b/tests/F_set_target_api_9000/stderr.txt.expect
@@ -1 +1 @@
-error: target API level '9000' is out of range ('11' - '15')
+error: target API level '9000' is out of range ('11' - '16')
diff --git a/tests/F_set_target_api_foo/stderr.txt.expect b/tests/F_set_target_api_foo/stderr.txt.expect
index 1aa0561..1c56599 100644
--- a/tests/F_set_target_api_foo/stderr.txt.expect
+++ b/tests/F_set_target_api_foo/stderr.txt.expect
@@ -1 +1 @@
-llvm-rs-cc: error: invalid integral value 'foo' in '-target-api foo'
+error: invalid integral value 'foo' in '-target-api foo'
diff --git a/tests/F_struct_array_copy/stderr.txt.expect b/tests/F_struct_array_copy/stderr.txt.expect
index 8623602..48bc6d7 100644
--- a/tests/F_struct_array_copy/stderr.txt.expect
+++ b/tests/F_struct_array_copy/stderr.txt.expect
@@ -1 +1 @@
-struct_array_copy.rs:35:5: error: Arrays of RS object types within structures cannot be copied
+struct_array_copy.rs:35:8: error: Arrays of RS object types within structures cannot be copied
diff --git a/tests/F_v15_non_root_kernel/stderr.txt.expect b/tests/F_v15_non_root_kernel/stderr.txt.expect
new file mode 100644
index 0000000..fe38dc8
--- /dev/null
+++ b/tests/F_v15_non_root_kernel/stderr.txt.expect
@@ -0,0 +1 @@
+v15_non_root_kernel.rs:5:6: error: Non-root compute kernel foo() is not supported in SDK levels 11-15
diff --git a/tests/F_v15_non_root_kernel/stdout.txt.expect b/tests/F_v15_non_root_kernel/stdout.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/F_v15_non_root_kernel/stdout.txt.expect
diff --git a/tests/F_v15_non_root_kernel/v15_non_root_kernel.rs b/tests/F_v15_non_root_kernel/v15_non_root_kernel.rs
new file mode 100644
index 0000000..d8b903e
--- /dev/null
+++ b/tests/F_v15_non_root_kernel/v15_non_root_kernel.rs
@@ -0,0 +1,6 @@
+// -target-api 15
+#pragma version(1)
+#pragma rs java_package_name(android.renderscript.cts)
+
+void foo(const int *in) {
+}
diff --git a/tests/P_array_init/array_init.rs b/tests/P_array_init/array_init.rs
new file mode 100644
index 0000000..b64e6ea
--- /dev/null
+++ b/tests/P_array_init/array_init.rs
@@ -0,0 +1,16 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+const int ic = 99;
+
+int ica[2] = {ic, 1000};
+
+float fa[4] = {1.0, 9.9999f};
+double da[2] = {7.0, 8.88888};
+char ca[4] = {'a', 7, 'b', 'c'};
+short sa[4] = {1, 1, 2, 3};
+int ia[4] = {5, 8};
+long la[2] = {13, 21};
+long long lla[4] = {34};
+bool ba[3] = {true, false};
+
diff --git a/tests/P_array_init/stderr.txt.expect b/tests/P_array_init/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_array_init/stderr.txt.expect
diff --git a/tests/P_array_init/stdout.txt.expect b/tests/P_array_init/stdout.txt.expect
new file mode 100644
index 0000000..e306a86
--- /dev/null
+++ b/tests/P_array_init/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_array_init.java ...
diff --git a/tests/P_compute/compute.rs b/tests/P_compute/compute.rs
new file mode 100644
index 0000000..9ed58b8
--- /dev/null
+++ b/tests/P_compute/compute.rs
@@ -0,0 +1,12 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+void root(const int *ain, int *aout, const void *usrData,
+ uint32_t x, uint32_t y) {
+}
+
+void bar(int i, float f) {
+}
+
+void foo (int *p) {
+}
diff --git a/tests/P_compute/stderr.txt.expect b/tests/P_compute/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_compute/stderr.txt.expect
diff --git a/tests/P_compute/stdout.txt.expect b/tests/P_compute/stdout.txt.expect
new file mode 100644
index 0000000..041ad8c
--- /dev/null
+++ b/tests/P_compute/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_compute.java ...
diff --git a/tests/P_constant/constant.rs b/tests/P_constant/constant.rs
new file mode 100644
index 0000000..6f98ff1
--- /dev/null
+++ b/tests/P_constant/constant.rs
@@ -0,0 +1,20 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+const float floatTest = 1.99f;
+const double doubleTest = 2.05;
+const char charTest = -8;
+const short shortTest = -16;
+const int intTest = -32;
+const long longTest = 17179869184l; // 1 << 34
+const long long longlongTest = 68719476736l; // 1 << 36
+
+const uchar ucharTest = 8;
+const ushort ushortTest = 16;
+const uint uintTest = 32;
+const ulong ulongTest = 4611686018427387904L;
+const int64_t int64_tTest = -17179869184l; // - 1 << 34
+const uint64_t uint64_tTest = 117179869184l;
+
+const bool boolTest = true;
+
diff --git a/tests/P_constant/stderr.txt.expect b/tests/P_constant/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_constant/stderr.txt.expect
diff --git a/tests/P_constant/stdout.txt.expect b/tests/P_constant/stdout.txt.expect
new file mode 100644
index 0000000..3c27edd
--- /dev/null
+++ b/tests/P_constant/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_constant.java ...
diff --git a/tests/P_dummy_root/dummy_root.rs b/tests/P_dummy_root/dummy_root.rs
new file mode 100644
index 0000000..7731d94
--- /dev/null
+++ b/tests/P_dummy_root/dummy_root.rs
@@ -0,0 +1,5 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+void foo (int *p) {
+}
diff --git a/tests/P_dummy_root/stderr.txt.expect b/tests/P_dummy_root/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_dummy_root/stderr.txt.expect
diff --git a/tests/P_dummy_root/stdout.txt.expect b/tests/P_dummy_root/stdout.txt.expect
new file mode 100644
index 0000000..cbcf1f9
--- /dev/null
+++ b/tests/P_dummy_root/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_dummy_root.java ...
diff --git a/tests/P_ignore_warnings/ignore_warnings.rs b/tests/P_ignore_warnings/ignore_warnings.rs
new file mode 100644
index 0000000..76704d6
--- /dev/null
+++ b/tests/P_ignore_warnings/ignore_warnings.rs
@@ -0,0 +1,7 @@
+// -w
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+static int foo() {
+}
+
diff --git a/tests/P_ignore_warnings/stderr.txt.expect b/tests/P_ignore_warnings/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_ignore_warnings/stderr.txt.expect
diff --git a/tests/P_ignore_warnings/stdout.txt.expect b/tests/P_ignore_warnings/stdout.txt.expect
new file mode 100644
index 0000000..5878c88
--- /dev/null
+++ b/tests/P_ignore_warnings/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_ignore_warnings.java ...
diff --git a/tests/P_ooo_compute/ooo_compute.rs b/tests/P_ooo_compute/ooo_compute.rs
new file mode 100644
index 0000000..961bcd2
--- /dev/null
+++ b/tests/P_ooo_compute/ooo_compute.rs
@@ -0,0 +1,13 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+void bar(int i, float f) {
+}
+
+void foo (int *p) {
+}
+
+void root(const int *ain, int *aout, const void *usrData,
+ uint32_t x, uint32_t y) {
+}
+
diff --git a/tests/P_ooo_compute/stderr.txt.expect b/tests/P_ooo_compute/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_ooo_compute/stderr.txt.expect
diff --git a/tests/P_ooo_compute/stdout.txt.expect b/tests/P_ooo_compute/stdout.txt.expect
new file mode 100644
index 0000000..48de3ac
--- /dev/null
+++ b/tests/P_ooo_compute/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_ooo_compute.java ...
diff --git a/tests/P_set_target_api_11/IN_CTS b/tests/P_set_target_api_11/IN_CTS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_11/IN_CTS
diff --git a/tests/P_set_target_api_11/set_target_api_11.rs b/tests/P_set_target_api_11/set_target_api_11.rs
index ad89b39..d5708b0 100644
--- a/tests/P_set_target_api_11/set_target_api_11.rs
+++ b/tests/P_set_target_api_11/set_target_api_11.rs
@@ -1,4 +1,21 @@
// -target-api 11
#pragma version(1)
-#pragma rs java_package_name(foo)
+#pragma rs java_package_name(android.renderscript.cts)
+
+#if RS_VERSION != 11
+#error Invalid RS_VERSION
+#endif
+
+#define RS_MSG_TEST_PASSED 100
+#define RS_MSG_TEST_FAILED 101
+
+void check(int version) {
+ if (version != RS_VERSION) {
+ rsDebug("version: ", version);
+ rsDebug("RS_VERSION: ", RS_VERSION);
+ rsSendToClient(RS_MSG_TEST_FAILED);
+ } else {
+ rsSendToClientBlocking(RS_MSG_TEST_PASSED);
+ }
+}
diff --git a/tests/P_set_target_api_12/IN_CTS b/tests/P_set_target_api_12/IN_CTS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_12/IN_CTS
diff --git a/tests/P_set_target_api_12/set_target_api_12.rs b/tests/P_set_target_api_12/set_target_api_12.rs
index e380bf0..87b1131 100644
--- a/tests/P_set_target_api_12/set_target_api_12.rs
+++ b/tests/P_set_target_api_12/set_target_api_12.rs
@@ -1,8 +1,21 @@
// -target-api 12
#pragma version(1)
-#pragma rs java_package_name(foo)
+#pragma rs java_package_name(android.renderscript.cts)
#if RS_VERSION != 12
#error Invalid RS_VERSION
#endif
+#define RS_MSG_TEST_PASSED 100
+#define RS_MSG_TEST_FAILED 101
+
+void check(int version) {
+ if (version != RS_VERSION) {
+ rsDebug("version: ", version);
+ rsDebug("RS_VERSION: ", RS_VERSION);
+ rsSendToClient(RS_MSG_TEST_FAILED);
+ } else {
+ rsSendToClientBlocking(RS_MSG_TEST_PASSED);
+ }
+}
+
diff --git a/tests/P_set_target_api_13/IN_CTS b/tests/P_set_target_api_13/IN_CTS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_13/IN_CTS
diff --git a/tests/P_set_target_api_13/set_target_api_13.rs b/tests/P_set_target_api_13/set_target_api_13.rs
index 4fca2a2..f0c3bf9 100644
--- a/tests/P_set_target_api_13/set_target_api_13.rs
+++ b/tests/P_set_target_api_13/set_target_api_13.rs
@@ -1,8 +1,21 @@
// -target-api 13
#pragma version(1)
-#pragma rs java_package_name(foo)
+#pragma rs java_package_name(android.renderscript.cts)
#if RS_VERSION != 13
#error Invalid RS_VERSION
#endif
+#define RS_MSG_TEST_PASSED 100
+#define RS_MSG_TEST_FAILED 101
+
+void check(int version) {
+ if (version != RS_VERSION) {
+ rsDebug("version: ", version);
+ rsDebug("RS_VERSION: ", RS_VERSION);
+ rsSendToClient(RS_MSG_TEST_FAILED);
+ } else {
+ rsSendToClientBlocking(RS_MSG_TEST_PASSED);
+ }
+}
+
diff --git a/tests/P_set_target_api_14/IN_CTS b/tests/P_set_target_api_14/IN_CTS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_14/IN_CTS
diff --git a/tests/P_set_target_api_14/set_target_api_14.rs b/tests/P_set_target_api_14/set_target_api_14.rs
index 3efa329..1139b1a 100644
--- a/tests/P_set_target_api_14/set_target_api_14.rs
+++ b/tests/P_set_target_api_14/set_target_api_14.rs
@@ -1,8 +1,21 @@
// -target-api 14
#pragma version(1)
-#pragma rs java_package_name(foo)
+#pragma rs java_package_name(android.renderscript.cts)
#if RS_VERSION != 14
#error Invalid RS_VERSION
#endif
+#define RS_MSG_TEST_PASSED 100
+#define RS_MSG_TEST_FAILED 101
+
+void check(int version) {
+ if (version != RS_VERSION) {
+ rsDebug("version: ", version);
+ rsDebug("RS_VERSION: ", RS_VERSION);
+ rsSendToClient(RS_MSG_TEST_FAILED);
+ } else {
+ rsSendToClientBlocking(RS_MSG_TEST_PASSED);
+ }
+}
+
diff --git a/tests/P_set_target_api_15/IN_CTS b/tests/P_set_target_api_15/IN_CTS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_15/IN_CTS
diff --git a/tests/P_set_target_api_15/set_target_api_15.rs b/tests/P_set_target_api_15/set_target_api_15.rs
new file mode 100644
index 0000000..cdab0e1
--- /dev/null
+++ b/tests/P_set_target_api_15/set_target_api_15.rs
@@ -0,0 +1,21 @@
+// -target-api 15
+#pragma version(1)
+#pragma rs java_package_name(android.renderscript.cts)
+
+#if RS_VERSION != 15
+#error Invalid RS_VERSION
+#endif
+
+#define RS_MSG_TEST_PASSED 100
+#define RS_MSG_TEST_FAILED 101
+
+void check(int version) {
+ if (version != RS_VERSION) {
+ rsDebug("version: ", version);
+ rsDebug("RS_VERSION: ", RS_VERSION);
+ rsSendToClient(RS_MSG_TEST_FAILED);
+ } else {
+ rsSendToClientBlocking(RS_MSG_TEST_PASSED);
+ }
+}
+
diff --git a/tests/P_set_target_api_15/stderr.txt.expect b/tests/P_set_target_api_15/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_15/stderr.txt.expect
diff --git a/tests/P_set_target_api_15/stdout.txt.expect b/tests/P_set_target_api_15/stdout.txt.expect
new file mode 100644
index 0000000..56a2d73
--- /dev/null
+++ b/tests/P_set_target_api_15/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_set_target_api_15.java ...
diff --git a/tests/P_set_target_api_16/IN_CTS b/tests/P_set_target_api_16/IN_CTS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_16/IN_CTS
diff --git a/tests/P_set_target_api_16/set_target_api_16.rs b/tests/P_set_target_api_16/set_target_api_16.rs
new file mode 100644
index 0000000..9281b9f
--- /dev/null
+++ b/tests/P_set_target_api_16/set_target_api_16.rs
@@ -0,0 +1,21 @@
+// -target-api 16
+#pragma version(1)
+#pragma rs java_package_name(android.renderscript.cts)
+
+#if RS_VERSION != 16
+#error Invalid RS_VERSION
+#endif
+
+#define RS_MSG_TEST_PASSED 100
+#define RS_MSG_TEST_FAILED 101
+
+void check(int version) {
+ if (version != RS_VERSION) {
+ rsDebug("version: ", version);
+ rsDebug("RS_VERSION: ", RS_VERSION);
+ rsSendToClient(RS_MSG_TEST_FAILED);
+ } else {
+ rsSendToClientBlocking(RS_MSG_TEST_PASSED);
+ }
+}
+
diff --git a/tests/P_set_target_api_16/stderr.txt.expect b/tests/P_set_target_api_16/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_set_target_api_16/stderr.txt.expect
diff --git a/tests/P_set_target_api_16/stdout.txt.expect b/tests/P_set_target_api_16/stdout.txt.expect
new file mode 100644
index 0000000..ddf6298
--- /dev/null
+++ b/tests/P_set_target_api_16/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_set_target_api_16.java ...
diff --git a/tests/test.py b/tests/test.py
index f6368a9..a804763 100755
--- a/tests/test.py
+++ b/tests/test.py
@@ -1,17 +1,17 @@
#!/usr/bin/python2.4
#
-# Copyright 2010 Google Inc. All Rights Reserved.
+# Copyright 2010-2012 Google Inc. All Rights Reserved.
-"""RenderScript Compiler Test.
+"""Renderscript Compiler Test.
-Runs subdirectories of tests for the RenderScript compiler.
+Runs subdirectories of tests for the Renderscript compiler.
"""
import filecmp
import glob
import os
+import re
import shutil
-import string
import subprocess
import sys
@@ -23,13 +23,11 @@
return
verbose = 0
cleanup = 1
+ updateCTS = 0
-def CompareFiles(filename):
- """Compares filename and filename.expect for equality."""
- actual = filename
- expect = filename + '.expect'
-
+def CompareFiles(actual, expect):
+ """Compares actual and expect for equality."""
if not os.path.isfile(actual):
if Options.verbose:
print 'Could not find %s' % actual
@@ -42,14 +40,21 @@
return filecmp.cmp(actual, expect, False)
+def UpdateFiles(src, dst):
+ """Update dst if it is different from src."""
+ if not CompareFiles(src, dst):
+ print 'Copying from %s to %s' % (src, dst)
+ shutil.copyfile(src, dst)
+
+
def GetCommandLineArgs(filename):
- """Extracts command line arguments from first comment line in a file"""
+ """Extracts command line arguments from first comment line in a file."""
f = open(filename, 'r')
line = f.readline()
if line[0] == '/' and line [1] == '/':
- return string.strip(line[2:])
+ return line[2:].strip()
else:
- return ""
+ return ''
def ExecTest(dirname):
@@ -75,7 +80,7 @@
# Extra command line arguments can be placed as // comments at the start of
# any .rs file. We automatically bundle up all of these extra args and invoke
# llvm-rs-cc with them.
- extra_args_str = ""
+ extra_args_str = ''
for rs_file in rs_files:
extra_args_str += GetCommandLineArgs(rs_file)
extra_args = extra_args_str.split()
@@ -127,15 +132,28 @@
if Options.verbose:
print 'Test Directory name should start with an F or a P'
- if not CompareFiles('stdout.txt'):
+ if not CompareFiles('stdout.txt', 'stdout.txt.expect'):
passed = False
if Options.verbose:
print 'stdout is different'
- if not CompareFiles('stderr.txt'):
+ if not CompareFiles('stderr.txt', 'stderr.txt.expect'):
passed = False
if Options.verbose:
print 'stderr is different'
+ if Options.updateCTS:
+ # Copy resulting files to appropriate CTS directory (if different).
+ if passed and glob.glob('IN_CTS'):
+ cts_path = '../../../../../cts/'
+ cts_res_raw_path = cts_path + 'tests/res/raw/'
+ cts_src_path = cts_path + 'tests/tests/renderscript/src/'
+ for bc_src in glob.glob('tmp/*.bc'):
+ bc_dst = re.sub('tmp\/', cts_res_raw_path, bc_src, 1)
+ UpdateFiles(bc_src, bc_dst)
+ for java_src in glob.glob('tmp/android/renderscript/cts/*.java'):
+ java_dst = re.sub('tmp\/', cts_src_path, java_src, 1)
+ UpdateFiles(java_src, java_dst)
+
if Options.cleanup:
try:
os.remove('stdout.txt')
@@ -149,12 +167,14 @@
def Usage():
+ """Print out usage information."""
print ('Usage: %s [OPTION]... [TESTNAME]...'
- 'RenderScript Compiler Test Harness\n'
+ 'Renderscript Compiler Test Harness\n'
'Runs TESTNAMEs (all tests by default)\n'
'Available Options:\n'
' -h, --help Help message\n'
' -n, --no-cleanup Don\'t clean up after running tests\n'
+ ' -u, --update-cts Update CTS test versions\n'
' -v, --verbose Verbose output\n'
) % (sys.argv[0]),
return
@@ -172,6 +192,8 @@
return 0
elif arg in ('-n', '--no-cleanup'):
Options.cleanup = 0
+ elif arg in ('-u', '--update-cts'):
+ Options.updateCTS = 1
elif arg in ('-v', '--verbose'):
Options.verbose += 1
else: