resolved conflicts for merge of 9e7e17b0 to master
Change-Id: I7d910038eaf3e7b43330253a7275a8496c26c9ad
diff --git a/Android.mk b/Android.mk
index a783ba9..2347d3d 100644
--- a/Android.mk
+++ b/Android.mk
@@ -40,6 +40,7 @@
libLLVMipo \
libLLVMBitWriter \
libLLVMBitWriter_2_9 \
+ libLLVMBitWriter_2_9_func \
libLLVMBitReader \
libLLVMARMCodeGen \
libLLVMARMAsmPrinter \
@@ -71,7 +72,8 @@
libclangLex \
libclangFrontend \
libclangBasic \
- libLLVMSupport
+ libLLVMSupport \
+ libLLVMVectorize
# Static library libslang for host
# ========================================================
@@ -209,7 +211,6 @@
RSClangBuiltinEnums.inc \
RSDataTypeEnums.inc \
RSDataElementEnums.inc \
- RSDataKindEnums.inc \
RSMatrixTypeEnums.inc \
RSObjectTypeEnums.inc
@@ -228,7 +229,9 @@
slang_rs_export_foreach.cpp \
slang_rs_object_ref_count.cpp \
slang_rs_reflection.cpp \
- slang_rs_reflect_utils.cpp \
+ slang_rs_reflection_base.cpp \
+ slang_rs_reflection_cpp.cpp \
+ slang_rs_reflect_utils.cpp
LOCAL_STATIC_LIBRARIES := \
libclangDriver libslang \
diff --git a/BitWriter_2_9/BitcodeWriter.cpp b/BitWriter_2_9/BitcodeWriter.cpp
index c4f8e75..202aa21 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 {
@@ -144,10 +150,11 @@
// 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;
+ uint64_t FauxAttr = PAWI.Attrs.Raw() & 0xffff;
if (PAWI.Attrs & Attribute::Alignment)
- FauxAttr |= (1ull<<16)<<(((PAWI.Attrs & Attribute::Alignment)-1) >> 16);
- FauxAttr |= (PAWI.Attrs & (0x3FFull << 21)) << 11;
+ FauxAttr |= (1ull<<16)<<
+ (((PAWI.Attrs & Attribute::Alignment).Raw()-1) >> 16);
+ FauxAttr |= (PAWI.Attrs.Raw() & (0x3FFull << 21)) << 11;
Record.push_back(FauxAttr);
}
@@ -162,7 +169,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 +242,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 +255,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 +292,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 +347,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()));
@@ -876,34 +883,56 @@
} else {
assert (0 && "Unknown FP type!");
}
- } else if (isa<ConstantArray>(C) && cast<ConstantArray>(C)->isString()) {
- const ConstantArray *CA = cast<ConstantArray>(C);
+ } else if (isa<ConstantDataSequential>(C) &&
+ cast<ConstantDataSequential>(C)->isString()) {
+ const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);
// Emit constant strings specially.
- unsigned NumOps = CA->getNumOperands();
+ unsigned NumElts = Str->getNumElements();
// If this is a null-terminated string, use the denser CSTRING encoding.
- if (CA->getOperand(NumOps-1)->isNullValue()) {
+ if (Str->isCString()) {
Code = bitc::CST_CODE_CSTRING;
- --NumOps; // Don't encode the null, which isn't allowed by char6.
+ --NumElts; // Don't encode the null, which isn't allowed by char6.
} else {
Code = bitc::CST_CODE_STRING;
AbbrevToUse = String8Abbrev;
}
bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
- for (unsigned i = 0; i != NumOps; ++i) {
- unsigned char V = cast<ConstantInt>(CA->getOperand(i))->getZExtValue();
+ for (unsigned i = 0; i != NumElts; ++i) {
+ unsigned char V = Str->getElementAsInteger(i);
Record.push_back(V);
isCStr7 &= (V & 128) == 0;
if (isCStrChar6)
isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
}
-
+
if (isCStrChar6)
AbbrevToUse = CString6Abbrev;
else if (isCStr7)
AbbrevToUse = CString7Abbrev;
- } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(V) ||
- isa<ConstantVector>(V)) {
+ } else if (const ConstantDataSequential *CDS =
+ dyn_cast<ConstantDataSequential>(C)) {
+ Code = bitc::CST_CODE_DATA;
+ Type *EltTy = CDS->getType()->getElementType();
+ if (isa<IntegerType>(EltTy)) {
+ for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
+ Record.push_back(CDS->getElementAsInteger(i));
+ } else if (EltTy->isFloatTy()) {
+ for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
+ union { float F; uint32_t I; };
+ F = CDS->getElementAsFloat(i);
+ Record.push_back(I);
+ }
+ } else {
+ assert(EltTy->isDoubleTy() && "Unknown ConstantData element type");
+ for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
+ union { double F; uint64_t I; };
+ F = CDS->getElementAsDouble(i);
+ Record.push_back(I);
+ }
+ }
+ } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(C) ||
+ isa<ConstantVector>(C)) {
Code = bitc::CST_CODE_AGGREGATE;
for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
Record.push_back(VE.getValueID(C->getOperand(i)));
@@ -1182,9 +1211,6 @@
}
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;
@@ -1616,7 +1642,17 @@
DarwinBCHeaderSize = 5*4
};
-static void EmitDarwinBCHeader(BitstreamWriter &Stream, const Triple &TT) {
+static void WriteInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,
+ uint32_t &Position) {
+ Buffer[Position + 0] = (unsigned char) (Value >> 0);
+ Buffer[Position + 1] = (unsigned char) (Value >> 8);
+ Buffer[Position + 2] = (unsigned char) (Value >> 16);
+ Buffer[Position + 3] = (unsigned char) (Value >> 24);
+ Position += 4;
+}
+
+static void EmitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
+ const Triple &TT) {
unsigned CPUType = ~0U;
// Match x86_64-*, i[3-9]86-*, powerpc-*, powerpc64-*, arm-*, thumb-*,
@@ -1643,63 +1679,55 @@
CPUType = DARWIN_CPU_TYPE_ARM;
// Traditional Bitcode starts after header.
+ assert(Buffer.size() >= DarwinBCHeaderSize &&
+ "Expected header size to be reserved");
unsigned BCOffset = DarwinBCHeaderSize;
+ unsigned BCSize = Buffer.size()-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);
+ // Write the magic and version.
+ unsigned Position = 0;
+ WriteInt32ToBuffer(0x0B17C0DE , Buffer, Position);
+ WriteInt32ToBuffer(0 , Buffer, Position); // Version.
+ WriteInt32ToBuffer(BCOffset , Buffer, Position);
+ WriteInt32ToBuffer(BCSize , Buffer, Position);
+ WriteInt32ToBuffer(CPUType , Buffer, Position);
// If the file is not a multiple of 16 bytes, insert dummy padding.
- while (BufferSize & 15) {
- Stream.Emit(0, 8);
- ++BufferSize;
- }
+ while (Buffer.size() & 15)
+ Buffer.push_back(0);
}
-
/// WriteBitcodeToFile - Write the specified module to the specified output
/// stream.
void llvm_2_9::WriteBitcodeToFile(const Module *M, raw_ostream &Out) {
- std::vector<unsigned char> Buffer;
- BitstreamWriter Stream(Buffer);
-
+ SmallVector<char, 1024> Buffer;
Buffer.reserve(256*1024);
- WriteBitcodeToStream( M, Stream );
+ // If this is darwin or another generic macho target, reserve space for the
+ // header.
+ Triple TT(M->getTargetTriple());
+ if (TT.isOSDarwin())
+ Buffer.insert(Buffer.begin(), DarwinBCHeaderSize, 0);
+
+ // Emit the module into the buffer.
+ {
+ BitstreamWriter Stream(Buffer);
+
+ // Emit the file header.
+ Stream.Emit((unsigned)'B', 8);
+ Stream.Emit((unsigned)'C', 8);
+ Stream.Emit(0x0, 4);
+ Stream.Emit(0xC, 4);
+ Stream.Emit(0xE, 4);
+ Stream.Emit(0xD, 4);
+
+ // Emit the module.
+ WriteModule(M, Stream);
+ }
+
+ if (TT.isOSDarwin())
+ EmitDarwinBCHeaderAndTrailer(Buffer, TT);
// 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::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/ReaderWriter_2_9.h b/BitWriter_2_9/ReaderWriter_2_9.h
index bb82fa3..997e9c7 100644
--- a/BitWriter_2_9/ReaderWriter_2_9.h
+++ b/BitWriter_2_9/ReaderWriter_2_9.h
@@ -55,10 +55,6 @@
/// 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);
diff --git a/BitWriter_2_9/ValueEnumerator.cpp b/BitWriter_2_9/ValueEnumerator.cpp
index 9ae9905..3764dec 100644
--- a/BitWriter_2_9/ValueEnumerator.cpp
+++ b/BitWriter_2_9/ValueEnumerator.cpp
@@ -283,7 +283,7 @@
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()) {
+ //} 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.
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..9a224ea
--- /dev/null
+++ b/BitWriter_2_9_func/BitcodeWriter.cpp
@@ -0,0 +1,1750 @@
+//===--- 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.Raw() & 0xffff;
+ if (PAWI.Attrs & Attribute::Alignment)
+ FauxAttr |= (1ull<<16)<<
+ (((PAWI.Attrs & Attribute::Alignment).Raw()-1) >> 16);
+ FauxAttr |= (PAWI.Attrs.Raw() & (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<ConstantDataSequential>(C) &&
+ cast<ConstantDataSequential>(C)->isString()) {
+ const ConstantDataSequential *Str = cast<ConstantDataSequential>(C);
+ // Emit constant strings specially.
+ unsigned NumElts = Str->getNumElements();
+ // If this is a null-terminated string, use the denser CSTRING encoding.
+ if (Str->isCString()) {
+ Code = bitc::CST_CODE_CSTRING;
+ --NumElts; // Don't encode the null, which isn't allowed by char6.
+ } else {
+ Code = bitc::CST_CODE_STRING;
+ AbbrevToUse = String8Abbrev;
+ }
+ bool isCStr7 = Code == bitc::CST_CODE_CSTRING;
+ bool isCStrChar6 = Code == bitc::CST_CODE_CSTRING;
+ for (unsigned i = 0; i != NumElts; ++i) {
+ unsigned char V = Str->getElementAsInteger(i);
+ Record.push_back(V);
+ isCStr7 &= (V & 128) == 0;
+ if (isCStrChar6)
+ isCStrChar6 = BitCodeAbbrevOp::isChar6(V);
+ }
+
+ if (isCStrChar6)
+ AbbrevToUse = CString6Abbrev;
+ else if (isCStr7)
+ AbbrevToUse = CString7Abbrev;
+ } else if (const ConstantDataSequential *CDS =
+ dyn_cast<ConstantDataSequential>(C)) {
+ Code = bitc::CST_CODE_DATA;
+ Type *EltTy = CDS->getType()->getElementType();
+ if (isa<IntegerType>(EltTy)) {
+ for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i)
+ Record.push_back(CDS->getElementAsInteger(i));
+ } else if (EltTy->isFloatTy()) {
+ for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
+ union { float F; uint32_t I; };
+ F = CDS->getElementAsFloat(i);
+ Record.push_back(I);
+ }
+ } else {
+ assert(EltTy->isDoubleTy() && "Unknown ConstantData element type");
+ for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
+ union { double F; uint64_t I; };
+ F = CDS->getElementAsDouble(i);
+ Record.push_back(I);
+ }
+ }
+ } else if (isa<ConstantArray>(C) || isa<ConstantStruct>(C) ||
+ isa<ConstantVector>(C)) {
+ 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::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 WriteInt32ToBuffer(uint32_t Value, SmallVectorImpl<char> &Buffer,
+ uint32_t &Position) {
+ Buffer[Position + 0] = (unsigned char) (Value >> 0);
+ Buffer[Position + 1] = (unsigned char) (Value >> 8);
+ Buffer[Position + 2] = (unsigned char) (Value >> 16);
+ Buffer[Position + 3] = (unsigned char) (Value >> 24);
+ Position += 4;
+}
+
+static void EmitDarwinBCHeaderAndTrailer(SmallVectorImpl<char> &Buffer,
+ 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.
+ assert(Buffer.size() >= DarwinBCHeaderSize &&
+ "Expected header size to be reserved");
+ unsigned BCOffset = DarwinBCHeaderSize;
+ unsigned BCSize = Buffer.size()-DarwinBCHeaderSize;
+
+ // Write the magic and version.
+ unsigned Position = 0;
+ WriteInt32ToBuffer(0x0B17C0DE , Buffer, Position);
+ WriteInt32ToBuffer(0 , Buffer, Position); // Version.
+ WriteInt32ToBuffer(BCOffset , Buffer, Position);
+ WriteInt32ToBuffer(BCSize , Buffer, Position);
+ WriteInt32ToBuffer(CPUType , Buffer, Position);
+
+ // If the file is not a multiple of 16 bytes, insert dummy padding.
+ while (Buffer.size() & 15)
+ Buffer.push_back(0);
+}
+
+/// WriteBitcodeToFile - Write the specified module to the specified output
+/// stream.
+void llvm_2_9_func::WriteBitcodeToFile(const Module *M, raw_ostream &Out) {
+ SmallVector<char, 1024> Buffer;
+ Buffer.reserve(256*1024);
+
+ // If this is darwin or another generic macho target, reserve space for the
+ // header.
+ Triple TT(M->getTargetTriple());
+ if (TT.isOSDarwin())
+ Buffer.insert(Buffer.begin(), DarwinBCHeaderSize, 0);
+
+ // Emit the module into the buffer.
+ {
+ BitstreamWriter Stream(Buffer);
+
+ // Emit the file header.
+ Stream.Emit((unsigned)'B', 8);
+ Stream.Emit((unsigned)'C', 8);
+ Stream.Emit(0x0, 4);
+ Stream.Emit(0xC, 4);
+ Stream.Emit(0xE, 4);
+ Stream.Emit(0xD, 4);
+
+ // Emit the module.
+ WriteModule(M, Stream);
+ }
+
+ if (TT.isOSDarwin())
+ EmitDarwinBCHeaderAndTrailer(Buffer, TT);
+
+ // Write the generated bitstream to "Out".
+ Out.write((char*)&Buffer.front(), Buffer.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..24ecc49
--- /dev/null
+++ b/BitWriter_2_9_func/ReaderWriter_2_9_func.h
@@ -0,0 +1,143 @@
+//===-- 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);
+
+ /// 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..3764dec
--- /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..ebd7f36 100644
--- a/RSCCOptions.td
+++ b/RSCCOptions.td
@@ -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.
@@ -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
//===----------------------------------------------------------------------===//
@@ -105,6 +108,13 @@
def _additional_dep_target : Separate<"-a">, Alias<additional_dep_target>;
//===----------------------------------------------------------------------===//
+// Reflection Options
+//===----------------------------------------------------------------------===//
+
+def reflect_cpp : Flag<"-reflect-c++">,
+ HelpText<"Reflect C++ classes">;
+
+//===----------------------------------------------------------------------===//
// Misc Options
//===----------------------------------------------------------------------===//
diff --git a/RSSpec.mk b/RSSpec.mk
index f617014..ba9c016 100644
--- a/RSSpec.mk
+++ b/RSSpec.mk
@@ -50,12 +50,6 @@
$(call generate-rs-spec-inc,rs-object-type-enums)
endif
-ifneq ($(findstring RSDataKindEnums.inc,$(RS_SPEC_TABLES)),)
-LOCAL_GENERATED_SOURCES += $(intermediates)/RSDataKindEnums.inc
-$(intermediates)/RSDataKindEnums.inc: $(RS_SPEC_GEN)
- $(call generate-rs-spec-inc,rs-data-kind-enums)
-endif
-
ifneq ($(findstring RSDataElementEnums.inc,$(RS_SPEC_TABLES)),)
LOCAL_GENERATED_SOURCES += $(intermediates)/RSDataElementEnums.inc
$(intermediates)/RSDataElementEnums.inc: $(RS_SPEC_GEN)
diff --git a/lit-tests/P_alloc_in_struct/alloc_in_struct.rs b/lit-tests/P_alloc_in_struct/alloc_in_struct.rs
new file mode 100644
index 0000000..24742fb
--- /dev/null
+++ b/lit-tests/P_alloc_in_struct/alloc_in_struct.rs
@@ -0,0 +1,11 @@
+// RUN: %Slang %s
+// RUN: %rs-filecheck-wrapper %s
+// CHECK: define void @.rs.dtor()
+
+#pragma version(1)
+#pragma rs java_package_name(alloc_in_struct)
+
+struct s {
+ rs_allocation a;
+} myStruct;
+
diff --git a/lit-tests/P_array_init/array_init.rs b/lit-tests/P_array_init/array_init.rs
new file mode 100644
index 0000000..f4465db
--- /dev/null
+++ b/lit-tests/P_array_init/array_init.rs
@@ -0,0 +1,30 @@
+// RUN: %Slang %s
+// RUN: %rs-filecheck-wrapper %s
+// CHECK: @ic = constant i32 99, align 4
+// CHECK: @ica = global [2 x i32] [i32 99, i32 1000], align 4
+// CHECK: @fa = global [4 x float] [float 1.000000e+00, float 0x4023FFF2E0000000, float 0.000000e+00, float 0.000000e+00], align 4
+// CHECK: @da = global [2 x double] [double 7.000000e+00, double 8.888880e+00], align 8
+// CHECK: @ca = global [4 x i8] c"a\07bc", align 1
+// CHECK: @sa = global [4 x i16] [i16 1, i16 1, i16 2, i16 3], align 2
+// CHECK: @ia = global [4 x i32] [i32 5, i32 8, i32 0, i32 0], align 4
+// CHECK: @la = global [2 x i64] [i64 13, i64 21], align 8
+// CHECK: @lla = global [4 x i64] [i64 34, i64 0, i64 0, i64 0], align 8
+// CHECK: @ba = global [3 x i8] c"\01\00\00", align 1
+
+
+#pragma version(1)
+#pragma rs java_package_name(array_init)
+
+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/lit-tests/P_compute/compute.rs b/lit-tests/P_compute/compute.rs
new file mode 100644
index 0000000..49405b8
--- /dev/null
+++ b/lit-tests/P_compute/compute.rs
@@ -0,0 +1,18 @@
+// RUN: %Slang %s
+// RUN: %rs-filecheck-wrapper %s
+// CHECK: define void @root(
+// CHECK: define void @foo(
+// CHECK: define void @.helper_bar(
+
+#pragma version(1)
+#pragma rs java_package_name(compute)
+
+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/lit-tests/debug_disabled.rs b/lit-tests/debug/debug_disabled.rs
similarity index 100%
rename from lit-tests/debug_disabled.rs
rename to lit-tests/debug/debug_disabled.rs
diff --git a/lit-tests/debug_enabled.rs b/lit-tests/debug/debug_enabled.rs
similarity index 100%
rename from lit-tests/debug_enabled.rs
rename to lit-tests/debug/debug_enabled.rs
diff --git a/lit-tests/lit.cfg b/lit-tests/lit.cfg
index 1fb7692..0db68fb 100644
--- a/lit-tests/lit.cfg
+++ b/lit-tests/lit.cfg
@@ -47,9 +47,9 @@
config.filecheck = inferTool('FileCheck', 'FILECHECK', config.environment['PATH'])
config.rs_filecheck_wrapper = inferTool('rs-filecheck-wrapper.sh', 'RS_FILECHECK_WRAPPER', os.path.join(config.base_path, 'frameworks', 'compile', 'slang', 'lit-tests'))
-# TODO: fix up for other SDKs. Maybe use lit parameter?
-config.slang_includes = "-I " + os.path.join(config.base_path, 'prebuilt', 'sdk', '14', 'renderscript', 'include') + " " \
- + "-I " + os.path.join(config.base_path, 'prebuilt', 'sdk', '14', 'renderscript', 'clang-include')
+# Use most up-to-date headers for includes.
+config.slang_includes = "-I " + os.path.join(config.base_path, 'frameworks', 'base', 'libs', 'rs', 'scriptc') + " " \
+ + "-I " + os.path.join(config.base_path, 'external', 'clang', 'lib', 'Headers')
config.slang_options = "-emit-llvm -o " + config.test_exec_root \
+ " -output-dep-dir " + config.test_exec_root \
diff --git a/lit-tests/locals_opt_0.rs b/lit-tests/opt/locals_opt_0.rs
similarity index 100%
rename from lit-tests/locals_opt_0.rs
rename to lit-tests/opt/locals_opt_0.rs
diff --git a/lit-tests/locals_opt_3.rs b/lit-tests/opt/locals_opt_3.rs
similarity index 100%
rename from lit-tests/locals_opt_3.rs
rename to lit-tests/opt/locals_opt_3.rs
diff --git a/lit-tests/locals_opt_default.rs b/lit-tests/opt/locals_opt_default.rs
similarity index 100%
rename from lit-tests/locals_opt_default.rs
rename to lit-tests/opt/locals_opt_default.rs
diff --git a/llvm-rs-cc.cpp b/llvm-rs-cc.cpp
index b8e3d59..2cd7bb0 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)
@@ -266,6 +273,10 @@
<< OptParser->getOptionName(OPT_bitcode_storage)
<< BitcodeStorageValue;
+ if (Args->hasArg(OPT_reflect_cpp)) {
+ Opts.mBitcodeStorage = slang::BCST_CPP_CODE;
+ }
+
Opts.mOutputDepDir =
Args->getLastArgValue(OPT_output_dep_dir, Opts.mOutputDir);
Opts.mAdditionalDepTargets =
@@ -360,6 +371,8 @@
OS << ".\n";
return;
}
+#undef wrap_str
+#undef str
int main(int argc, const char **argv) {
std::set<std::string> SavedStrings;
@@ -376,24 +389,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 +421,7 @@
// No input file
if (Inputs.empty()) {
DiagEngine.Report(clang::diag::err_drv_no_input_files);
+ llvm::errs() << DiagClient->str();
return 1;
}
@@ -419,7 +431,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];
@@ -466,6 +479,7 @@
Opts.mOptimizationLevel,
Opts.mJavaReflectionPathBase,
Opts.mJavaReflectionPackageName);
+
Compiler->reset();
return CompileFailed;
diff --git a/slang.cpp b/slang.cpp
index 45dc277..662c243 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,10 @@
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,
+ LangOpts,
+ mTarget.get());
mPP.reset(new clang::Preprocessor(*mDiagEngine,
LangOpts,
@@ -256,7 +249,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 +258,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 +277,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 +331,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 +340,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 +362,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 ed03814..483b85a 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) {
@@ -247,9 +251,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) {
@@ -344,11 +347,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.cpp b/slang_rs.cpp
index 8b52931..4aa2214 100644
--- a/slang_rs.cpp
+++ b/slang_rs.cpp
@@ -36,6 +36,8 @@
#include "slang_rs_context.h"
#include "slang_rs_export_type.h"
+#include "slang_rs_reflection_cpp.h"
+
namespace slang {
#define RS_HEADER_SUFFIX "rsh"
@@ -47,11 +49,15 @@
RS_HEADER_ENTRY(rs_cl) \
RS_HEADER_ENTRY(rs_core) \
RS_HEADER_ENTRY(rs_debug) \
+ RS_HEADER_ENTRY(rs_element) \
RS_HEADER_ENTRY(rs_graphics) \
RS_HEADER_ENTRY(rs_math) \
+ RS_HEADER_ENTRY(rs_mesh) \
RS_HEADER_ENTRY(rs_matrix) \
RS_HEADER_ENTRY(rs_object) \
+ RS_HEADER_ENTRY(rs_program) \
RS_HEADER_ENTRY(rs_quaternion) \
+ RS_HEADER_ENTRY(rs_sampler) \
RS_HEADER_ENTRY(rs_time) \
RS_HEADER_ENTRY(rs_types) \
@@ -319,26 +325,38 @@
return false;
if (OutputType != Slang::OT_Dependency) {
- if (!reflectToJava(JavaReflectionPathBase,
- JavaReflectionPackageName,
- &RealPackageName))
- return false;
- for (std::vector<std::string>::const_iterator
- I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end();
- I != E;
- I++) {
- std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath(
- JavaReflectionPathBase.c_str(),
- (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str());
- appendGeneratedFileName(ReflectedName + ".java");
- }
+ if (BitcodeStorage == BCST_CPP_CODE) {
+ RSReflectionCpp R(mRSContext);
+ bool ret = R.reflect(JavaReflectionPathBase, getInputFileName(), getOutputFileName());
+ if (!ret) {
+ return false;
+ }
+ } else {
- if ((OutputType == Slang::OT_Bitcode) &&
- (BitcodeStorage == BCST_JAVA_CODE) &&
- !generateBitcodeAccessor(JavaReflectionPathBase,
- RealPackageName.c_str()))
+ if (!reflectToJava(JavaReflectionPathBase,
+ JavaReflectionPackageName,
+ &RealPackageName)) {
return false;
+ }
+
+ for (std::vector<std::string>::const_iterator
+ I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end();
+ I != E;
+ I++) {
+ std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath(
+ JavaReflectionPathBase.c_str(),
+ (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str());
+ appendGeneratedFileName(ReflectedName + ".java");
+ }
+
+ if ((OutputType == Slang::OT_Bitcode) &&
+ (BitcodeStorage == BCST_JAVA_CODE) &&
+ !generateBitcodeAccessor(JavaReflectionPathBase,
+ RealPackageName.c_str())) {
+ return false;
+ }
+ }
}
if (OutputDep) {
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..007a6ad 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();
}
@@ -493,27 +506,6 @@
llvm::MDString::get(mLLVMContext,
F->getType()->getName().c_str()));
- // 3. field kind
- switch (F->getType()->getClass()) {
- case RSExportType::ExportClassPrimitive:
- case RSExportType::ExportClassVector: {
- const RSExportPrimitiveType *EPT =
- static_cast<const RSExportPrimitiveType*>(F->getType());
- FieldInfo.push_back(
- llvm::MDString::get(mLLVMContext,
- llvm::itostr(EPT->getKind())));
- break;
- }
-
- default: {
- FieldInfo.push_back(
- llvm::MDString::get(mLLVMContext,
- llvm::itostr(
- RSExportPrimitiveType::DataKindUser)));
- break;
- }
- }
-
StructInfoMetadata->addOperand(
llvm::MDNode::get(mLLVMContext, FieldInfo));
FieldInfo.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_element.cpp b/slang_rs_export_element.cpp
index 842e92e..c1b9c3c 100644
--- a/slang_rs_export_element.cpp
+++ b/slang_rs_export_element.cpp
@@ -34,10 +34,9 @@
void RSExportElement::Init() {
if (!Initialized) {
// Initialize ElementInfoMap
-#define ENUM_RS_DATA_ELEMENT(_name, _dk, _dt, _norm, _vsize) \
+#define ENUM_RS_DATA_ELEMENT(_name, _dt, _norm, _vsize) \
{ \
ElementInfo *EI = new ElementInfo; \
- EI->kind = RSExportPrimitiveType::DataKind ## _dk; \
EI->type = RSExportPrimitiveType::DataType ## _dt; \
EI->normalized = _norm; \
EI->vsize = _vsize; \
@@ -83,7 +82,6 @@
RSExportPrimitiveType::Create(Context,
T,
TypeName,
- EI->kind,
EI->normalized);
// Verify
slangAssert(EI->type == EPT->getType() && "Element has unexpected type");
@@ -99,7 +97,6 @@
T->getCanonicalTypeInternal()
.getTypePtr()),
TypeName,
- EI->kind,
EI->normalized);
// Verify
slangAssert(EI->type == EVT->getType() && "Element has unexpected type");
diff --git a/slang_rs_export_element.h b/slang_rs_export_element.h
index dba1156..5740e5d 100644
--- a/slang_rs_export_element.h
+++ b/slang_rs_export_element.h
@@ -41,7 +41,6 @@
RSExportElement() { return; }
typedef struct {
- RSExportPrimitiveType::DataKind kind;
RSExportPrimitiveType::DataType type;
bool normalized;
unsigned vsize;
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..843ef56 100644
--- a/slang_rs_export_type.cpp
+++ b/slang_rs_export_type.cpp
@@ -42,6 +42,43 @@
namespace {
+static RSReflectionType gReflectionTypes[] = {
+ {"FLOAT_16", "F16", 16, "half", "half", "Half", "Half", false},
+ {"FLOAT_32", "F32", 32, "float", "float", "Float", "Float", false},
+ {"FLOAT_64", "F64", 64, "double", "double", "Double", "Double",false},
+ {"SIGNED_8", "I8", 8, "int8_t", "byte", "Byte", "Byte", false},
+ {"SIGNED_16", "I16", 16, "int16_t", "short", "Short", "Short", false},
+ {"SIGNED_32", "I32", 32, "int32_t", "int", "Int", "Int", false},
+ {"SIGNED_64", "I64", 64, "int64_t", "long", "Long", "Long", false},
+ {"UNSIGNED_8", "U8", 8, "uint8_t", "short", "UByte", "Short", true},
+ {"UNSIGNED_16", "U16", 16, "uint16_t", "int", "UShort", "Int", true},
+ {"UNSIGNED_32", "U32", 32, "uint32_t", "long", "UInt", "Long", true},
+ {"UNSIGNED_64", "U64", 64, "uint64_t", "long", "ULong", "Long", false},
+
+ {"BOOLEAN", "BOOLEAN", 8, "bool", "boolean", NULL, NULL, false},
+
+ {"UNSIGNED_5_6_5", NULL, 16, NULL, NULL, NULL, NULL, false},
+ {"UNSIGNED_5_5_5_1", NULL, 16, NULL, NULL, NULL, NULL, false},
+ {"UNSIGNED_4_4_4_4", NULL, 16, NULL, NULL, NULL, NULL, false},
+
+ {"MATRIX_2X2", NULL, 4*32, "rsMatrix_2x2", "Matrix2f", NULL, NULL, false},
+ {"MATRIX_3X3", NULL, 9*32, "rsMatrix_3x3", "Matrix3f", NULL, NULL, false},
+ {"MATRIX_4X4", NULL, 16*32, "rsMatrix_4x4", "Matrix4f", NULL, NULL, false},
+
+ {"RS_ELEMENT", "ELEMENT", 32, "Element", "Element", NULL, NULL, false},
+ {"RS_TYPE", "TYPE", 32, "Type", "Type", NULL, NULL, false},
+ {"RS_ALLOCATION", "ALLOCATION", 32, "Allocation", "Allocation", NULL, NULL, false},
+ {"RS_SAMPLER", "SAMPLER", 32, "Sampler", "Sampler", NULL, NULL, false},
+ {"RS_SCRIPT", "SCRIPT", 32, "Script", "Script", NULL, NULL, false},
+ {"RS_MESH", "MESH", 32, "Mesh", "Mesh", NULL, NULL, false},
+ {"RS_PATH", "PATH", 32, "Path", "Path", NULL, NULL, false},
+ {"RS_PROGRAM_FRAGMENT", "PROGRAM_FRAGMENT", 32, "ProgramFragment", "ProgramFragment", NULL, NULL, false},
+ {"RS_PROGRAM_VERTEX", "PROGRAM_VERTEX", 32, "ProgramVertex", "ProgramVertex", NULL, NULL, false},
+ {"RS_PROGRAM_RASTER", "PROGRAM_RASTER", 32, "ProgramRaster", "ProgramRaster", NULL, NULL, false},
+ {"RS_PROGRAM_STORE", "PROGRAM_STORE", 32, "ProgramStore", "ProgramStore", NULL, NULL, false},
+ {"RS_FONT", "FONT", 32, "Font", "Font", NULL, NULL, false}
+};
+
static const clang::Type *TypeExportableHelper(
const clang::Type *T,
llvm::SmallPtrSet<const clang::Type*, 8>& SPS,
@@ -116,12 +153,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;
@@ -854,7 +890,6 @@
*RSExportPrimitiveType::Create(RSContext *Context,
const clang::Type *T,
const llvm::StringRef &TypeName,
- DataKind DK,
bool Normalized) {
DataType DT = GetDataType(Context, T);
@@ -862,16 +897,15 @@
return NULL;
else
return new RSExportPrimitiveType(Context, ExportClassPrimitive, TypeName,
- DT, DK, Normalized);
+ DT, Normalized);
}
RSExportPrimitiveType *RSExportPrimitiveType::Create(RSContext *Context,
- const clang::Type *T,
- DataKind DK) {
+ const clang::Type *T) {
llvm::StringRef TypeName;
if (RSExportType::NormalizeType(T, TypeName, Context->getDiagnostics(), NULL)
&& IsPrimitiveType(T)) {
- return Create(Context, T, TypeName, DK);
+ return Create(Context, T, TypeName);
} else {
return NULL;
}
@@ -955,6 +989,14 @@
return (static_cast<const RSExportPrimitiveType*>(E)->getType() == getType());
}
+RSReflectionType *RSExportPrimitiveType::getRSReflectionType(DataType DT) {
+ if (DT > DataTypeUnknown && DT < DataTypeMax) {
+ return &gReflectionTypes[DT];
+ } else {
+ return NULL;
+ }
+}
+
/**************************** RSExportPointerType ****************************/
RSExportPointerType
@@ -1043,7 +1085,6 @@
RSExportVectorType *RSExportVectorType::Create(RSContext *Context,
const clang::ExtVectorType *EVT,
const llvm::StringRef &TypeName,
- DataKind DK,
bool Normalized) {
slangAssert(EVT != NULL && EVT->getTypeClass() == clang::Type::ExtVector);
@@ -1055,7 +1096,6 @@
return new RSExportVectorType(Context,
TypeName,
DT,
- DK,
Normalized,
EVT->getNumElements());
else
@@ -1360,17 +1400,6 @@
RS_RECORD_TYPE_SET_FIELD_NAME(ST, FieldIdx, F->getName().c_str());
RS_RECORD_TYPE_SET_FIELD_TYPE(ST, FieldIdx, F->getType()->getSpecType());
-
- enum RSDataKind DK = RS_DK_User;
- if ((F->getType()->getClass() == ExportClassPrimitive) ||
- (F->getType()->getClass() == ExportClassVector)) {
- const RSExportPrimitiveType *EPT =
- static_cast<const RSExportPrimitiveType*>(F->getType());
- // enum RSExportPrimitiveType::DataKind is synced with enum RSDataKind in
- // slang_rs_type_spec.h
- DK = static_cast<enum RSDataKind>(EPT->getKind());
- }
- RS_RECORD_TYPE_SET_FIELD_DATA_KIND(ST, FieldIdx, DK);
}
// TODO(slang): Check whether all fields were created normally.
@@ -1410,4 +1439,52 @@
return true;
}
+void RSExportType::convertToRTD(RSReflectionTypeData *rtd) const {
+ memset(rtd, 0, sizeof(*rtd));
+ rtd->vecSize = 1;
+
+ switch(getClass()) {
+ case RSExportType::ExportClassPrimitive: {
+ const RSExportPrimitiveType *EPT = static_cast<const RSExportPrimitiveType*>(this);
+ rtd->type = RSExportPrimitiveType::getRSReflectionType(EPT);
+ return;
+ }
+ case RSExportType::ExportClassPointer: {
+ const RSExportPointerType *EPT = static_cast<const RSExportPointerType*>(this);
+ const RSExportType *PointeeType = EPT->getPointeeType();
+ PointeeType->convertToRTD(rtd);
+ rtd->isPointer = true;
+ return;
+ }
+ case RSExportType::ExportClassVector: {
+ const RSExportVectorType *EVT = static_cast<const RSExportVectorType*>(this);
+ rtd->type = EVT->getRSReflectionType(EVT);
+ rtd->vecSize = EVT->getNumElement();
+ return;
+ }
+ case RSExportType::ExportClassMatrix: {
+ const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType*>(this);
+ unsigned Dim = EMT->getDim();
+ slangAssert((Dim >= 2) && (Dim <= 4));
+ rtd->type = &gReflectionTypes[15 + Dim-2];
+ return;
+ }
+ case RSExportType::ExportClassConstantArray: {
+ const RSExportConstantArrayType* CAT =
+ static_cast<const RSExportConstantArrayType*>(this);
+ CAT->getElementType()->convertToRTD(rtd);
+ rtd->arraySize = CAT->getSize();
+ return;
+ }
+ case RSExportType::ExportClassRecord: {
+ slangAssert(!"RSExportType::ExportClassRecord not implemented");
+ return;// RS_TYPE_CLASS_NAME_PREFIX + ET->getName() + ".Item";
+ }
+ default: {
+ slangAssert(false && "Unknown class of type");
+ }
+ }
+}
+
+
} // namespace slang
diff --git a/slang_rs_export_type.h b/slang_rs_export_type.h
index fcb2f1b..e3d8f78 100644
--- a/slang_rs_export_type.h
+++ b/slang_rs_export_type.h
@@ -60,6 +60,31 @@
class RSContext;
+typedef struct {
+ const char * rs_type;
+ const char * rs_short_type;
+ uint32_t size_in_bits;
+ const char * c_name;
+ const char * java_name;
+ const char * rs_c_vector_prefix;
+ const char * rs_java_vector_prefix;
+ bool java_promotion;
+} RSReflectionType;
+
+
+typedef struct RSReflectionTypeData_rec {
+ const RSReflectionType *type;
+ uint32_t vecSize;
+ bool isPointer;
+ uint32_t arraySize;
+
+ // Subelements
+ //std::vector<const struct RSReflectionTypeData_rec *> fields;
+ //std::vector< std::string > fieldNames;
+ //std::vector< uint32_t> fieldOffsetBytes;
+} RSReflectionTypeData;
+
+
class RSExportType : public RSExportable {
friend class RSExportElement;
public:
@@ -72,6 +97,8 @@
ExportClassRecord
} ExportClass;
+ void convertToRTD(RSReflectionTypeData *rtd) const;
+
private:
ExportClass mClass;
std::string mName;
@@ -196,14 +223,6 @@
DataTypeMax
} DataType;
- // From graphics/java/android/renderscript/Element.java: Element.DataKind
- typedef enum {
- DataKindUnknown = -1
-#define ENUM_RS_DATA_KIND(kind) \
- , DataKind ## kind
-#include "RSDataKindEnums.inc"
- } DataKind;
-
private:
// NOTE: There's no any instance of RSExportPrimitiveType which mType
// is of the value DataTypeRSMatrix*. DataTypeRSMatrix* enumeration here is
@@ -211,7 +230,6 @@
// rs_matrix{2x2, 3x3, 4x4}. These matrix type are represented as
// RSExportMatrixType.
DataType mType;
- DataKind mKind;
bool mNormalized;
typedef llvm::StringMap<DataType> RSSpecificTypeMapTy;
@@ -227,7 +245,6 @@
static RSExportPrimitiveType *Create(RSContext *Context,
const clang::Type *T,
const llvm::StringRef &TypeName,
- DataKind DK = DataKindUser,
bool Normalized = false);
protected:
@@ -236,11 +253,9 @@
ExportClass Class,
const llvm::StringRef &Name,
DataType DT,
- DataKind DK,
bool Normalized)
: RSExportType(Context, Class, Name),
mType(DT),
- mKind(DK),
mNormalized(Normalized) {
return;
}
@@ -257,8 +272,7 @@
// @T may not be normalized
static RSExportPrimitiveType *Create(RSContext *Context,
- const clang::Type *T,
- DataKind DK = DataKindUser);
+ const clang::Type *T);
static DataType GetRSSpecificType(const llvm::StringRef &TypeName);
static DataType GetRSSpecificType(const clang::Type *T);
@@ -276,12 +290,17 @@
static size_t GetSizeInBits(const RSExportPrimitiveType *EPT);
inline DataType getType() const { return mType; }
- inline DataKind getKind() const { return mKind; }
inline bool isRSObjectType() const {
return ((mType >= FirstRSObjectType) && (mType <= LastRSObjectType));
}
virtual bool equals(const RSExportable *E) const;
+
+ static RSReflectionType *getRSReflectionType(DataType DT);
+ static RSReflectionType *getRSReflectionType(
+ const RSExportPrimitiveType *EPT) {
+ return getRSReflectionType(EPT->getType());
+ }
}; // RSExportPrimitiveType
@@ -326,11 +345,10 @@
RSExportVectorType(RSContext *Context,
const llvm::StringRef &Name,
DataType DT,
- DataKind DK,
bool Normalized,
unsigned NumElement)
: RSExportPrimitiveType(Context, ExportClassVector, Name,
- DT, DK, Normalized),
+ DT, Normalized),
mNumElement(NumElement) {
return;
}
@@ -340,7 +358,6 @@
static RSExportVectorType *Create(RSContext *Context,
const clang::ExtVectorType *EVT,
const llvm::StringRef &TypeName,
- DataKind DK = DataKindUser,
bool Normalized = false);
virtual llvm::Type *convertToLLVMType() const;
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..26a4766 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),
@@ -281,13 +282,6 @@
return 0;
}
- // 3. field data kind
- if (!EncodeInteger(mModule->getContext(),
- RS_RECORD_TYPE_GET_FIELD_DATA_KIND(T, i),
- FieldInfo)) {
- return 0;
- }
-
RecordInfoMetadata->addOperand(llvm::MDNode::get(mModule->getContext(),
FieldInfo));
FieldInfo.clear();
diff --git a/slang_rs_object_ref_count.cpp b/slang_rs_object_ref_count.cpp
index 4693fd9..b5996eb 100644
--- a/slang_rs_object_ref_count.cpp
+++ b/slang_rs_object_ref_count.cpp
@@ -402,6 +402,7 @@
clang::Expr *RefRSClearObjectFD =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
ClearObjectFD,
ClearObjectFD->getLocation(),
ClearObjectFDType,
@@ -513,6 +514,7 @@
clang::DeclRefExpr *RefrsIntIter =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
IIVD,
Loc,
C.IntTy,
@@ -707,6 +709,7 @@
RefRSStruct,
false,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
FD,
FoundDecl,
clang::DeclarationNameInfo(),
@@ -739,6 +742,7 @@
RefRSStruct,
false,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
FD,
FoundDecl,
clang::DeclarationNameInfo(),
@@ -790,6 +794,7 @@
clang::Expr *RefRSSetObjectFD =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
SetObjectFD,
Loc,
SetObjectFDType,
@@ -1031,6 +1036,7 @@
LHS,
false,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
FD,
FoundDecl,
clang::DeclarationNameInfo(),
@@ -1044,6 +1050,7 @@
RHS,
false,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
FD,
FoundDecl,
clang::DeclarationNameInfo(),
@@ -1110,7 +1117,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())) {
@@ -1150,6 +1157,7 @@
clang::DeclRefExpr *RefRSVar =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
VD,
Loc,
T->getCanonicalTypeInternal(),
@@ -1177,6 +1185,7 @@
clang::Expr *RefRSSetObjectFD =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
SetObjectFD,
Loc,
SetObjectFDType,
@@ -1195,6 +1204,7 @@
clang::DeclRefExpr *RefRSVar =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
VD,
Loc,
T->getCanonicalTypeInternal(),
@@ -1258,6 +1268,7 @@
clang::DeclRefExpr *RefRSVar =
clang::DeclRefExpr::Create(C,
clang::NestedNameSpecifierLoc(),
+ clang::SourceLocation(),
VD,
Loc,
T->getCanonicalTypeInternal(),
@@ -1344,6 +1355,7 @@
case RSExportPrimitiveType::DataTypeRSSampler:
case RSExportPrimitiveType::DataTypeRSScript:
case RSExportPrimitiveType::DataTypeRSMesh:
+ case RSExportPrimitiveType::DataTypeRSPath:
case RSExportPrimitiveType::DataTypeRSProgramFragment:
case RSExportPrimitiveType::DataTypeRSProgramVertex:
case RSExportPrimitiveType::DataTypeRSProgramRaster:
@@ -1399,7 +1411,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..01b93f0 100644
--- a/slang_rs_reflect_utils.h
+++ b/slang_rs_reflect_utils.h
@@ -24,7 +24,8 @@
// BitCode storage type
enum BitCodeStorageType {
BCST_APK_RESOURCE,
- BCST_JAVA_CODE
+ BCST_JAVA_CODE,
+ BCST_CPP_CODE
};
class RSSlangReflectUtils {
@@ -77,6 +78,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..d0505ec 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>
@@ -37,6 +38,8 @@
#include "slang_version.h"
#include "slang_utils.h"
+#include "slang_rs_reflection_base.h"
+
#define RS_SCRIPT_CLASS_NAME_PREFIX "ScriptC_"
#define RS_SCRIPT_CLASS_SUPER_CLASS_NAME "ScriptC"
@@ -47,9 +50,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_"
@@ -73,177 +78,6 @@
return true;
}
-static const char *GetPrimitiveTypeName(const RSExportPrimitiveType *EPT) {
- static const char *PrimitiveTypeJavaNameMap[] = {
- "", // RSExportPrimitiveType::DataTypeFloat16
- "float", // RSExportPrimitiveType::DataTypeFloat32
- "double", // RSExportPrimitiveType::DataTypeFloat64
- "byte", // RSExportPrimitiveType::DataTypeSigned8
- "short", // RSExportPrimitiveType::DataTypeSigned16
- "int", // RSExportPrimitiveType::DataTypeSigned32
- "long", // RSExportPrimitiveType::DataTypeSigned64
- "short", // RSExportPrimitiveType::DataTypeUnsigned8
- "int", // RSExportPrimitiveType::DataTypeUnsigned16
- "long", // RSExportPrimitiveType::DataTypeUnsigned32
- "long", // RSExportPrimitiveType::DataTypeUnsigned64
- "boolean", // RSExportPrimitiveType::DataTypeBoolean
-
- "int", // RSExportPrimitiveType::DataTypeUnsigned565
- "int", // RSExportPrimitiveType::DataTypeUnsigned5551
- "int", // RSExportPrimitiveType::DataTypeUnsigned4444
-
- "", // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix2x2
- "", // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix3x3
- "", // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix4x4
-
- "Element", // RSExportPrimitiveType::DataTypeRSElement
- "Type", // RSExportPrimitiveType::DataTypeRSType
- "Allocation", // RSExportPrimitiveType::DataTypeRSAllocation
- "Sampler", // RSExportPrimitiveType::DataTypeRSSampler
- "Script", // RSExportPrimitiveType::DataTypeRSScript
- "Mesh", // RSExportPrimitiveType::DataTypeRSMesh
- "ProgramFragment", // RSExportPrimitiveType::DataTypeRSProgramFragment
- "ProgramVertex", // RSExportPrimitiveType::DataTypeRSProgramVertex
- "ProgramRaster", // RSExportPrimitiveType::DataTypeRSProgramRaster
- "ProgramStore", // RSExportPrimitiveType::DataTypeRSProgramStore
- "Font", // RSExportPrimitiveType::DataTypeRSFont
- };
- unsigned TypeId = EPT->getType();
-
- if (TypeId < (sizeof(PrimitiveTypeJavaNameMap) / sizeof(const char*))) {
- return PrimitiveTypeJavaNameMap[ EPT->getType() ];
- }
-
- slangAssert(false && "GetPrimitiveTypeName : Unknown primitive data type");
- return NULL;
-}
-
-static const char *GetVectorTypeName(const RSExportVectorType *EVT) {
- static const char *VectorTypeJavaNameMap[][3] = {
- /* 0 */ { "Byte2", "Byte3", "Byte4" },
- /* 1 */ { "Short2", "Short3", "Short4" },
- /* 2 */ { "Int2", "Int3", "Int4" },
- /* 3 */ { "Long2", "Long3", "Long4" },
- /* 4 */ { "Float2", "Float3", "Float4" },
- /* 5 */ { "Double2", "Double3", "Double4" }
- };
-
- const char **BaseElement = NULL;
-
- switch (EVT->getType()) {
- case RSExportPrimitiveType::DataTypeSigned8: {
- BaseElement = VectorTypeJavaNameMap[0];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned16:
- case RSExportPrimitiveType::DataTypeUnsigned8: {
- BaseElement = VectorTypeJavaNameMap[1];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned32:
- case RSExportPrimitiveType::DataTypeUnsigned16: {
- BaseElement = VectorTypeJavaNameMap[2];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned64:
- case RSExportPrimitiveType::DataTypeUnsigned64:
- case RSExportPrimitiveType::DataTypeUnsigned32: {
- BaseElement = VectorTypeJavaNameMap[3];
- break;
- }
- case RSExportPrimitiveType::DataTypeFloat32: {
- BaseElement = VectorTypeJavaNameMap[4];
- break;
- }
- case RSExportPrimitiveType::DataTypeFloat64: {
- BaseElement = VectorTypeJavaNameMap[5];
- break;
- }
- default: {
- slangAssert(false && "RSReflection::GetVectorTypeName : Unsupported "
- "vector element data type");
- break;
- }
- }
-
- slangAssert((EVT->getNumElement() > 1) &&
- (EVT->getNumElement() <= 4) &&
- "Number of elements in vector type is invalid");
-
- return BaseElement[EVT->getNumElement() - 2];
-}
-
-static const char *GetVectorElementName(const RSExportVectorType *EVT) {
- static const char *VectorElementNameMap[][3] = {
- /* 0 */ { "U8_2", "U8_3", "U8_4" },
- /* 1 */ { "I8_2", "I8_3", "I8_4" },
- /* 2 */ { "U16_2", "U16_3", "U16_4" },
- /* 3 */ { "I16_2", "I16_3", "I16_4" },
- /* 4 */ { "U32_2", "U32_3", "U32_4" },
- /* 5 */ { "I32_2", "I32_3", "I32_4" },
- /* 6 */ { "U64_2", "U64_3", "U64_4" },
- /* 7 */ { "I64_2", "I64_3", "I64_4" },
- /* 8 */ { "F32_2", "F32_3", "F32_4" },
- /* 9 */ { "F64_2", "F64_3", "F64_4" },
- };
-
- const char **BaseElement = NULL;
-
- switch (EVT->getType()) {
- case RSExportPrimitiveType::DataTypeUnsigned8: {
- BaseElement = VectorElementNameMap[0];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned8: {
- BaseElement = VectorElementNameMap[1];
- break;
- }
- case RSExportPrimitiveType::DataTypeUnsigned16: {
- BaseElement = VectorElementNameMap[2];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned16: {
- BaseElement = VectorElementNameMap[3];
- break;
- }
- case RSExportPrimitiveType::DataTypeUnsigned32: {
- BaseElement = VectorElementNameMap[4];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned32: {
- BaseElement = VectorElementNameMap[5];
- break;
- }
- case RSExportPrimitiveType::DataTypeUnsigned64: {
- BaseElement = VectorElementNameMap[6];
- break;
- }
- case RSExportPrimitiveType::DataTypeSigned64: {
- BaseElement = VectorElementNameMap[7];
- break;
- }
- case RSExportPrimitiveType::DataTypeFloat32: {
- BaseElement = VectorElementNameMap[8];
- break;
- }
- case RSExportPrimitiveType::DataTypeFloat64: {
- BaseElement = VectorElementNameMap[9];
- break;
- }
- default: {
- slangAssert(false && "RSReflection::GetVectorElementName : Unsupported "
- "vector element data type");
- break;
- }
- }
-
- slangAssert((EVT->getNumElement() > 1) &&
- (EVT->getNumElement() <= 4) &&
- "Number of elements in vector type is invalid");
-
- return BaseElement[EVT->getNumElement() - 2];
-}
-
static const char *GetMatrixTypeName(const RSExportMatrixType *EMT) {
static const char *MatrixTypeJavaNameMap[] = {
/* 2x2 */ "Matrix2f",
@@ -302,6 +136,7 @@
"addObj", // RSExportPrimitiveType::DataTypeRSSampler
"addObj", // RSExportPrimitiveType::DataTypeRSScript
"addObj", // RSExportPrimitiveType::DataTypeRSMesh
+ "addObj", // RSExportPrimitiveType::DataTypeRSPath
"addObj", // RSExportPrimitiveType::DataTypeRSProgramFragment
"addObj", // RSExportPrimitiveType::DataTypeRSProgramVertex
"addObj", // RSExportPrimitiveType::DataTypeRSProgramRaster
@@ -317,11 +152,11 @@
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(
- static_cast<const RSExportPrimitiveType*>(ET));
+ return RSExportPrimitiveType::getRSReflectionType(
+ static_cast<const RSExportPrimitiveType*>(ET))->java_name;
}
case RSExportType::ExportClassPointer: {
const RSExportType *PointeeType =
@@ -333,7 +168,12 @@
return RS_TYPE_CLASS_NAME_PREFIX + PointeeType->getName();
}
case RSExportType::ExportClassVector: {
- return GetVectorTypeName(static_cast<const RSExportVectorType*>(ET));
+ const RSExportVectorType *EVT =
+ static_cast<const RSExportVectorType*>(ET);
+ std::stringstream VecName;
+ VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix
+ << EVT->getNumElement();
+ return VecName.str();
}
case RSExportType::ExportClassMatrix: {
return GetMatrixTypeName(static_cast<const RSExportMatrixType*>(ET));
@@ -342,7 +182,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: {
@@ -385,85 +227,24 @@
return "";
}
-static const char *GetBuiltinElementConstruct(const RSExportType *ET) {
+static std::string GetBuiltinElementConstruct(const RSExportType *ET) {
if (ET->getClass() == RSExportType::ExportClassPrimitive) {
const RSExportPrimitiveType *EPT =
static_cast<const RSExportPrimitiveType*>(ET);
- if (EPT->getKind() == RSExportPrimitiveType::DataKindUser) {
- static const char *PrimitiveBuiltinElementConstructMap[] = {
- NULL, // RSExportPrimitiveType::DataTypeFloat16
- "Element.F32", // RSExportPrimitiveType::DataTypeFloat32
- "Element.F64", // RSExportPrimitiveType::DataTypeFloat64
- "Element.I8", // RSExportPrimitiveType::DataTypeSigned8
- "Element.I16", // RSExportPrimitiveType::DataTypeSigned16
- "Element.I32", // RSExportPrimitiveType::DataTypeSigned32
- "Element.I64", // RSExportPrimitiveType::DataTypeSigned64
- "Element.U8", // RSExportPrimitiveType::DataTypeUnsigned8
- "Element.U16", // RSExportPrimitiveType::DataTypeUnsigned16
- "Element.U32", // RSExportPrimitiveType::DataTypeUnsigned32
- "Element.U64", // RSExportPrimitiveType::DataTypeUnsigned64
- "Element.BOOLEAN", // RSExportPrimitiveType::DataTypeBoolean
-
- NULL, // RSExportPrimitiveType::DataTypeUnsigned565
- NULL, // RSExportPrimitiveType::DataTypeUnsigned5551
- NULL, // RSExportPrimitiveType::DataTypeUnsigned4444
-
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix2x2
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix3x3
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix4x4
-
- "Element.ELEMENT", // RSExportPrimitiveType::DataTypeRSElement
- "Element.TYPE", // RSExportPrimitiveType::DataTypeRSType
- "Element.ALLOCATION", // RSExportPrimitiveType::DataTypeRSAllocation
- "Element.SAMPLER", // RSExportPrimitiveType::DataTypeRSSampler
- "Element.SCRIPT", // RSExportPrimitiveType::DataTypeRSScript
- "Element.MESH", // RSExportPrimitiveType::DataTypeRSMesh
- "Element.PROGRAM_FRAGMENT",
- // RSExportPrimitiveType::DataTypeRSProgramFragment
- "Element.PROGRAM_VERTEX",
- // RSExportPrimitiveType::DataTypeRSProgramVertex
- "Element.PROGRAM_RASTER",
- // RSExportPrimitiveType::DataTypeRSProgramRaster
- "Element.PROGRAM_STORE",
- // RSExportPrimitiveType::DataTypeRSProgramStore
- "Element.FONT",
- // RSExportPrimitiveType::DataTypeRSFont
- };
- unsigned TypeId = EPT->getType();
-
- if (TypeId <
- (sizeof(PrimitiveBuiltinElementConstructMap) / sizeof(const char*)))
- return PrimitiveBuiltinElementConstructMap[ EPT->getType() ];
- } else if (EPT->getKind() == RSExportPrimitiveType::DataKindPixelA) {
- if (EPT->getType() == RSExportPrimitiveType::DataTypeUnsigned8)
- return "Element.A_8";
- } else if (EPT->getKind() == RSExportPrimitiveType::DataKindPixelRGB) {
- if (EPT->getType() == RSExportPrimitiveType::DataTypeUnsigned565)
- return "Element.RGB_565";
- else if (EPT->getType() == RSExportPrimitiveType::DataTypeUnsigned8)
- return "Element.RGB_888";
- } else if (EPT->getKind() == RSExportPrimitiveType::DataKindPixelRGBA) {
- if (EPT->getType() == RSExportPrimitiveType::DataTypeUnsigned5551)
- return "Element.RGBA_5551";
- else if (EPT->getType() == RSExportPrimitiveType::DataTypeUnsigned4444)
- return "Element.RGBA_4444";
- else if (EPT->getType() == RSExportPrimitiveType::DataTypeUnsigned8)
- return "Element.RGBA_8888";
- }
+ return std::string("Element.") +
+ RSExportPrimitiveType::getRSReflectionType(EPT)->rs_short_type;
} else if (ET->getClass() == RSExportType::ExportClassVector) {
const RSExportVectorType *EVT = static_cast<const RSExportVectorType*>(ET);
- if (EVT->getKind() == RSExportPrimitiveType::DataKindUser) {
- if (EVT->getType() == RSExportPrimitiveType::DataTypeFloat32) {
- if (EVT->getNumElement() == 2)
- return "Element.F32_2";
- else if (EVT->getNumElement() == 3)
- return "Element.F32_3";
- else if (EVT->getNumElement() == 4)
- return "Element.F32_4";
- } else if (EVT->getType() == RSExportPrimitiveType::DataTypeUnsigned8) {
- if (EVT->getNumElement() == 4)
- return "Element.U8_4";
- }
+ if (EVT->getType() == RSExportPrimitiveType::DataTypeFloat32) {
+ if (EVT->getNumElement() == 2)
+ return "Element.F32_2";
+ else if (EVT->getNumElement() == 3)
+ return "Element.F32_3";
+ else if (EVT->getNumElement() == 4)
+ return "Element.F32_4";
+ } else if (EVT->getType() == RSExportPrimitiveType::DataTypeUnsigned8) {
+ if (EVT->getNumElement() == 4)
+ return "Element.U8_4";
}
} else if (ET->getClass() == RSExportType::ExportClassMatrix) {
const RSExportMatrixType *EMT = static_cast<const RSExportMatrixType *>(ET);
@@ -473,134 +254,10 @@
case 4: return "Element.MATRIX_4X4";
default: slangAssert(false && "Unsupported dimension of matrix");
}
- } else if (ET->getClass() == RSExportType::ExportClassPointer) {
- // Treat pointer type variable as unsigned int
- // TODO(zonr): this is target dependent
- return "Element.USER_I32";
}
+ // RSExportType::ExportClassPointer can't be generated in a struct.
- return NULL;
-}
-
-static const char *GetElementDataKindName(RSExportPrimitiveType::DataKind DK) {
- static const char *ElementDataKindNameMap[] = {
- "Element.DataKind.USER", // RSExportPrimitiveType::DataKindUser
- "Element.DataKind.PIXEL_L", // RSExportPrimitiveType::DataKindPixelL
- "Element.DataKind.PIXEL_A", // RSExportPrimitiveType::DataKindPixelA
- "Element.DataKind.PIXEL_LA", // RSExportPrimitiveType::DataKindPixelLA
- "Element.DataKind.PIXEL_RGB", // RSExportPrimitiveType::DataKindPixelRGB
- "Element.DataKind.PIXEL_RGBA", // RSExportPrimitiveType::DataKindPixelRGBA
- };
-
- if (static_cast<unsigned>(DK) <
- (sizeof(ElementDataKindNameMap) / sizeof(const char*)))
- return ElementDataKindNameMap[ DK ];
- else
- return NULL;
-}
-
-static const char *GetElementDataTypeName(RSExportPrimitiveType::DataType DT) {
- static const char *ElementDataTypeNameMap[] = {
- NULL, // RSExportPrimitiveType::DataTypeFloat16
- "Element.DataType.FLOAT_32", // RSExportPrimitiveType::DataTypeFloat32
- "Element.DataType.FLOAT_64", // RSExportPrimitiveType::DataTypeFloat64
- "Element.DataType.SIGNED_8", // RSExportPrimitiveType::DataTypeSigned8
- "Element.DataType.SIGNED_16", // RSExportPrimitiveType::DataTypeSigned16
- "Element.DataType.SIGNED_32", // RSExportPrimitiveType::DataTypeSigned32
- "Element.DataType.SIGNED_64", // RSExportPrimitiveType::DataTypeSigned64
- "Element.DataType.UNSIGNED_8", // RSExportPrimitiveType::DataTypeUnsigned8
- "Element.DataType.UNSIGNED_16",
- // RSExportPrimitiveType::DataTypeUnsigned16
- "Element.DataType.UNSIGNED_32",
- // RSExportPrimitiveType::DataTypeUnsigned32
- "Element.DataType.UNSIGNED_64",
- // RSExportPrimitiveType::DataTypeUnsigned64
- "Element.DataType.BOOLEAN",
- // RSExportPrimitiveType::DataTypeBoolean
-
- // RSExportPrimitiveType::DataTypeUnsigned565
- "Element.DataType.UNSIGNED_5_6_5",
- // RSExportPrimitiveType::DataTypeUnsigned5551
- "Element.DataType.UNSIGNED_5_5_5_1",
- // RSExportPrimitiveType::DataTypeUnsigned4444
- "Element.DataType.UNSIGNED_4_4_4_4",
-
- // DataTypeRSMatrix* must have been resolved in GetBuiltinElementConstruct()
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix2x2
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix3x3
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix4x4
-
- "Element.DataType.RS_ELEMENT", // RSExportPrimitiveType::DataTypeRSElement
- "Element.DataType.RS_TYPE", // RSExportPrimitiveType::DataTypeRSType
- // RSExportPrimitiveType::DataTypeRSAllocation
- "Element.DataType.RS_ALLOCATION",
- // RSExportPrimitiveType::DataTypeRSSampler
- "Element.DataType.RS_SAMPLER",
- // RSExportPrimitiveType::DataTypeRSScript
- "Element.DataType.RS_SCRIPT",
- // RSExportPrimitiveType::DataTypeRSMesh
- "Element.DataType.RS_MESH",
- // RSExportPrimitiveType::DataTypeRSProgramFragment
- "Element.DataType.RS_PROGRAM_FRAGMENT",
- // RSExportPrimitiveType::DataTypeRSProgramVertex
- "Element.DataType.RS_PROGRAM_VERTEX",
- // RSExportPrimitiveType::DataTypeRSProgramRaster
- "Element.DataType.RS_PROGRAM_RASTER",
- // RSExportPrimitiveType::DataTypeRSProgramStore
- "Element.DataType.RS_PROGRAM_STORE",
- // RSExportPrimitiveType::DataTypeRSFont
- "Element.DataType.RS_FONT",
- };
-
- if (static_cast<unsigned>(DT) <
- (sizeof(ElementDataTypeNameMap) / sizeof(const char*)))
- return ElementDataTypeNameMap[ DT ];
- else
- return NULL;
-}
-
-static const char *GetElementJavaTypeName(RSExportPrimitiveType::DataType DT) {
- static const char *ElementJavaTypeNameMap[] = {
- NULL, // RSExportPrimitiveType::DataTypeFloat16
- "F32", // RSExportPrimitiveType::DataTypeFloat32
- "F64", // RSExportPrimitiveType::DataTypeFloat64
- "I8", // RSExportPrimitiveType::DataTypeSigned8
- "I16", // RSExportPrimitiveType::DataTypeSigned16
- "I32", // RSExportPrimitiveType::DataTypeSigned32
- "I64", // RSExportPrimitiveType::DataTypeSigned64
- "U8", // RSExportPrimitiveType::DataTypeUnsigned8
- "U16", // RSExportPrimitiveType::DataTypeUnsigned16
- "U32", // RSExportPrimitiveType::DataTypeUnsigned32
- "U64", // RSExportPrimitiveType::DataTypeUnsigned64
- "BOOLEAN", // RSExportPrimitiveType::DataTypeBoolean
-
- "RGB_565", // RSExportPrimitiveType::DataTypeUnsigned565
- "RGBA_5551", // RSExportPrimitiveType::DataTypeUnsigned5551
- "RGBA_4444", // RSExportPrimitiveType::DataTypeUnsigned4444
-
- // DataTypeRSMatrix* must have been resolved in GetBuiltinElementConstruct()
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix2x2
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix3x3
- NULL, // (Dummy) RSExportPrimitiveType::DataTypeRSMatrix4x4
-
- "ELEMENT", // RSExportPrimitiveType::DataTypeRSElement
- "TYPE", // RSExportPrimitiveType::DataTypeRSType
- "ALLOCATION", // RSExportPrimitiveType::DataTypeRSAllocation
- "SAMPLER", // RSExportPrimitiveType::DataTypeRSSampler
- "SCRIPT", // RSExportPrimitiveType::DataTypeRSScript
- "MESH", // RSExportPrimitiveType::DataTypeRSMesh
- "PROGRAM_FRAGMENT", // RSExportPrimitiveType::DataTypeRSProgramFragment
- "PROGRAM_VERTEX", // RSExportPrimitiveType::DataTypeRSProgramVertex
- "PROGRAM_RASTER", // RSExportPrimitiveType::DataTypeRSProgramRaster
- "PROGRAM_STORE", // RSExportPrimitiveType::DataTypeRSProgramStore
- "FONT", // RSExportPrimitiveType::DataTypeRSFont
- };
-
- if (static_cast<unsigned>(DT) <
- (sizeof(ElementJavaTypeNameMap) / sizeof(const char*)))
- return ElementJavaTypeNameMap[DT];
- else
- return NULL;
+ return "";
}
@@ -665,8 +322,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
@@ -720,37 +392,7 @@
slangAssert(!Val.isUninit() && "Not a valid initializer");
C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = ";
- switch (Val.getKind()) {
- case clang::APValue::Int: {
- llvm::APInt api = Val.getInt();
- C.out() << api.getSExtValue();
- if (api.getBitWidth() > 32) {
- C.out() << "L";
- }
- break;
- }
- case clang::APValue::Float: {
- llvm::APFloat apf = Val.getFloat();
- if (&apf.getSemantics() == &llvm::APFloat::IEEEsingle) {
- C.out() << apf.convertToFloat() << "f";
- } else {
- C.out() << apf.convertToDouble();
- }
- break;
- }
-
- case clang::APValue::ComplexInt:
- case clang::APValue::ComplexFloat:
- case clang::APValue::LValue:
- case clang::APValue::Vector: {
- slangAssert(false &&
- "Primitive type cannot have such kind of initializer");
- break;
- }
- default: {
- slangAssert(false && "Unknown kind of initializer");
- }
- }
+ C.out() << RSReflectionBase::genInitValue(Val);
C.out() << ";" << std::endl;
return;
@@ -792,8 +434,11 @@
break;
}
case clang::APValue::Vector: {
+ std::stringstream VecName;
+ VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix
+ << EVT->getNumElement();
C.indent() << RS_EXPORT_VAR_PREFIX << VarName << " = new "
- << GetVectorTypeName(EVT) << "();" << std::endl;
+ << VecName.str() << "();" << std::endl;
unsigned NumElements =
std::min(static_cast<unsigned>(EVT->getNumElement()),
@@ -805,10 +450,15 @@
}
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:
+ case clang::APValue::AddrLabelDiff: {
slangAssert(false && "Unexpected type of value of initializer.");
}
}
@@ -943,6 +593,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;
@@ -1041,25 +700,12 @@
static_cast<const RSExportPrimitiveType*>(ET);
slangAssert(EPT);
- switch (EPT->getKind()) {
- case RSExportPrimitiveType::DataKindPixelL:
- case RSExportPrimitiveType::DataKindPixelA:
- case RSExportPrimitiveType::DataKindPixelLA:
- case RSExportPrimitiveType::DataKindPixelRGB:
- case RSExportPrimitiveType::DataKindPixelRGBA: {
- break;
- }
-
- case RSExportPrimitiveType::DataKindUser:
- default: {
- std::string TypeName = GetElementJavaTypeName(EPT->getType());
- if (C.mTypesToCheck.find(TypeName) == C.mTypesToCheck.end()) {
- C.indent() << "__" << TypeName << " = Element." << TypeName
- << "(rs);" << std::endl;
- C.mTypesToCheck.insert(TypeName);
- }
- break;
- }
+ std::string TypeName =
+ RSExportPrimitiveType::getRSReflectionType(EPT)->rs_short_type;
+ if (C.mTypesToCheck.find(TypeName) == C.mTypesToCheck.end()) {
+ C.indent() << "__" << TypeName << " = Element." << TypeName
+ << "(rs);" << std::endl;
+ C.mTypesToCheck.insert(TypeName);
}
break;
}
@@ -1069,7 +715,10 @@
static_cast<const RSExportVectorType*>(ET);
slangAssert(EVT);
- const char *TypeName = GetVectorElementName(EVT);
+ std::stringstream VecName;
+ VecName << EVT->getRSReflectionType(EVT)->rs_short_type
+ << "_" << EVT->getNumElement();
+ std::string TypeName = VecName.str();
if (C.mTypesToCheck.find(TypeName) == C.mTypesToCheck.end()) {
C.indent() << "__" << TypeName << " = Element." << TypeName
<< "(rs);" << std::endl;
@@ -1117,9 +766,8 @@
static_cast<const RSExportPrimitiveType*>(ET);
slangAssert(EPT);
- if (EPT->getKind() == RSExportPrimitiveType::DataKindUser) {
- TypeName = GetElementJavaTypeName(EPT->getType());
- }
+ TypeName =
+ RSExportPrimitiveType::getRSReflectionType(EPT)->rs_short_type;
break;
}
@@ -1127,7 +775,10 @@
const RSExportVectorType *EVT =
static_cast<const RSExportVectorType*>(ET);
slangAssert(EVT);
- TypeName = GetVectorElementName(EVT);
+ std::stringstream VecName;
+ VecName << EVT->getRSReflectionType(EVT)->rs_short_type
+ << "_" << EVT->getNumElement();
+ TypeName = VecName.str();
break;
}
@@ -1164,13 +815,20 @@
const RSExportPrimitiveType *EPT =
static_cast<const RSExportPrimitiveType*>(EV->getType());
- const char *TypeName = GetPrimitiveTypeName(EPT);
+ const char *TypeName =
+ RSExportPrimitiveType::getRSReflectionType(EPT)->java_name;
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();
+ C.out() << RSReflectionBase::genInitValue(Val, EPT->getType() ==
+ RSExportPrimitiveType::DataTypeBoolean) << ";" << std::endl;
+ } else {
+ // set_*()
C.startFunction(Context::AM_Public,
false,
"void",
@@ -1239,7 +897,10 @@
const RSExportVectorType *EVT =
static_cast<const RSExportVectorType*>(EV->getType());
- const char *TypeName = GetVectorTypeName(EVT);
+ std::stringstream VecName;
+ VecName << EVT->getRSReflectionType(EVT)->rs_java_vector_prefix
+ << EVT->getNumElement();
+ std::string TypeName = VecName.str();
const char *FieldPackerName = "fp";
C.indent() << "private " << TypeName << " "RS_EXPORT_VAR_PREFIX
@@ -1252,7 +913,7 @@
"void",
"set_" + EV->getName(),
1,
- TypeName, "v");
+ TypeName.c_str(), "v");
C.indent() << RS_EXPORT_VAR_PREFIX << EV->getName() << " = v;" << std::endl;
if (genCreateFieldPacker(C, EVT, FieldPackerName))
@@ -1616,6 +1277,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 +1349,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 +1394,7 @@
C.indent() << "init(" << RenderScriptVar << ", count);" << std::endl;
C.endFunction();
+ // 1D with usage
C.startFunction(Context::AM_Public,
false,
NULL,
@@ -1721,9 +1412,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,
@@ -1963,48 +1754,33 @@
const char *ElementBuilderName,
const char *RenderScriptVar,
unsigned ArraySize) {
- const char *ElementConstruct = GetBuiltinElementConstruct(ET);
+ std::string ElementConstruct = GetBuiltinElementConstruct(ET);
- if (ElementConstruct != NULL) {
+ if (ElementConstruct != "") {
EB_ADD(ElementConstruct << "(" << RenderScriptVar << ")");
} else {
if ((ET->getClass() == RSExportType::ExportClassPrimitive) ||
(ET->getClass() == RSExportType::ExportClassVector)) {
const RSExportPrimitiveType *EPT =
static_cast<const RSExportPrimitiveType*>(ET);
- const char *DataKindName = GetElementDataKindName(EPT->getKind());
- const char *DataTypeName = GetElementDataTypeName(EPT->getType());
+ const char *DataTypeName =
+ RSExportPrimitiveType::getRSReflectionType(EPT)->rs_type;
int Size = (ET->getClass() == RSExportType::ExportClassVector) ?
static_cast<const RSExportVectorType*>(ET)->getNumElement() :
1;
- switch (EPT->getKind()) {
- case RSExportPrimitiveType::DataKindPixelL:
- case RSExportPrimitiveType::DataKindPixelA:
- case RSExportPrimitiveType::DataKindPixelLA:
- case RSExportPrimitiveType::DataKindPixelRGB:
- case RSExportPrimitiveType::DataKindPixelRGBA: {
- // Element.createPixel()
- EB_ADD("Element.createPixel(" << RenderScriptVar << ", "
- << DataTypeName << ", "
- << DataKindName << ")");
- break;
- }
- case RSExportPrimitiveType::DataKindUser:
- default: {
- if (EPT->getClass() == RSExportType::ExportClassPrimitive) {
- // Element.createUser()
- EB_ADD("Element.createUser(" << RenderScriptVar << ", "
- << DataTypeName << ")");
- } else {
- slangAssert((ET->getClass() == RSExportType::ExportClassVector) &&
- "Unexpected type.");
- EB_ADD("Element.createVector(" << RenderScriptVar << ", "
- << DataTypeName << ", "
- << Size << ")");
- }
- break;
- }
+ if (EPT->getClass() == RSExportType::ExportClassPrimitive) {
+ // Element.createUser()
+ EB_ADD("Element.createUser(" << RenderScriptVar
+ << ", Element.DataType."
+ << DataTypeName << ")");
+ } else {
+ slangAssert((ET->getClass() == RSExportType::ExportClassVector) &&
+ "Unexpected type.");
+ EB_ADD("Element.createVector(" << RenderScriptVar
+ << ", Element.DataType."
+ << DataTypeName << ", "
+ << Size << ")");
}
#ifndef NDEBUG
} else if (ET->getClass() == RSExportType::ExportClassPointer) {
@@ -2093,11 +1869,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 +1924,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 +1940,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 +1995,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_reflection_base.cpp b/slang_rs_reflection_base.cpp
new file mode 100644
index 0000000..c29c89d
--- /dev/null
+++ b/slang_rs_reflection_base.cpp
@@ -0,0 +1,193 @@
+/*
+ * Copyright 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/stat.h>
+
+#include <cstdarg>
+#include <cctype>
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "os_sep.h"
+#include "slang_rs_context.h"
+#include "slang_rs_export_var.h"
+#include "slang_rs_export_foreach.h"
+#include "slang_rs_export_func.h"
+#include "slang_rs_reflect_utils.h"
+#include "slang_version.h"
+#include "slang_utils.h"
+
+#include "slang_rs_reflection_base.h"
+
+
+
+using namespace std;
+
+namespace slang {
+
+static const char *const gApacheLicenseNote =
+"/*\n"
+" * Copyright (C) 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"
+" * You may obtain a copy of the License at\n"
+" *\n"
+" * http://www.apache.org/licenses/LICENSE-2.0\n"
+" *\n"
+" * Unless required by applicable law or agreed to in writing, software\n"
+" * distributed under the License is distributed on an \"AS IS\" BASIS,\n"
+" * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
+" * See the License for the specific language governing permissions and\n"
+" * limitations under the License.\n"
+" */\n"
+"\n";
+
+
+RSReflectionBase::RSReflectionBase(const RSContext *con) {
+ mRSContext = con;
+ mLicenseNote = gApacheLicenseNote;
+
+}
+
+RSReflectionBase::~RSReflectionBase() {
+
+}
+
+/*
+bool RSReflectionBase::openFile(const string &name, string &errorMsg) {
+ if(!mUseStdout) {
+ mOF.clear();
+ if(!SlangUtils::CreateDirectoryWithParents(mOutputPath, &errorMsg)) {
+ return false;
+ }
+
+ string cf(mOutputPath + OS_PATH_SEPARATOR_STR + name);
+ mOF.open(cf.c_str());
+ if(!mOF.good()) {
+ errorMsg = "failed to open file '" + cf + "' for write";
+ return false;
+ }
+ }
+ return true;
+}
+*/
+
+void RSReflectionBase::startFile(const string &filename) {
+ if(mVerbose) {
+ printf("Generating %s\n", filename.c_str());
+ }
+
+ // License
+ write(mLicenseNote);
+
+ // Notice of generated file
+ write("/*");
+ write(" * This file is auto-generated. DO NOT MODIFY!");
+ write(" * The source Renderscript file: " + mInputFileName);
+ write(" */");
+ write("");
+}
+
+string RSReflectionBase::stripRS(const string &s) const {
+ size_t pos = s.rfind(".rs");
+ if(pos != string::npos) {
+ string tmp(s);
+ tmp.erase(pos);
+ return tmp;
+ }
+ return s;
+}
+
+void RSReflectionBase::write(const std::string &t) {
+ //printf("%s%s\n", mIndent.c_str(), t.c_str());
+ mText.push_back(mIndent + t);
+}
+
+void RSReflectionBase::write(const std::stringstream &t) {
+ mText.push_back(mIndent + t.str());
+}
+
+
+void RSReflectionBase::incIndent() {
+ mIndent.append(" ");
+}
+
+void RSReflectionBase::decIndent() {
+ mIndent.erase(0, 4);
+}
+
+bool RSReflectionBase::writeFile(const string &filename, const vector< string > &txt) {
+ FILE *pfin = fopen(filename.c_str(), "wt");
+ if (pfin == NULL) {
+ fprintf(stderr, "Error: could not write file %s\n", filename.c_str());
+ return false;
+ }
+
+ for(size_t ct=0; ct < txt.size(); ct++) {
+ fprintf(pfin, "%s\n", txt[ct].c_str());
+ }
+ fclose(pfin);
+ return true;
+}
+
+
+string RSReflectionBase::genInitValue(const clang::APValue &Val, bool asBool) {
+ stringstream tmp;
+ switch (Val.getKind()) {
+ case clang::APValue::Int: {
+ llvm::APInt api = Val.getInt();
+ if(asBool) {
+ tmp << ((api.getSExtValue() == 0) ? "false" : "true");
+ } else {
+ tmp << api.getSExtValue();
+ if (api.getBitWidth() > 32) {
+ tmp << "L";
+ }
+ }
+ break;
+ }
+
+ case clang::APValue::Float: {
+ llvm::APFloat apf = Val.getFloat();
+ if (&apf.getSemantics() == &llvm::APFloat::IEEEsingle) {
+ tmp << apf.convertToFloat() << "f";
+ } else {
+ tmp << apf.convertToDouble();
+ }
+ break;
+ }
+
+ case clang::APValue::ComplexInt:
+ case clang::APValue::ComplexFloat:
+ case clang::APValue::LValue:
+ case clang::APValue::Vector: {
+ slangAssert(false && "Primitive type cannot have such kind of initializer");
+ break;
+ }
+
+ default: {
+ slangAssert(false && "Unknown kind of initializer");
+ }
+ }
+ return tmp.str();
+}
+
+
+}
diff --git a/slang_rs_reflection_base.h b/slang_rs_reflection_base.h
new file mode 100644
index 0000000..474a738
--- /dev/null
+++ b/slang_rs_reflection_base.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_BASE_H_ // NOLINT
+#define _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_BASE_H_
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "llvm/ADT/StringExtras.h"
+
+#include "slang_assert.h"
+#include "slang_rs_export_type.h"
+
+namespace slang {
+ class RSContext;
+ class RSExportVar;
+ class RSExportFunc;
+ class RSExportForEach;
+
+class RSReflectionBase {
+protected:
+ const RSContext *mRSContext;
+
+
+
+ RSReflectionBase(const RSContext *);
+
+
+ bool mVerbose;
+
+ std::string mLicenseNote;
+ std::string mInputFileName;
+
+ std::string mClassName;
+ std::string mOutputPath;
+ std::string mOutputBCFileName;
+
+ std::vector< std::string > mText;
+ std::string mIndent;
+
+ bool openFile(const std::string &name, std::string &errorMsg);
+ void startFile(const std::string &filename);
+ void incIndent();
+ void decIndent();
+ void write(const std::string &t);
+ void write(const std::stringstream &t);
+
+ std::string stripRS(const std::string &s) const;
+
+ static bool writeFile(const std::string &filename, const std::vector< std::string > &txt);
+
+
+private:
+
+public:
+ virtual ~RSReflectionBase();
+
+ static std::string genInitValue(const clang::APValue &Val, bool asBool=false);
+
+}; // class RSReflection
+
+} // namespace slang
+
+#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_BASE_H_ NOLINT
diff --git a/slang_rs_reflection_cpp.cpp b/slang_rs_reflection_cpp.cpp
new file mode 100644
index 0000000..b4765b4
--- /dev/null
+++ b/slang_rs_reflection_cpp.cpp
@@ -0,0 +1,306 @@
+/*
+ * Copyright 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/stat.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <cstdarg>
+#include <cctype>
+
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <utility>
+
+#include "os_sep.h"
+#include "slang_rs_context.h"
+#include "slang_rs_export_var.h"
+#include "slang_rs_export_foreach.h"
+#include "slang_rs_export_func.h"
+#include "slang_rs_reflect_utils.h"
+#include "slang_version.h"
+#include "slang_utils.h"
+
+#include "slang_rs_reflection_cpp.h"
+
+using namespace std;
+
+namespace slang {
+
+RSReflectionCpp::RSReflectionCpp(const RSContext *con) :
+ RSReflectionBase(con) {
+
+}
+
+RSReflectionCpp::~RSReflectionCpp() {
+
+}
+
+bool RSReflectionCpp::reflect(const string &OutputPathBase,
+ const string &InputFileName,
+ const string &OutputBCFileName) {
+ mInputFileName = InputFileName;
+ mOutputPath = OutputPathBase;
+ mOutputBCFileName = OutputBCFileName;
+ mClassName = string("ScriptC_") + stripRS(InputFileName);
+
+ makeHeader("ScriptC");
+ std::vector< std::string > header(mText);
+ mText.clear();
+
+ makeImpl("ScriptC");
+ std::vector< std::string > cpp(mText);
+ mText.clear();
+
+
+ RSReflectionBase::writeFile(mClassName + ".h", header);
+ RSReflectionBase::writeFile(mClassName + ".cpp", cpp);
+
+
+ return false;
+}
+
+typedef std::vector<std::pair<std::string, std::string> > ArgTy;
+
+
+#define RS_TYPE_CLASS_NAME_PREFIX "ScriptField_"
+
+
+
+bool RSReflectionCpp::makeHeader(const std::string &baseClass) {
+ startFile(mClassName + ".h");
+
+ write("");
+ write("#include \"ScriptC.h\"");
+ write("");
+
+ // Imports
+ //for(unsigned i = 0; i < (sizeof(Import) / sizeof(const char*)); i++)
+ //out() << "import " << Import[i] << ";" << std::endl;
+ //out() << std::endl;
+
+ if(!baseClass.empty()) {
+ write("class " + mClassName + " : protected " + baseClass + " {");
+ } else {
+ write("class " + mClassName + " {");
+ }
+
+ write("private:");
+ uint32_t slot = 0;
+ incIndent();
+ for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(),
+ E = mRSContext->export_vars_end(); I != E; I++, slot++) {
+
+ const RSExportVar *ev = *I;
+ RSReflectionTypeData rtd;
+ ev->getType()->convertToRTD(&rtd);
+ if(!ev->isConst()) {
+ write(string(rtd.type->c_name) + " __" + ev->getName() + ";");
+ }
+ }
+ decIndent();
+
+ write("public:");
+ incIndent();
+ write(mClassName + "(RenderScript *rs, const char *cacheDir, size_t cacheDirLength);");
+ write("virtual ~" + mClassName + "();");
+ write("");
+
+
+ // Reflect export variable
+ slot = 0;
+ for (RSContext::const_export_var_iterator I = mRSContext->export_vars_begin(),
+ E = mRSContext->export_vars_end(); I != E; I++, slot++) {
+
+ const RSExportVar *ev = *I;
+ RSReflectionTypeData rtd;
+ ev->getType()->convertToRTD(&rtd);
+
+ if(!ev->isConst()) {
+ write(string("void set_") + ev->getName() + "(" + rtd.type->c_name + " v) {");
+ stringstream tmp;
+ tmp << slot;
+ write(string(" setVar(") + tmp.str() + ", v);");
+ write(string(" __") + ev->getName() + " = v;");
+ write("}");
+ }
+ write(string(rtd.type->c_name) + " get_" + ev->getName() + "() const {");
+ if(ev->isConst()) {
+ const clang::APValue &val = ev->getInit();
+ bool isBool = !strcmp(rtd.type->c_name, "bool");
+ write(string(" return ") + genInitValue(val, isBool) + ";");
+ } else {
+ write(string(" return __") + ev->getName() + ";");
+ }
+ write("}");
+ write("");
+ }
+
+ // Reflect export for each functions
+ for (RSContext::const_export_foreach_iterator I = mRSContext->export_foreach_begin(),
+ E = mRSContext->export_foreach_end(); I != E; I++) {
+
+ const RSExportForEach *ef = *I;
+ if (ef->isDummyRoot()) {
+ write("// No forEach_root(...)");
+ continue;
+ }
+
+ stringstream tmp;
+ tmp << "void forEach_" << ef->getName() << "(";
+ if(ef->hasIn() && ef->hasOut()) {
+ tmp << "const Allocation *ain, const Allocation *aout";
+ } else if(ef->hasIn()) {
+ tmp << "const Allocation *ain";
+ } else {
+ tmp << "const Allocation *aout";
+ }
+
+ if(ef->getParamPacketType()) {
+ for(RSExportForEach::const_param_iterator i = ef->params_begin(),
+ e = ef->params_end(); i != e; i++) {
+
+ RSReflectionTypeData rtd;
+ (*i)->getType()->convertToRTD(&rtd);
+ tmp << rtd.type->c_name << " " << (*i)->getName();
+ }
+ }
+ tmp << ") const;";
+ write(tmp);
+ }
+
+
+ // Reflect export function
+ for (RSContext::const_export_func_iterator I = mRSContext->export_funcs_begin(),
+ E = mRSContext->export_funcs_end(); I != E; I++) {
+
+ //genExportFunction(C, *I);
+ }
+
+ decIndent();
+ write("};");
+ return true;
+}
+
+bool RSReflectionCpp::writeBC() {
+ FILE *pfin = fopen(mOutputBCFileName.c_str(), "rb");
+ if (pfin == NULL) {
+ fprintf(stderr, "Error: could not read file %s\n", mOutputBCFileName.c_str());
+ return false;
+ }
+
+ unsigned char buf[16];
+ int read_length;
+ write("static const unsigned char __txt[] = {");
+ incIndent();
+ while ((read_length = fread(buf, 1, sizeof(buf), pfin)) > 0) {
+ string s;
+ for(int i = 0; i < read_length; i++) {
+ char buf2[16];
+ sprintf(buf2, "0x%02x,", buf[i]);
+ s += buf2;
+ }
+ write(s);
+ }
+ decIndent();
+ write("};");
+ write("");
+ return true;
+}
+
+bool RSReflectionCpp::makeImpl(const std::string &baseClass) {
+ startFile(mClassName + ".h");
+
+ write("");
+ write("#include \"" + mClassName + ".h\"");
+ write("");
+
+ writeBC();
+
+ // Imports
+ //for(unsigned i = 0; i < (sizeof(Import) / sizeof(const char*)); i++)
+ //out() << "import " << Import[i] << ";" << std::endl;
+ //out() << std::endl;
+
+ write(mClassName + "::" + mClassName +
+ "(RenderScript *rs, const char *cacheDir, size_t cacheDirLength) :");
+ write(" ScriptC(rs, __txt, sizeof(__txt), \"" + mInputFileName +
+ "\", 4, cacheDir, cacheDirLength) {");
+ incIndent();
+ //...
+ decIndent();
+ write("}");
+ write("");
+
+ write(mClassName + "::~" + mClassName + "() {");
+ write("}");
+ write("");
+
+ // Reflect export for each functions
+ uint32_t slot = 0;
+ for (RSContext::const_export_foreach_iterator I = mRSContext->export_foreach_begin(),
+ E = mRSContext->export_foreach_end(); I != E; I++, slot++) {
+
+ const RSExportForEach *ef = *I;
+ if (ef->isDummyRoot()) {
+ write("// No forEach_root(...)");
+ continue;
+ }
+
+ stringstream tmp;
+ tmp << "void " << mClassName << "::forEach_" << ef->getName() << "(";
+ if(ef->hasIn() && ef->hasOut()) {
+ tmp << "const Allocation *ain, const Allocation *aout";
+ } else if(ef->hasIn()) {
+ tmp << "const Allocation *ain";
+ } else {
+ tmp << "const Allocation *aout";
+ }
+ tmp << ") const {";
+ write(tmp);
+ tmp.str("");
+
+ tmp << " forEach(" << slot << ", ";
+ if(ef->hasIn() && ef->hasOut()) {
+ tmp << "ain, aout, NULL, 0);";
+ } else if(ef->hasIn()) {
+ tmp << "ain, NULL, 0);";
+ } else {
+ tmp << "aout, NULL, 0);";
+ }
+ write(tmp);
+
+ write("}");
+ write("");
+ }
+
+
+ // Reflect export function
+ slot = 0;
+ for (RSContext::const_export_func_iterator I = mRSContext->export_funcs_begin(),
+ E = mRSContext->export_funcs_end(); I != E; I++) {
+
+ //genExportFunction(C, *I);
+ }
+
+ decIndent();
+ return true;
+}
+
+
+
+}
diff --git a/slang_rs_reflection_cpp.h b/slang_rs_reflection_cpp.h
new file mode 100644
index 0000000..1537286
--- /dev/null
+++ b/slang_rs_reflection_cpp.h
@@ -0,0 +1,48 @@
+/*
+ * Copyright 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_CPP_H_ // NOLINT
+#define _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_CPP_H_
+
+#include "slang_rs_reflection_base.h"
+
+namespace slang {
+
+class RSReflectionCpp : public RSReflectionBase {
+protected:
+
+
+public:
+ RSReflectionCpp(const RSContext *);
+ virtual ~RSReflectionCpp();
+
+ bool reflect(const std::string &OutputPathBase,
+ const std::string &InputFileName,
+ const std::string &OutputBCFileName);
+
+
+private:
+ bool makeHeader(const std::string &baseClass);
+ bool makeImpl(const std::string &baseClass);
+ bool writeBC();
+
+ bool startScriptHeader();
+
+}; // class RSReflection
+
+} // namespace slang
+
+#endif // _FRAMEWORKS_COMPILE_SLANG_SLANG_RS_REFLECTION_CPP_H_ NOLINT
diff --git a/slang_rs_spec_table.cpp b/slang_rs_spec_table.cpp
index 51dc1fb..87fb3b5 100644
--- a/slang_rs_spec_table.cpp
+++ b/slang_rs_spec_table.cpp
@@ -47,12 +47,6 @@
#undef RS_OBJECT_DATA_TYPE_RANGE
};
-enum {
-#define ENUM_RS_DATA_KIND(x) x,
- RS_DATA_KIND_ENUMS
-#undef ENUM_RS_DATA_KIND
-};
-
class RSDataTypeSpec {
private:
const char *mTypeName; // e.g. Float32
@@ -134,36 +128,19 @@
/////////////////////////////////////////////////////////////////////////////
-class RSDataKindSpec {
- private:
- const char *mKindName;
-
- public:
- explicit RSDataKindSpec(const char *KindName) : mKindName(KindName) {
- return;
- }
-
- inline const char *getKindName() const { return mKindName; }
-};
-
-/////////////////////////////////////////////////////////////////////////////
-
class RSDataElementSpec {
private:
const char *mElementName;
- const RSDataKindSpec *mDataKind;
const RSDataTypeSpec *mDataType;
bool mIsNormal;
unsigned mVectorSize;
public:
RSDataElementSpec(const char *ElementName,
- const RSDataKindSpec *DataKind,
const RSDataTypeSpec *DataType,
bool IsNormal,
unsigned VectorSize)
: mElementName(ElementName),
- mDataKind(DataKind),
mDataType(DataType),
mIsNormal(IsNormal),
mVectorSize(VectorSize) {
@@ -171,7 +148,6 @@
}
inline const char *getElementName() const { return mElementName; }
- inline const RSDataKindSpec *getDataKind() const { return mDataKind; }
inline const RSDataTypeSpec *getDataType() const { return mDataType; }
inline bool isNormal() const { return mIsNormal; }
inline unsigned getVectorSize() const { return mVectorSize; }
@@ -297,18 +273,6 @@
return 0;
}
-// -gen-rs-data-kind-enums
-//
-// ENUM_RS_DATA_KIND(kind)
-// e.g., ENUM_RS_DATA_KIND(PixelRGB)
-int GenRSDataKindEnums(const RSDataKindSpec *const DataKinds[],
- unsigned NumDataKinds) {
- for (unsigned i = 0; i < NumDataKinds; i++)
- printf("ENUM_RS_DATA_KIND(%s)\n", DataKinds[i]->getKindName());
- printf("#undef ENUM_RS_DATA_KIND\n");
- return 0;
-}
-
// -gen-rs-data-element-enums
//
// ENUM_RS_DATA_ELEMENT(name, dt, dk, normailized, vsize)
@@ -316,9 +280,8 @@
int GenRSDataElementEnums(const RSDataElementSpec *const DataElements[],
unsigned NumDataElements) {
for (unsigned i = 0; i < NumDataElements; i++)
- printf("ENUM_RS_DATA_ELEMENT(\"%s\", %s, %s, %s, %d)\n",
+ printf("ENUM_RS_DATA_ELEMENT(\"%s\", %s, %s, %d)\n",
DataElements[i]->getElementName(),
- DataElements[i]->getDataKind()->getKindName(),
DataElements[i]->getDataType()->getTypeName(),
((DataElements[i]->isNormal()) ? "true" : "false"),
DataElements[i]->getVectorSize());
@@ -390,47 +353,29 @@
/////////////////////////////////////////////////////////////////////////////
- RSDataKindSpec *DataKinds[] = {
-#define ENUM_RS_DATA_KIND(x) \
- new RSDataKindSpec(#x),
- RS_DATA_KIND_ENUMS
-#undef ENUM_RS_DATA_KIND
- };
-
- unsigned NumDataKinds = sizeof(DataKinds) / sizeof(DataKinds[0]);
- /////////////////////////////////////////////////////////////////////////////
-
RSDataElementSpec *DataElements[] = {
new RSDataElementSpec("rs_pixel_l",
- DataKinds[PixelL],
DataTypes[Unsigned8],
/* IsNormal = */true, /* VectorSize = */1),
new RSDataElementSpec("rs_pixel_a",
- DataKinds[PixelA],
DataTypes[Unsigned8],
true, 1),
new RSDataElementSpec("rs_pixel_la",
- DataKinds[PixelLA],
DataTypes[Unsigned8],
true, 2),
new RSDataElementSpec("rs_pixel_rgb",
- DataKinds[PixelRGB],
DataTypes[Unsigned8],
true, 3),
new RSDataElementSpec("rs_pixel_rgba",
- DataKinds[PixelRGB],
DataTypes[Unsigned8],
true, 4),
new RSDataElementSpec("rs_pixel_rgb565",
- DataKinds[PixelRGB],
DataTypes[Unsigned8],
true, 3),
new RSDataElementSpec("rs_pixel_rgb5551",
- DataKinds[PixelRGBA],
DataTypes[Unsigned8],
true, 4),
new RSDataElementSpec("rs_pixel_rgb4444",
- DataKinds[PixelRGBA],
DataTypes[Unsigned8],
true, 4),
};
@@ -447,8 +392,6 @@
Result = GenRSMatrixTypeEnums(DataTypes, NumDataTypes);
else if (::strcmp(argv[1], "-gen-rs-object-type-enums") == 0)
Result = GenRSObjectTypeEnums(DataTypes, NumDataTypes);
- else if (::strcmp(argv[1], "-gen-rs-data-kind-enums") == 0)
- Result = GenRSDataKindEnums(DataKinds, NumDataKinds);
else if (::strcmp(argv[1], "-gen-rs-data-element-enums") == 0)
Result = GenRSDataElementEnums(DataElements, NumDataElements);
else
@@ -461,8 +404,6 @@
delete DataTypes[i];
for (unsigned i = 0; i < NumClangBuilitins; i++)
delete ClangBuilitinsMap[i];
- for (unsigned i = 0; i < NumDataKinds; i++)
- delete DataKinds[i];
for (unsigned i = 0; i < NumDataElements; i++)
delete DataElements[i];
diff --git a/slang_rs_type_spec.h b/slang_rs_type_spec.h
index bd7b157..08151f9 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") \
@@ -63,14 +64,6 @@
ENUM_RS_OBJECT_DATA_TYPE(RSFont, "rs_font") \
RS_OBJECT_DATA_TYPE_RANGE(RSElement, RSFont)
-#define RS_DATA_KIND_ENUMS \
- ENUM_RS_DATA_KIND(User) \
- ENUM_RS_DATA_KIND(PixelL) \
- ENUM_RS_DATA_KIND(PixelA) \
- ENUM_RS_DATA_KIND(PixelLA) \
- ENUM_RS_DATA_KIND(PixelRGB) \
- ENUM_RS_DATA_KIND(PixelRGBA)
-
enum RSTypeClass {
#define ENUM_RS_DATA_TYPE_CLASS(x) RS_TC_ ## x,
RS_DATA_TYPE_CLASS_ENUMS
@@ -106,13 +99,6 @@
RS_DT_USER_DEFINED
};
-enum RSDataKind {
-#define ENUM_RS_DATA_KIND(x) RS_DK_ ## x,
- RS_DATA_KIND_ENUMS
-#undef ENUM_RS_DATA_KIND
- RS_DK_Max
-};
-
// Forward declaration
union RSType;
@@ -163,7 +149,6 @@
struct RSRecordField {
const char *name; // field name
const union RSType *type;
- enum RSDataKind dk;
};
struct RSRecordType {
@@ -258,9 +243,4 @@
#define RS_RECORD_TYPE_SET_FIELD_TYPE(R, I, V) \
RS_RECORD_TYPE_GET_FIELD_TYPE(R, I) = (V)
-#define RS_RECORD_TYPE_GET_FIELD_DATA_KIND(R, I) \
- RS_CAST_TO_RECORD_TYPE(R)->field[(I)].dk
-#define RS_RECORD_TYPE_SET_FIELD_DATA_KIND(R, I, V) \
- RS_RECORD_TYPE_GET_FIELD_DATA_KIND(R, I) = (V)
-
#endif // _COMPILE_SLANG_SLANG_RS_TYPE_SPEC_H_ NOLINT
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 6ca87bf..ef390ea 100644
--- a/slang_version.h
+++ b/slang_version.h
@@ -18,18 +18,22 @@
#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
-
// SlangVersion refers to the released compiler version (for which certain
// behaviors could change - i.e. critical bugs fixed that may require
// additional workarounds in the backend compiler).
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_export_types/export_types.rs b/tests/P_export_types/export_types.rs
new file mode 100644
index 0000000..a885a18
--- /dev/null
+++ b/tests/P_export_types/export_types.rs
@@ -0,0 +1,32 @@
+#pragma version(1)
+#pragma rs java_package_name(foo)
+
+float f = 9.9999f;
+double d = 7.0;
+char c = 'a';
+unsigned char uc = 'a';
+short s = 1;
+unsigned short us = 1;
+int i = 5;
+unsigned int ui;
+long l = 13;
+unsigned long ul = 13;
+long long ll = 34;
+unsigned long long ull = 34;
+bool b = true;
+
+rs_element element;
+rs_type type;
+rs_allocation allocation;
+rs_sampler sampler;
+rs_script script;
+rs_mesh mesh;
+rs_path path;
+rs_program_fragment program_fragment;
+rs_program_vertex program_vertex;
+rs_program_raster program_raster;
+rs_program_store program_store;
+rs_font font;
+
+
+
diff --git a/tests/P_export_types/stderr.txt.expect b/tests/P_export_types/stderr.txt.expect
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/P_export_types/stderr.txt.expect
diff --git a/tests/P_export_types/stdout.txt.expect b/tests/P_export_types/stdout.txt.expect
new file mode 100644
index 0000000..b48d491
--- /dev/null
+++ b/tests/P_export_types/stdout.txt.expect
@@ -0,0 +1 @@
+Generating ScriptC_export_types.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: