Merge "Fix code-generation on x86 targets"
diff --git a/bcinfo/MetadataExtractor.cpp b/bcinfo/MetadataExtractor.cpp
index add1ab1..f190c48 100644
--- a/bcinfo/MetadataExtractor.cpp
+++ b/bcinfo/MetadataExtractor.cpp
@@ -64,6 +64,13 @@
return c;
}
+const char *createStringFromOptionalValue(llvm::MDNode *n, unsigned opndNum) {
+ llvm::Metadata *opnd;
+ if (opndNum >= n->getNumOperands() || !(opnd = n->getOperand(opndNum)))
+ return nullptr;
+ return createStringFromValue(opnd);
+}
+
// Collect metadata from NamedMDNodes that contain a list of names
// (strings).
//
@@ -146,10 +153,14 @@
// (should be synced with slang_rs_metadata.h)
static const llvm::StringRef ExportForEachMetadataName = "#rs_export_foreach";
-// Name of metadata node where exported reduce name information resides
+// Name of metadata node where exported simple reduce name information resides
// (should be synced with slang_rs_metadata.h)
static const llvm::StringRef ExportReduceMetadataName = "#rs_export_reduce";
+// Name of metadata node where exported general reduce information resides
+// (should be synced with slang_rs_metadata.h)
+static const llvm::StringRef ExportReduceNewMetadataName = "#rs_export_reduce_new";
+
// Name of metadata node where RS object slot info resides (should be
// synced with slang_rs_metadata.h)
static const llvm::StringRef ObjectSlotMetadataName = "#rs_object_slots";
@@ -163,10 +174,11 @@
MetadataExtractor::MetadataExtractor(const char *bitcode, size_t bitcodeSize)
: mModule(nullptr), mBitcode(bitcode), mBitcodeSize(bitcodeSize),
mExportVarCount(0), mExportFuncCount(0), mExportForEachSignatureCount(0),
- mExportReduceCount(0), mExportVarNameList(nullptr),
+ mExportReduceCount(0), mExportReduceNewCount(0), mExportVarNameList(nullptr),
mExportFuncNameList(nullptr), mExportForEachNameList(nullptr),
mExportForEachSignatureList(nullptr),
mExportForEachInputCountList(nullptr), mExportReduceNameList(nullptr),
+ mExportReduceNewList(nullptr),
mPragmaCount(0), mPragmaKeyList(nullptr), mPragmaValueList(nullptr),
mObjectSlotCount(0), mObjectSlotList(nullptr),
mRSFloatPrecision(RS_FP_Full), mIsThreadable(true),
@@ -180,10 +192,11 @@
MetadataExtractor::MetadataExtractor(const llvm::Module *module)
: mModule(module), mBitcode(nullptr), mBitcodeSize(0),
mExportVarCount(0), mExportFuncCount(0), mExportForEachSignatureCount(0),
- mExportReduceCount(0), mExportVarNameList(nullptr),
+ mExportReduceCount(0), mExportReduceNewCount(0), mExportVarNameList(nullptr),
mExportFuncNameList(nullptr), mExportForEachNameList(nullptr),
mExportForEachSignatureList(nullptr),
mExportForEachInputCountList(nullptr), mExportReduceNameList(nullptr),
+ mExportReduceNewList(nullptr),
mPragmaCount(0), mPragmaKeyList(nullptr), mPragmaValueList(nullptr),
mObjectSlotCount(0), mObjectSlotList(nullptr),
mRSFloatPrecision(RS_FP_Full), mIsThreadable(true),
@@ -224,6 +237,9 @@
delete [] mExportForEachSignatureList;
mExportForEachSignatureList = nullptr;
+ delete [] mExportForEachInputCountList;
+ mExportForEachInputCountList = nullptr;
+
if (mExportReduceNameList) {
for (size_t i = 0; i < mExportReduceCount; i++) {
delete [] mExportReduceNameList[i];
@@ -233,6 +249,9 @@
delete [] mExportReduceNameList;
mExportReduceNameList = nullptr;
+ delete [] mExportReduceNewList;
+ mExportReduceNewList = nullptr;
+
for (size_t i = 0; i < mPragmaCount; i++) {
if (mPragmaKeyList) {
delete [] mPragmaKeyList[i];
@@ -468,6 +487,61 @@
}
+bool MetadataExtractor::populateReduceNewMetadata(const llvm::NamedMDNode *ReduceNewMetadata) {
+ mExportReduceNewCount = 0;
+ mExportReduceNewList = nullptr;
+
+ if (!ReduceNewMetadata || !(mExportReduceNewCount = ReduceNewMetadata->getNumOperands()))
+ return true;
+
+ ReduceNew *TmpReduceNewList = new ReduceNew[mExportReduceNewCount];
+
+ for (size_t i = 0; i < mExportReduceNewCount; i++) {
+ llvm::MDNode *Node = ReduceNewMetadata->getOperand(i);
+ if (!Node || Node->getNumOperands() < 3) {
+ ALOGE("Missing reduce metadata");
+ return false;
+ }
+
+ TmpReduceNewList[i].mReduceName = createStringFromValue(Node->getOperand(0));
+
+ if (!extractUIntFromMetadataString(&TmpReduceNewList[i].mAccumulatorDataSize,
+ Node->getOperand(1))) {
+ ALOGE("Non-integer accumulator data size value in reduce metadata");
+ return false;
+ }
+
+ llvm::MDNode *AccumulatorNode = llvm::dyn_cast<llvm::MDNode>(Node->getOperand(2));
+ if (!AccumulatorNode || AccumulatorNode->getNumOperands() != 2) {
+ ALOGE("Malformed accumulator node in reduce metadata");
+ return false;
+ }
+ TmpReduceNewList[i].mAccumulatorName = createStringFromValue(AccumulatorNode->getOperand(0));
+ if (!extractUIntFromMetadataString(&TmpReduceNewList[i].mSignature,
+ AccumulatorNode->getOperand(1))) {
+ ALOGE("Non-integer signature value in reduce metadata");
+ return false;
+ }
+ llvm::Function *Func =
+ mModule->getFunction(llvm::StringRef(TmpReduceNewList[i].mAccumulatorName));
+ if (!Func) {
+ ALOGE("reduce metadata names missing accumulator function");
+ return false;
+ }
+ // Why calculateNumInputs() - 1? The "-1" is because we don't
+ // want to treat the accumulator argument as an input.
+ TmpReduceNewList[i].mInputCount = calculateNumInputs(Func, TmpReduceNewList[i].mSignature) - 1;
+
+ TmpReduceNewList[i].mInitializerName = createStringFromOptionalValue(Node, 3);
+ TmpReduceNewList[i].mCombinerName = createStringFromOptionalValue(Node, 4);
+ TmpReduceNewList[i].mOutConverterName = createStringFromOptionalValue(Node, 5);
+ TmpReduceNewList[i].mHalterName = createStringFromOptionalValue(Node, 6);
+ }
+
+ mExportReduceNewList = TmpReduceNewList;
+ return true;
+}
+
void MetadataExtractor::readThreadableFlag(
const llvm::NamedMDNode *ThreadableMetadata) {
@@ -544,6 +618,8 @@
mModule->getNamedMetadata(ExportForEachMetadataName);
const llvm::NamedMDNode *ExportReduceMetadata =
mModule->getNamedMetadata(ExportReduceMetadataName);
+ const llvm::NamedMDNode *ExportReduceNewMetadata =
+ mModule->getNamedMetadata(ExportReduceNewMetadataName);
const llvm::NamedMDNode *PragmaMetadata =
mModule->getNamedMetadata(PragmaMetadataName);
const llvm::NamedMDNode *ObjectSlotMetadata =
@@ -577,6 +653,11 @@
return false;
}
+ if (!populateReduceNewMetadata(ExportReduceNewMetadata)) {
+ ALOGE("Could not populate export general reduction metadata");
+ return false;
+ }
+
populatePragmaMetadata(PragmaMetadata);
if (!populateObjectSlotMetadata(ObjectSlotMetadata)) {
diff --git a/bcinfo/tools/main.cpp b/bcinfo/tools/main.cpp
index c4e40f4..855199d 100644
--- a/bcinfo/tools/main.cpp
+++ b/bcinfo/tools/main.cpp
@@ -110,6 +110,11 @@
}
+static void dumpReduceNewInfo(FILE *info, const char *Kind, const char *Name) {
+ if (Name)
+ fprintf(info, " %s(%s)\n", Kind, Name);
+}
+
static int dumpInfo(bcinfo::MetadataExtractor *ME) {
if (!ME) {
return 1;
@@ -149,6 +154,20 @@
fprintf(info, "%s\n", reduceNameList[i]);
}
+ fprintf(info, "exportReduceNewCount: %zu\n", ME->getExportReduceNewCount());
+ const bcinfo::MetadataExtractor::ReduceNew *reduceNewList =
+ ME->getExportReduceNewList();
+ for (size_t i = 0; i < ME->getExportReduceNewCount(); i++) {
+ const bcinfo::MetadataExtractor::ReduceNew &reduceNew = reduceNewList[i];
+ fprintf(info, "%u - %s - %u - %u\n", reduceNew.mSignature, reduceNew.mReduceName,
+ reduceNew.mInputCount, reduceNew.mAccumulatorDataSize);
+ dumpReduceNewInfo(info, "initializer", reduceNew.mInitializerName);
+ dumpReduceNewInfo(info, "accumulator", reduceNew.mAccumulatorName);
+ dumpReduceNewInfo(info, "combiner", reduceNew.mCombinerName);
+ dumpReduceNewInfo(info, "outconverter", reduceNew.mOutConverterName);
+ dumpReduceNewInfo(info, "halter", reduceNew.mHalterName);
+ }
+
fprintf(info, "objectSlotCount: %zu\n", ME->getObjectSlotCount());
const uint32_t *slotList = ME->getObjectSlotList();
for (size_t i = 0; i < ME->getObjectSlotCount(); i++) {
@@ -210,6 +229,20 @@
}
printf("\n");
+ printf("exportReduceNewCount: %zu\n", ME->getExportReduceNewCount());
+ const bcinfo::MetadataExtractor::ReduceNew *reduceNewList = ME->getExportReduceNewList();
+ for (size_t i = 0; i < ME->getExportReduceNewCount(); i++) {
+ const bcinfo::MetadataExtractor::ReduceNew &reduceNew = reduceNewList[i];
+ printf("exportReduceNewList[%zu]: %s - 0x%08x - %u - %u\n", i, reduceNew.mReduceName,
+ reduceNew.mSignature, reduceNew.mInputCount, reduceNew.mAccumulatorDataSize);
+ dumpReduceNewInfo(stdout, "initializer", reduceNew.mInitializerName);
+ dumpReduceNewInfo(stdout, "accumulator", reduceNew.mAccumulatorName);
+ dumpReduceNewInfo(stdout, "combiner", reduceNew.mCombinerName);
+ dumpReduceNewInfo(stdout, "outconverter", reduceNew.mOutConverterName);
+ dumpReduceNewInfo(stdout, "halter", reduceNew.mHalterName);
+ }
+ printf("\n");
+
printf("pragmaCount: %zu\n", ME->getPragmaCount());
const char **keyList = ME->getPragmaKeyList();
const char **valueList = ME->getPragmaValueList();
diff --git a/include/bcinfo/MetadataExtractor.h b/include/bcinfo/MetadataExtractor.h
index 742346a..738c1c2 100644
--- a/include/bcinfo/MetadataExtractor.h
+++ b/include/bcinfo/MetadataExtractor.h
@@ -46,6 +46,40 @@
};
class MetadataExtractor {
+ public:
+ struct ReduceNew {
+ // These strings are owned by the ReduceNew instance, and deleted upon its destruction.
+ // They are assumed to have been allocated by "new []" and hence are deleted by "delete []".
+ const char *mReduceName;
+ const char *mInitializerName;
+ const char *mAccumulatorName;
+ const char *mCombinerName;
+ const char *mOutConverterName;
+ const char *mHalterName;
+
+ uint32_t mSignature; // of accumulator function
+ uint32_t mInputCount; // of accumulator function (and of kernel itself)
+ uint32_t mAccumulatorDataSize; // in bytes
+
+ ReduceNew() :
+ mReduceName(nullptr),
+ mInitializerName(nullptr), mAccumulatorName(nullptr), mCombinerName(nullptr),
+ mOutConverterName(nullptr), mHalterName(nullptr),
+ mSignature(0), mInputCount(0), mAccumulatorDataSize(0) {
+ }
+ ~ReduceNew() {
+ delete [] mReduceName;
+ delete [] mInitializerName;
+ delete [] mAccumulatorName;
+ delete [] mCombinerName;
+ delete [] mOutConverterName;
+ delete [] mHalterName;
+ }
+
+ ReduceNew(const ReduceNew &) = delete;
+ void operator=(const ReduceNew &) = delete;
+ };
+
private:
const llvm::Module *mModule;
const char *mBitcode;
@@ -55,12 +89,14 @@
size_t mExportFuncCount;
size_t mExportForEachSignatureCount;
size_t mExportReduceCount;
+ size_t mExportReduceNewCount;
const char **mExportVarNameList;
const char **mExportFuncNameList;
const char **mExportForEachNameList;
const uint32_t *mExportForEachSignatureList;
const uint32_t *mExportForEachInputCountList;
const char **mExportReduceNameList;
+ const ReduceNew *mExportReduceNewList;
size_t mPragmaCount;
const char **mPragmaKeyList;
@@ -83,6 +119,7 @@
// Helper functions for extraction
bool populateForEachMetadata(const llvm::NamedMDNode *Names,
const llvm::NamedMDNode *Signatures);
+ bool populateReduceNewMetadata(const llvm::NamedMDNode *ReduceNewMetadata);
bool populateObjectSlotMetadata(const llvm::NamedMDNode *ObjectSlotMetadata);
void populatePragmaMetadata(const llvm::NamedMDNode *PragmaMetadata);
void readThreadableFlag(const llvm::NamedMDNode *ThreadableMetadata);
@@ -183,20 +220,34 @@
}
/**
- * \return number of exported reduce kernels (slots) in this script/module.
+ * \return number of exported simple reduce kernels (slots) in this script/module.
*/
size_t getExportReduceCount() const {
return mExportReduceCount;
}
/**
- * \return array of exported reduce kernel names.
+ * \return array of exported simple reduce kernel names.
*/
const char **getExportReduceNameList() const {
return mExportReduceNameList;
}
/**
+ * \return number of exported general reduce kernels (slots) in this script/module.
+ */
+ size_t getExportReduceNewCount() const {
+ return mExportReduceNewCount;
+ }
+
+ /**
+ * \return array of exported general reduce kernel descriptions.
+ */
+ const ReduceNew *getExportReduceNewList() const {
+ return mExportReduceNewList;
+ }
+
+ /**
* \return number of pragmas contained in pragmaKeyList and pragmaValueList.
*/
size_t getPragmaCount() const {
diff --git a/lib/Core/Compiler.cpp b/lib/Core/Compiler.cpp
index 5c769b4..71c0ed2 100644
--- a/lib/Core/Compiler.cpp
+++ b/lib/Core/Compiler.cpp
@@ -330,10 +330,12 @@
size_t exportFuncCount = me.getExportFuncCount();
size_t exportForEachCount = me.getExportForEachSignatureCount();
size_t exportReduceCount = me.getExportReduceCount();
+ size_t exportReduceNewCount = me.getExportReduceNewCount();
const char **exportVarNameList = me.getExportVarNameList();
const char **exportFuncNameList = me.getExportFuncNameList();
const char **exportForEachNameList = me.getExportForEachNameList();
const char **exportReduceNameList = me.getExportReduceNameList();
+ const bcinfo::MetadataExtractor::ReduceNew *exportReduceNewList = me.getExportReduceNewList();
size_t i;
for (i = 0; i < exportVarCount; ++i) {
@@ -349,7 +351,7 @@
// functions around until createInternalizePass() is finished making
// its own copy of the visible symbols.
std::vector<std::string> expanded_funcs;
- expanded_funcs.reserve(exportForEachCount + exportReduceCount);
+ expanded_funcs.reserve(exportForEachCount + exportReduceCount + exportReduceNewCount);
for (i = 0; i < exportForEachCount; ++i) {
expanded_funcs.push_back(std::string(exportForEachNameList[i]) + ".expand");
@@ -357,6 +359,9 @@
for (i = 0; i < exportReduceCount; ++i) {
expanded_funcs.push_back(std::string(exportReduceNameList[i]) + ".expand");
}
+ for (i = 0; i < exportReduceNewCount; ++i) {
+ expanded_funcs.push_back(std::string(exportReduceNewList[i].mAccumulatorName) + ".expand");
+ }
for (auto &symbol_name : expanded_funcs) {
export_symbols.push_back(symbol_name.c_str());
diff --git a/lib/Renderscript/RSEmbedInfo.cpp b/lib/Renderscript/RSEmbedInfo.cpp
index b0c2767..54e0acb 100644
--- a/lib/Renderscript/RSEmbedInfo.cpp
+++ b/lib/Renderscript/RSEmbedInfo.cpp
@@ -74,6 +74,7 @@
size_t exportFuncCount = me.getExportFuncCount();
size_t exportForEachCount = me.getExportForEachSignatureCount();
size_t exportReduceCount = me.getExportReduceCount();
+ size_t exportReduceNewCount = me.getExportReduceNewCount();
size_t objectSlotCount = me.getObjectSlotCount();
size_t pragmaCount = me.getPragmaCount();
const char **exportVarNameList = me.getExportVarNameList();
@@ -82,6 +83,8 @@
const char **exportReduceNameList = me.getExportReduceNameList();
const uint32_t *exportForEachSignatureList =
me.getExportForEachSignatureList();
+ const bcinfo::MetadataExtractor::ReduceNew *exportReduceNewList =
+ me.getExportReduceNewList();
const uint32_t *objectSlotList = me.getObjectSlotList();
const char **pragmaKeyList = me.getPragmaKeyList();
const char **pragmaValueList = me.getPragmaValueList();
@@ -90,13 +93,22 @@
size_t i;
- // We use a simple text format here that the compatibility library can
- // easily parse. Each section starts out with its name followed by a count.
- // The count denotes the number of lines to parse for that particular
- // category. Variables and Functions merely put the appropriate identifier
- // on the line, while ForEach kernels have the encoded int signature,
- // followed by a hyphen followed by the identifier (function to look up).
- // Object Slots are just listed as one integer per line.
+ // We use a simple text format here that the compatibility library
+ // can easily parse. Each section starts out with its name
+ // followed by a count. The count denotes the number of lines to
+ // parse for that particular category. Variables and Functions and
+ // simple reduce kernels merely put the appropriate identifier on
+ // the line. ForEach kernels have the encoded int signature,
+ // followed by a hyphen followed by the identifier (function to
+ // look up). General reduce kernels have the encoded int
+ // signature, followed by a hyphen followed by the accumulator
+ // data size, followed by a hyphen followed by the identifier
+ // (reduction name); and then for each possible constituent
+ // function, a hyphen followed by the identifier (function name)
+ // -- in the case where the function is omitted, "." is used in
+ // place of the identifier. Object Slots are just listed as one
+ // integer per line.
+
s << "exportVarCount: " << exportVarCount << "\n";
for (i = 0; i < exportVarCount; ++i) {
s << exportVarNameList[i] << "\n";
@@ -118,6 +130,21 @@
s << exportReduceNameList[i] << "\n";
}
+ s << "exportReduceNewCount: " << exportReduceNewCount << "\n";
+ auto reduceNewFnName = [](const char *Name) { return Name ? Name : "."; };
+ for (i = 0; i < exportReduceNewCount; ++i) {
+ const bcinfo::MetadataExtractor::ReduceNew &reduceNew = exportReduceNewList[i];
+ s << reduceNew.mSignature << " - "
+ << reduceNew.mAccumulatorDataSize << " - "
+ << reduceNew.mReduceName << " - "
+ << reduceNewFnName(reduceNew.mInitializerName) << " - "
+ << reduceNewFnName(reduceNew.mAccumulatorName) << " - "
+ << reduceNewFnName(reduceNew.mCombinerName) << " - "
+ << reduceNewFnName(reduceNew.mOutConverterName) << " - "
+ << reduceNewFnName(reduceNew.mHalterName)
+ << "\n";
+ }
+
s << "objectSlotCount: " << objectSlotCount << "\n";
for (i = 0; i < objectSlotCount; ++i) {
s << objectSlotList[i] << "\n";
diff --git a/lib/Renderscript/RSGlobalInfoPass.cpp b/lib/Renderscript/RSGlobalInfoPass.cpp
index 0600692..68d082a 100644
--- a/lib/Renderscript/RSGlobalInfoPass.cpp
+++ b/lib/Renderscript/RSGlobalInfoPass.cpp
@@ -138,6 +138,11 @@
continue;
}
+ // Skip intrinsic variables.
+ if (GV.getName().startswith("llvm.")) {
+ continue;
+ }
+
// In LLVM, an instance of GlobalVariable is actually a Value
// corresponding to the address of it.
GVAddresses.push_back(llvm::ConstantExpr::getBitCast(&GV, VoidPtrTy));
diff --git a/lib/Renderscript/RSKernelExpand.cpp b/lib/Renderscript/RSKernelExpand.cpp
index 34611d7..d06cb5b 100644
--- a/lib/Renderscript/RSKernelExpand.cpp
+++ b/lib/Renderscript/RSKernelExpand.cpp
@@ -19,6 +19,7 @@
#include <cstdlib>
#include <functional>
+#include <unordered_set>
#include <llvm/IR/DerivedTypes.h>
#include <llvm/IR/Function.h>
@@ -42,6 +43,7 @@
// Only used in bccAssert()
const int kNumExpandedForeachParams = 4;
const int kNumExpandedReduceParams = 3;
+const int kNumExpandedReduceNewAccumulatorParams = 4;
#endif
const char kRenderScriptTBAARootName[] = "RenderScript Distinct TBAA";
@@ -70,6 +72,8 @@
private:
static const size_t RS_KERNEL_INPUT_LIMIT = 8; // see frameworks/base/libs/rs/cpu_ref/rsCpuCoreRuntime.h
+ typedef std::unordered_set<llvm::Function *> FunctionSet;
+
enum RsLaunchDimensionsField {
RsLaunchDimensionsFieldX,
RsLaunchDimensionsFieldY,
@@ -105,6 +109,7 @@
* the pass is run on.
*/
llvm::FunctionType *ExpandedForEachType, *ExpandedReduceType;
+ llvm::Type *RsExpandKernelDriverInfoPfxTy;
uint32_t mExportForEachCount;
const char **mExportForEachNameList;
@@ -294,7 +299,7 @@
RsExpandKernelDriverInfoPfxTypes.push_back(RsLaunchDimensionsTy); // RsLaunchDimensions current
RsExpandKernelDriverInfoPfxTypes.push_back(VoidPtrTy); // const void *usr
RsExpandKernelDriverInfoPfxTypes.push_back(Int32Ty); // uint32_t usrLen
- llvm::StructType *RsExpandKernelDriverInfoPfxTy =
+ RsExpandKernelDriverInfoPfxTy =
llvm::StructType::create(RsExpandKernelDriverInfoPfxTypes, "RsExpandKernelDriverInfoPfx");
// Create the function type for expanded kernels.
@@ -369,6 +374,55 @@
return ExpandedFunction;
}
+ // Create skeleton of a general reduce kernel's expanded accumulator.
+ //
+ // This creates a function with the following signature:
+ //
+ // void @func.expand(%RsExpandKernelDriverInfoPfx* nocapture %p,
+ // i32 %x1, i32 %x2, accumType* nocapture %accum)
+ //
+ llvm::Function *createEmptyExpandedReduceNewAccumulator(llvm::StringRef OldName,
+ llvm::Type *AccumArgTy) {
+ llvm::Type *Int32Ty = llvm::Type::getInt32Ty(*Context);
+ llvm::Type *VoidTy = llvm::Type::getVoidTy(*Context);
+ llvm::FunctionType *ExpandedReduceNewAccumulatorType =
+ llvm::FunctionType::get(VoidTy,
+ {RsExpandKernelDriverInfoPfxTy->getPointerTo(),
+ Int32Ty, Int32Ty, AccumArgTy}, false);
+ llvm::Function *FnExpandedAccumulator =
+ llvm::Function::Create(ExpandedReduceNewAccumulatorType,
+ llvm::GlobalValue::ExternalLinkage,
+ OldName + ".expand", Module);
+ bccAssert(FnExpandedAccumulator->arg_size() == kNumExpandedReduceNewAccumulatorParams);
+
+ llvm::Function::arg_iterator AI = FnExpandedAccumulator->arg_begin();
+
+ using llvm::Attribute;
+
+ llvm::Argument *Arg_p = &(*AI++);
+ Arg_p->setName("p");
+ Arg_p->addAttr(llvm::AttributeSet::get(*Context, Arg_p->getArgNo() + 1,
+ llvm::makeArrayRef(Attribute::NoCapture)));
+
+ llvm::Argument *Arg_x1 = &(*AI++);
+ Arg_x1->setName("x1");
+
+ llvm::Argument *Arg_x2 = &(*AI++);
+ Arg_x2->setName("x2");
+
+ llvm::Argument *Arg_accum = &(*AI++);
+ Arg_accum->setName("accum");
+ Arg_accum->addAttr(llvm::AttributeSet::get(*Context, Arg_accum->getArgNo() + 1,
+ llvm::makeArrayRef(Attribute::NoCapture)));
+
+ llvm::BasicBlock *Begin = llvm::BasicBlock::Create(*Context, "Begin",
+ FnExpandedAccumulator);
+ llvm::IRBuilder<> Builder(Begin);
+ Builder.CreateRetVoid();
+
+ return FnExpandedAccumulator;
+ }
+
/// @brief Create an empty loop
///
/// Create a loop of the form:
@@ -504,12 +558,12 @@
}
// Build contribution to outgoing argument list for calling a
- // ForEach-able function, based on the special parameters of that
- // function.
+ // ForEach-able function or a general reduction accumulator
+ // function, based on the special parameters of that function.
//
- // Signature - metadata bits for the signature of the ForEach-able function
+ // Signature - metadata bits for the signature of the callee
// X, Arg_p - values derived directly from expanded function,
- // suitable for computing arguments for the ForEach-able function
+ // suitable for computing arguments for the callee
// CalleeArgs - contribution is accumulated here
// Bump - invoked once for each contributed outgoing argument
// LoopHeaderInsertionPoint - an Instruction in the loop header, before which
@@ -571,6 +625,126 @@
return Return;
}
+ // Generate loop-invariant input processing setup code for an expanded
+ // ForEach-able function or an expanded general reduction accumulator
+ // function.
+ //
+ // LoopHeader - block at the end of which the setup code will be inserted
+ // Arg_p - RSKernelDriverInfo pointer passed to the expanded function
+ // TBAAPointer - metadata for marking loads of pointer values out of RSKernelDriverInfo
+ // ArgIter - iterator pointing to first input of the UNexpanded function
+ // NumInputs - number of inputs (NOT number of ARGUMENTS)
+ //
+ // InBufPtrs[] - this function sets each array element to point to the first
+ // cell of the corresponding input allocation
+ // InStructTempSlots[] - this function sets each array element either to nullptr
+ // or to the result of an alloca (for the case where the
+ // calling convention dictates that a value must be passed
+ // by reference, and so we need a stacked temporary to hold
+ // a copy of that value)
+ void ExpandInputsLoopInvariant(llvm::IRBuilder<> &Builder, llvm::BasicBlock *LoopHeader,
+ llvm::Value *Arg_p,
+ llvm::MDNode *TBAAPointer,
+ llvm::Function::arg_iterator ArgIter,
+ const size_t NumInputs,
+ llvm::SmallVectorImpl<llvm::Value *> &InBufPtrs,
+ llvm::SmallVectorImpl<llvm::Value *> &InStructTempSlots) {
+ bccAssert(NumInputs <= RS_KERNEL_INPUT_LIMIT);
+
+ // Extract information about input slots. The work done
+ // here is loop-invariant, so we can hoist the operations out of the loop.
+ auto OldInsertionPoint = Builder.saveIP();
+ Builder.SetInsertPoint(LoopHeader->getTerminator());
+
+ for (size_t InputIndex = 0; InputIndex < NumInputs; ++InputIndex, ArgIter++) {
+ llvm::Type *InType = ArgIter->getType();
+
+ /*
+ * AArch64 calling conventions dictate that structs of sufficient size
+ * get passed by pointer instead of passed by value. This, combined
+ * with the fact that we don't allow kernels to operate on pointer
+ * data means that if we see a kernel with a pointer parameter we know
+ * that it is a struct input that has been promoted. As such we don't
+ * need to convert its type to a pointer. Later we will need to know
+ * to create a temporary copy on the stack, so we save this information
+ * in InStructTempSlots.
+ */
+ if (auto PtrType = llvm::dyn_cast<llvm::PointerType>(InType)) {
+ llvm::Type *ElementType = PtrType->getElementType();
+ InStructTempSlots.push_back(Builder.CreateAlloca(ElementType, nullptr,
+ "input_struct_slot"));
+ } else {
+ InType = InType->getPointerTo();
+ InStructTempSlots.push_back(nullptr);
+ }
+
+ SmallGEPIndices InBufPtrGEP(GEPHelper({0, RsExpandKernelDriverInfoPfxFieldInPtr,
+ static_cast<int32_t>(InputIndex)}));
+ llvm::Value *InBufPtrAddr = Builder.CreateInBoundsGEP(Arg_p, InBufPtrGEP, "input_buf.gep");
+ llvm::LoadInst *InBufPtr = Builder.CreateLoad(InBufPtrAddr, "input_buf");
+ llvm::Value *CastInBufPtr = Builder.CreatePointerCast(InBufPtr, InType, "casted_in");
+
+ if (gEnableRsTbaa) {
+ InBufPtr->setMetadata("tbaa", TBAAPointer);
+ }
+
+ InBufPtrs.push_back(CastInBufPtr);
+ }
+
+ Builder.restoreIP(OldInsertionPoint);
+ }
+
+ // Generate loop-varying input processing code for an expanded ForEach-able function
+ // or an expanded general reduction accumulator function. Also, for the call to the
+ // UNexpanded function, collect the portion of the argument list corresponding to the
+ // inputs.
+ //
+ // Arg_x1 - first X coordinate to be processed by the expanded function
+ // TBAAAllocation - metadata for marking loads of input values out of allocations
+ // NumInputs -- number of inputs (NOT number of ARGUMENTS)
+ // InBufPtrs[] - this function consumes the information produced by ExpandInputsLoopInvariant()
+ // InStructTempSlots[] - this function consumes the information produced by ExpandInputsLoopInvariant()
+ // IndVar - value of loop induction variable (X coordinate) for a given loop iteration
+ //
+ // RootArgs - this function sets this to the list of outgoing argument values corresponding
+ // to the inputs
+ void ExpandInputsBody(llvm::IRBuilder<> &Builder,
+ llvm::Value *Arg_x1,
+ llvm::MDNode *TBAAAllocation,
+ const size_t NumInputs,
+ const llvm::SmallVectorImpl<llvm::Value *> &InBufPtrs,
+ const llvm::SmallVectorImpl<llvm::Value *> &InStructTempSlots,
+ llvm::Value *IndVar,
+ llvm::SmallVectorImpl<llvm::Value *> &RootArgs) {
+ llvm::Value *Offset = Builder.CreateSub(IndVar, Arg_x1);
+
+ for (size_t Index = 0; Index < NumInputs; ++Index) {
+ llvm::Value *InPtr = Builder.CreateInBoundsGEP(InBufPtrs[Index], Offset);
+ llvm::Value *Input;
+
+ llvm::LoadInst *InputLoad = Builder.CreateLoad(InPtr, "input");
+
+ if (gEnableRsTbaa) {
+ InputLoad->setMetadata("tbaa", TBAAAllocation);
+ }
+
+ if (llvm::Value *TemporarySlot = InStructTempSlots[Index]) {
+ // Pass a pointer to a temporary on the stack, rather than
+ // passing a pointer to the original value. We do not want
+ // the kernel to potentially modify the input data.
+
+ // Note: don't annotate with TBAA, since the kernel might
+ // have its own TBAA annotations for the pointer argument.
+ Builder.CreateStore(InputLoad, TemporarySlot);
+ Input = TemporarySlot;
+ } else {
+ Input = InputLoad;
+ }
+
+ RootArgs.push_back(Input);
+ }
+ }
+
/* Performs the actual optimization on a selected function. On success, the
* Module will contain a new function of the name "<NAME>.expand" that
* invokes <NAME>() in a loop with the appropriate parameters.
@@ -595,7 +769,7 @@
/*
* Extract the expanded function's parameters. It is guaranteed by
- * createEmptyExpandedFunction that there will be four parameters.
+ * createEmptyExpandedForEachKernel that there will be four parameters.
*/
bccAssert(ExpandedFunction->arg_size() == kNumExpandedForeachParams);
@@ -725,7 +899,7 @@
/*
* Extract the expanded function's parameters. It is guaranteed by
- * createEmptyExpandedFunction that there will be four parameters.
+ * createEmptyExpandedForEachKernel that there will be four parameters.
*/
bccAssert(ExpandedFunction->arg_size() == kNumExpandedForeachParams);
@@ -802,7 +976,6 @@
CastedOutBasePtr = Builder.CreatePointerCast(OutBasePtr, OutTy, "casted_out");
}
- llvm::SmallVector<llvm::Type*, 8> InTypes;
llvm::SmallVector<llvm::Value*, 8> InBufPtrs;
llvm::SmallVector<llvm::Value*, 8> InStructTempSlots;
@@ -826,47 +999,8 @@
const size_t NumInPtrArguments = NumRemainingInputs;
if (NumInPtrArguments > 0) {
- // Extract information about input slots and step sizes. The work done
- // here is loop-invariant, so we can hoist the operations out of the loop.
- auto OldInsertionPoint = Builder.saveIP();
- Builder.SetInsertPoint(LoopHeader->getTerminator());
-
- for (size_t InputIndex = 0; InputIndex < NumInPtrArguments; ++InputIndex, ArgIter++) {
- llvm::Type *InType = ArgIter->getType();
-
- /*
- * AArch64 calling conventions dictate that structs of sufficient size
- * get passed by pointer instead of passed by value. This, combined
- * with the fact that we don't allow kernels to operate on pointer
- * data means that if we see a kernel with a pointer parameter we know
- * that it is a struct input that has been promoted. As such we don't
- * need to convert its type to a pointer. Later we will need to know
- * to create a temporary copy on the stack, so we save this information
- * in InStructTempSlots.
- */
- if (auto PtrType = llvm::dyn_cast<llvm::PointerType>(InType)) {
- llvm::Type *ElementType = PtrType->getElementType();
- InStructTempSlots.push_back(Builder.CreateAlloca(ElementType, nullptr,
- "input_struct_slot"));
- } else {
- InType = InType->getPointerTo();
- InStructTempSlots.push_back(nullptr);
- }
-
- SmallGEPIndices InBufPtrGEP(GEPHelper({0, RsExpandKernelDriverInfoPfxFieldInPtr,
- static_cast<int32_t>(InputIndex)}));
- llvm::Value *InBufPtrAddr = Builder.CreateInBoundsGEP(Arg_p, InBufPtrGEP, "input_buf.gep");
- llvm::LoadInst *InBufPtr = Builder.CreateLoad(InBufPtrAddr, "input_buf");
- llvm::Value *CastInBufPtr = Builder.CreatePointerCast(InBufPtr, InType, "casted_in");
- if (gEnableRsTbaa) {
- InBufPtr->setMetadata("tbaa", TBAAPointer);
- }
-
- InTypes.push_back(InType);
- InBufPtrs.push_back(CastInBufPtr);
- }
-
- Builder.restoreIP(OldInsertionPoint);
+ ExpandInputsLoopInvariant(Builder, LoopHeader, Arg_p, TBAAPointer, ArgIter, NumInPtrArguments,
+ InBufPtrs, InStructTempSlots);
}
// Populate the actual call to kernel().
@@ -889,33 +1023,8 @@
// Inputs
if (NumInPtrArguments > 0) {
- llvm::Value *Offset = Builder.CreateSub(IV, Arg_x1);
-
- for (size_t Index = 0; Index < NumInPtrArguments; ++Index) {
- llvm::Value *InPtr = Builder.CreateInBoundsGEP(InBufPtrs[Index], Offset);
- llvm::Value *Input;
-
- llvm::LoadInst *InputLoad = Builder.CreateLoad(InPtr, "input");
-
- if (gEnableRsTbaa) {
- InputLoad->setMetadata("tbaa", TBAAAllocation);
- }
-
- if (llvm::Value *TemporarySlot = InStructTempSlots[Index]) {
- // Pass a pointer to a temporary on the stack, rather than
- // passing a pointer to the original value. We do not want
- // the kernel to potentially modify the input data.
-
- // Note: don't annotate with TBAA, since the kernel might
- // have its own TBAA annotations for the pointer argument.
- Builder.CreateStore(InputLoad, TemporarySlot);
- Input = TemporarySlot;
- } else {
- Input = InputLoad;
- }
-
- RootArgs.push_back(Input);
- }
+ ExpandInputsBody(Builder, Arg_x1, TBAAAllocation, NumInPtrArguments,
+ InBufPtrs, InStructTempSlots, IV, RootArgs);
}
finishArgList(RootArgs, CalleeArgs, CalleeArgsContextIdx, *Function, Builder);
@@ -933,7 +1042,7 @@
return true;
}
- // Expand a reduce-style kernel function.
+ // Expand a simple reduce-style kernel function.
//
// The input is a kernel which represents a binary operation,
// of the form
@@ -999,7 +1108,7 @@
bool ExpandReduce(llvm::Function *Function) {
bccAssert(Function);
- ALOGV("Expanding reduce kernel %s", Function->getName().str().c_str());
+ ALOGV("Expanding simple reduce kernel %s", Function->getName().str().c_str());
llvm::DataLayout DL(Module);
@@ -1020,7 +1129,7 @@
createEmptyExpandedReduceKernel(Function->getName());
// Extract the expanded kernel's parameters. It is guaranteed by
- // createEmptyExpandedFunction that there will be 3 parameters.
+ // createEmptyExpandedReduceKernel that there will be 3 parameters.
auto ExpandedFunctionArgIter = ExpandedFunction->arg_begin();
llvm::Value *Arg_inBuf = &*(ExpandedFunctionArgIter++);
@@ -1196,6 +1305,118 @@
return true;
}
+ // Certain categories of functions that make up a general
+ // reduce-style kernel are called directly from the driver with no
+ // expansion needed. For a function in such a category, we need to
+ // promote linkage from static to external, to ensure that the
+ // function is visible to the driver in the dynamic symbol table.
+ // This promotion is safe because we don't have any kind of cross
+ // translation unit linkage model (except for linking against
+ // RenderScript libraries), so we do not risk name clashes.
+ bool PromoteReduceNewFunction(const char *Name, FunctionSet &PromotedFunctions) {
+ if (!Name) // a presumably-optional function that is not present
+ return false;
+
+ llvm::Function *Fn = Module->getFunction(Name);
+ bccAssert(Fn != nullptr);
+ if (PromotedFunctions.insert(Fn).second) {
+ bccAssert(Fn->getLinkage() == llvm::GlobalValue::InternalLinkage);
+ Fn->setLinkage(llvm::GlobalValue::ExternalLinkage);
+ return true;
+ }
+
+ return false;
+ }
+
+ // Expand the accumulator function for a general reduce-style kernel.
+ //
+ // The input is a function of the form
+ //
+ // define void @func(accumType* %accum, foo1 in1[, ... fooN inN] [, special arguments])
+ //
+ // where all arguments except the first are the same as for a foreach kernel.
+ //
+ // The input accumulator function gets expanded into a function of the form
+ //
+ // define void @func.expand(%RsExpandKernelDriverInfoPfx* %p, i32 %x1, i32 %x2, accumType* %accum)
+ //
+ // which performs a serial accumulaion of elements [x1, x2) into *%accum.
+ //
+ // In pseudocode, @func.expand does:
+ //
+ // for (i = %x1; i < %x2; ++i) {
+ // func(%accum,
+ // *((foo1 *)p->inPtr[0] + i)[, ... *((fooN *)p->inPtr[N-1] + i)
+ // [, p] [, i] [, p->current.y] [, p->current.z]);
+ // }
+ //
+ // This is very similar to foreach kernel expansion with no output.
+ bool ExpandReduceNewAccumulator(llvm::Function *FnAccumulator, uint32_t Signature, size_t NumInputs) {
+ ALOGV("Expanding accumulator %s for general reduce kernel",
+ FnAccumulator->getName().str().c_str());
+
+ // Create TBAA meta-data.
+ llvm::MDNode *TBAARenderScriptDistinct, *TBAARenderScript,
+ *TBAAAllocation, *TBAAPointer;
+ llvm::MDBuilder MDHelper(*Context);
+ TBAARenderScriptDistinct =
+ MDHelper.createTBAARoot(kRenderScriptTBAARootName);
+ TBAARenderScript = MDHelper.createTBAANode(kRenderScriptTBAANodeName,
+ TBAARenderScriptDistinct);
+ TBAAAllocation = MDHelper.createTBAAScalarTypeNode("allocation",
+ TBAARenderScript);
+ TBAAAllocation = MDHelper.createTBAAStructTagNode(TBAAAllocation,
+ TBAAAllocation, 0);
+ TBAAPointer = MDHelper.createTBAAScalarTypeNode("pointer",
+ TBAARenderScript);
+ TBAAPointer = MDHelper.createTBAAStructTagNode(TBAAPointer, TBAAPointer, 0);
+
+ auto AccumulatorArgIter = FnAccumulator->arg_begin();
+
+ // Create empty accumulator function.
+ llvm::Function *FnExpandedAccumulator =
+ createEmptyExpandedReduceNewAccumulator(FnAccumulator->getName(),
+ (AccumulatorArgIter++)->getType());
+
+ // Extract the expanded accumulator's parameters. It is
+ // guaranteed by createEmptyExpandedReduceNewAccumulator that
+ // there will be 4 parameters.
+ bccAssert(FnExpandedAccumulator->arg_size() == kNumExpandedReduceNewAccumulatorParams);
+ auto ExpandedAccumulatorArgIter = FnExpandedAccumulator->arg_begin();
+ llvm::Value *Arg_p = &*(ExpandedAccumulatorArgIter++);
+ llvm::Value *Arg_x1 = &*(ExpandedAccumulatorArgIter++);
+ llvm::Value *Arg_x2 = &*(ExpandedAccumulatorArgIter++);
+ llvm::Value *Arg_accum = &*(ExpandedAccumulatorArgIter++);
+
+ // Construct the actual function body.
+ llvm::IRBuilder<> Builder(FnExpandedAccumulator->getEntryBlock().begin());
+
+ // Create the loop structure.
+ llvm::BasicBlock *LoopHeader = Builder.GetInsertBlock();
+ llvm::PHINode *IndVar;
+ createLoop(Builder, Arg_x1, Arg_x2, &IndVar);
+
+ llvm::SmallVector<llvm::Value*, 8> CalleeArgs;
+ const int CalleeArgsContextIdx =
+ ExpandSpecialArguments(Signature, IndVar, Arg_p, Builder, CalleeArgs,
+ [](){}, LoopHeader->getTerminator());
+
+ llvm::SmallVector<llvm::Value*, 8> InBufPtrs;
+ llvm::SmallVector<llvm::Value*, 8> InStructTempSlots;
+ ExpandInputsLoopInvariant(Builder, LoopHeader, Arg_p, TBAAPointer, AccumulatorArgIter, NumInputs,
+ InBufPtrs, InStructTempSlots);
+
+ // Populate the actual call to the original accumulator.
+ llvm::SmallVector<llvm::Value*, 8> RootArgs;
+ RootArgs.push_back(Arg_accum);
+ ExpandInputsBody(Builder, Arg_x1, TBAAAllocation, NumInputs, InBufPtrs, InStructTempSlots,
+ IndVar, RootArgs);
+ finishArgList(RootArgs, CalleeArgs, CalleeArgsContextIdx, *FnAccumulator, Builder);
+ Builder.CreateCall(FnAccumulator, RootArgs);
+
+ return true;
+ }
+
/// @brief Checks if pointers to allocation internals are exposed
///
/// This function verifies if through the parameters passed to the kernel
@@ -1315,7 +1536,7 @@
}
}
- // Expand reduce_* style kernels.
+ // Expand simple reduce_* style kernels.
mExportReduceCount = me.getExportReduceCount();
mExportReduceNameList = me.getExportReduceNameList();
@@ -1326,6 +1547,25 @@
}
}
+ // Process general reduce_* style functions.
+ const size_t ExportReduceNewCount = me.getExportReduceNewCount();
+ const bcinfo::MetadataExtractor::ReduceNew *ExportReduceNewList = me.getExportReduceNewList();
+ // Note that functions can be shared between kernels
+ FunctionSet PromotedFunctions, ExpandedAccumulators;
+
+ for (size_t i = 0; i < ExportReduceNewCount; ++i) {
+ Changed |= PromoteReduceNewFunction(ExportReduceNewList[i].mInitializerName, PromotedFunctions);
+ Changed |= PromoteReduceNewFunction(ExportReduceNewList[i].mOutConverterName, PromotedFunctions);
+
+ // Accumulator
+ llvm::Function *accumulator = Module.getFunction(ExportReduceNewList[i].mAccumulatorName);
+ bccAssert(accumulator != nullptr);
+ if (ExpandedAccumulators.insert(accumulator).second)
+ Changed |= ExpandReduceNewAccumulator(accumulator,
+ ExportReduceNewList[i].mSignature,
+ ExportReduceNewList[i].mInputCount);
+ }
+
if (gEnableRsTbaa && !allocPointersExposed(Module)) {
connectRenderScriptTBAAMetadata(Module);
}
diff --git a/lib/Renderscript/RSStubsWhiteList.cpp b/lib/Renderscript/RSStubsWhiteList.cpp
index 08976d6..71ec96f 100644
--- a/lib/Renderscript/RSStubsWhiteList.cpp
+++ b/lib/Renderscript/RSStubsWhiteList.cpp
@@ -27,24 +27,44 @@
"_Z10half_rsqrtDv3_f",
"_Z10half_rsqrtDv4_f",
"_Z10half_rsqrtf",
+"_Z10native_cosDh",
+"_Z10native_cosDv2_Dh",
"_Z10native_cosDv2_f",
+"_Z10native_cosDv3_Dh",
"_Z10native_cosDv3_f",
+"_Z10native_cosDv4_Dh",
"_Z10native_cosDv4_f",
"_Z10native_cosf",
+"_Z10native_expDh",
+"_Z10native_expDv2_Dh",
"_Z10native_expDv2_f",
+"_Z10native_expDv3_Dh",
"_Z10native_expDv3_f",
+"_Z10native_expDv4_Dh",
"_Z10native_expDv4_f",
"_Z10native_expf",
+"_Z10native_logDh",
+"_Z10native_logDv2_Dh",
"_Z10native_logDv2_f",
+"_Z10native_logDv3_Dh",
"_Z10native_logDv3_f",
+"_Z10native_logDv4_Dh",
"_Z10native_logDv4_f",
"_Z10native_logf",
+"_Z10native_sinDh",
+"_Z10native_sinDv2_Dh",
"_Z10native_sinDv2_f",
+"_Z10native_sinDv3_Dh",
"_Z10native_sinDv3_f",
+"_Z10native_sinDv4_Dh",
"_Z10native_sinDv4_f",
"_Z10native_sinf",
+"_Z10native_tanDh",
+"_Z10native_tanDv2_Dh",
"_Z10native_tanDv2_f",
+"_Z10native_tanDv3_Dh",
"_Z10native_tanDv3_f",
+"_Z10native_tanDv4_Dh",
"_Z10native_tanDv4_f",
"_Z10native_tanf",
"_Z10rsAtomicOrPVii",
@@ -64,48 +84,92 @@
"_Z11fast_lengthDv3_f",
"_Z11fast_lengthDv4_f",
"_Z11fast_lengthf",
+"_Z11native_acosDh",
+"_Z11native_acosDv2_Dh",
"_Z11native_acosDv2_f",
+"_Z11native_acosDv3_Dh",
"_Z11native_acosDv3_f",
+"_Z11native_acosDv4_Dh",
"_Z11native_acosDv4_f",
"_Z11native_acosf",
+"_Z11native_asinDh",
+"_Z11native_asinDv2_Dh",
"_Z11native_asinDv2_f",
+"_Z11native_asinDv3_Dh",
"_Z11native_asinDv3_f",
+"_Z11native_asinDv4_Dh",
"_Z11native_asinDv4_f",
"_Z11native_asinf",
+"_Z11native_atanDh",
+"_Z11native_atanDv2_Dh",
"_Z11native_atanDv2_f",
+"_Z11native_atanDv3_Dh",
"_Z11native_atanDv3_f",
+"_Z11native_atanDv4_Dh",
"_Z11native_atanDv4_f",
"_Z11native_atanf",
+"_Z11native_cbrtDh",
+"_Z11native_cbrtDv2_Dh",
"_Z11native_cbrtDv2_f",
+"_Z11native_cbrtDv3_Dh",
"_Z11native_cbrtDv3_f",
+"_Z11native_cbrtDv4_Dh",
"_Z11native_cbrtDv4_f",
"_Z11native_cbrtf",
+"_Z11native_coshDh",
+"_Z11native_coshDv2_Dh",
"_Z11native_coshDv2_f",
+"_Z11native_coshDv3_Dh",
"_Z11native_coshDv3_f",
+"_Z11native_coshDv4_Dh",
"_Z11native_coshDv4_f",
"_Z11native_coshf",
+"_Z11native_exp2Dh",
+"_Z11native_exp2Dv2_Dh",
"_Z11native_exp2Dv2_f",
+"_Z11native_exp2Dv3_Dh",
"_Z11native_exp2Dv3_f",
+"_Z11native_exp2Dv4_Dh",
"_Z11native_exp2Dv4_f",
"_Z11native_exp2f",
+"_Z11native_log2Dh",
+"_Z11native_log2Dv2_Dh",
"_Z11native_log2Dv2_f",
+"_Z11native_log2Dv3_Dh",
"_Z11native_log2Dv3_f",
+"_Z11native_log2Dv4_Dh",
"_Z11native_log2Dv4_f",
"_Z11native_log2f",
+"_Z11native_powrDhDh",
+"_Z11native_powrDv2_DhS_",
"_Z11native_powrDv2_fS_",
+"_Z11native_powrDv3_DhS_",
"_Z11native_powrDv3_fS_",
+"_Z11native_powrDv4_DhS_",
"_Z11native_powrDv4_fS_",
"_Z11native_powrff",
+"_Z11native_sinhDh",
+"_Z11native_sinhDv2_Dh",
"_Z11native_sinhDv2_f",
+"_Z11native_sinhDv3_Dh",
"_Z11native_sinhDv3_f",
+"_Z11native_sinhDv4_Dh",
"_Z11native_sinhDv4_f",
"_Z11native_sinhf",
+"_Z11native_sqrtDh",
+"_Z11native_sqrtDv2_Dh",
"_Z11native_sqrtDv2_f",
+"_Z11native_sqrtDv3_Dh",
"_Z11native_sqrtDv3_f",
+"_Z11native_sqrtDv4_Dh",
"_Z11native_sqrtDv4_f",
"_Z11native_sqrtf",
+"_Z11native_tanhDh",
+"_Z11native_tanhDv2_Dh",
"_Z11native_tanhDv2_f",
+"_Z11native_tanhDv3_Dh",
"_Z11native_tanhDv3_f",
+"_Z11native_tanhDv4_Dh",
"_Z11native_tanhDv4_f",
"_Z11native_tanhf",
"_Z11rsAtomicAddPVii",
@@ -159,6 +223,7 @@
"_Z11rsgDrawText13rs_allocationii",
"_Z11rsgDrawTextPKcii",
"_Z11rsgGetWidthv",
+"_Z12convert_int2Dv2_Dh",
"_Z12convert_int2Dv2_c",
"_Z12convert_int2Dv2_d",
"_Z12convert_int2Dv2_f",
@@ -169,6 +234,7 @@
"_Z12convert_int2Dv2_m",
"_Z12convert_int2Dv2_s",
"_Z12convert_int2Dv2_t",
+"_Z12convert_int3Dv3_Dh",
"_Z12convert_int3Dv3_c",
"_Z12convert_int3Dv3_d",
"_Z12convert_int3Dv3_f",
@@ -179,6 +245,7 @@
"_Z12convert_int3Dv3_m",
"_Z12convert_int3Dv3_s",
"_Z12convert_int3Dv3_t",
+"_Z12convert_int4Dv4_Dh",
"_Z12convert_int4Dv4_c",
"_Z12convert_int4Dv4_d",
"_Z12convert_int4Dv4_f",
@@ -189,64 +256,124 @@
"_Z12convert_int4Dv4_m",
"_Z12convert_int4Dv4_s",
"_Z12convert_int4Dv4_t",
+"_Z12native_acoshDh",
+"_Z12native_acoshDv2_Dh",
"_Z12native_acoshDv2_f",
+"_Z12native_acoshDv3_Dh",
"_Z12native_acoshDv3_f",
+"_Z12native_acoshDv4_Dh",
"_Z12native_acoshDv4_f",
"_Z12native_acoshf",
+"_Z12native_asinhDh",
+"_Z12native_asinhDv2_Dh",
"_Z12native_asinhDv2_f",
+"_Z12native_asinhDv3_Dh",
"_Z12native_asinhDv3_f",
+"_Z12native_asinhDv4_Dh",
"_Z12native_asinhDv4_f",
"_Z12native_asinhf",
+"_Z12native_atan2DhDh",
+"_Z12native_atan2Dv2_DhS_",
"_Z12native_atan2Dv2_fS_",
+"_Z12native_atan2Dv3_DhS_",
"_Z12native_atan2Dv3_fS_",
+"_Z12native_atan2Dv4_DhS_",
"_Z12native_atan2Dv4_fS_",
"_Z12native_atan2ff",
+"_Z12native_atanhDh",
+"_Z12native_atanhDv2_Dh",
"_Z12native_atanhDv2_f",
+"_Z12native_atanhDv3_Dh",
"_Z12native_atanhDv3_f",
+"_Z12native_atanhDv4_Dh",
"_Z12native_atanhDv4_f",
"_Z12native_atanhf",
+"_Z12native_cospiDh",
+"_Z12native_cospiDv2_Dh",
"_Z12native_cospiDv2_f",
+"_Z12native_cospiDv3_Dh",
"_Z12native_cospiDv3_f",
+"_Z12native_cospiDv4_Dh",
"_Z12native_cospiDv4_f",
"_Z12native_cospif",
+"_Z12native_exp10Dh",
+"_Z12native_exp10Dv2_Dh",
"_Z12native_exp10Dv2_f",
+"_Z12native_exp10Dv3_Dh",
"_Z12native_exp10Dv3_f",
+"_Z12native_exp10Dv4_Dh",
"_Z12native_exp10Dv4_f",
"_Z12native_exp10f",
+"_Z12native_expm1Dh",
+"_Z12native_expm1Dv2_Dh",
"_Z12native_expm1Dv2_f",
+"_Z12native_expm1Dv3_Dh",
"_Z12native_expm1Dv3_f",
+"_Z12native_expm1Dv4_Dh",
"_Z12native_expm1Dv4_f",
"_Z12native_expm1f",
+"_Z12native_hypotDhDh",
+"_Z12native_hypotDv2_DhS_",
"_Z12native_hypotDv2_fS_",
+"_Z12native_hypotDv3_DhS_",
"_Z12native_hypotDv3_fS_",
+"_Z12native_hypotDv4_DhS_",
"_Z12native_hypotDv4_fS_",
"_Z12native_hypotff",
+"_Z12native_log10Dh",
+"_Z12native_log10Dv2_Dh",
"_Z12native_log10Dv2_f",
+"_Z12native_log10Dv3_Dh",
"_Z12native_log10Dv3_f",
+"_Z12native_log10Dv4_Dh",
"_Z12native_log10Dv4_f",
"_Z12native_log10f",
+"_Z12native_log1pDh",
+"_Z12native_log1pDv2_Dh",
"_Z12native_log1pDv2_f",
+"_Z12native_log1pDv3_Dh",
"_Z12native_log1pDv3_f",
+"_Z12native_log1pDv4_Dh",
"_Z12native_log1pDv4_f",
"_Z12native_log1pf",
+"_Z12native_recipDh",
+"_Z12native_recipDv2_Dh",
"_Z12native_recipDv2_f",
+"_Z12native_recipDv3_Dh",
"_Z12native_recipDv3_f",
+"_Z12native_recipDv4_Dh",
"_Z12native_recipDv4_f",
"_Z12native_recipf",
+"_Z12native_rootnDhi",
+"_Z12native_rootnDv2_DhDv2_i",
"_Z12native_rootnDv2_fDv2_i",
+"_Z12native_rootnDv3_DhDv3_i",
"_Z12native_rootnDv3_fDv3_i",
+"_Z12native_rootnDv4_DhDv4_i",
"_Z12native_rootnDv4_fDv4_i",
"_Z12native_rootnfi",
+"_Z12native_rsqrtDh",
+"_Z12native_rsqrtDv2_Dh",
"_Z12native_rsqrtDv2_f",
+"_Z12native_rsqrtDv3_Dh",
"_Z12native_rsqrtDv3_f",
+"_Z12native_rsqrtDv4_Dh",
"_Z12native_rsqrtDv4_f",
"_Z12native_rsqrtf",
+"_Z12native_sinpiDh",
+"_Z12native_sinpiDv2_Dh",
"_Z12native_sinpiDv2_f",
+"_Z12native_sinpiDv3_Dh",
"_Z12native_sinpiDv3_f",
+"_Z12native_sinpiDv4_Dh",
"_Z12native_sinpiDv4_f",
"_Z12native_sinpif",
+"_Z12native_tanpiDh",
+"_Z12native_tanpiDv2_Dh",
"_Z12native_tanpiDv2_f",
+"_Z12native_tanpiDv3_Dh",
"_Z12native_tanpiDv3_f",
+"_Z12native_tanpiDv4_Dh",
"_Z12native_tanpiDv4_f",
"_Z12native_tanpif",
"_Z12rsCreateType10rs_elementj",
@@ -263,6 +390,7 @@
"_Z12rsMatrixLoadP12rs_matrix4x4PKf",
"_Z12rsgFontColorffff",
"_Z12rsgGetHeightv",
+"_Z13convert_char2Dv2_Dh",
"_Z13convert_char2Dv2_c",
"_Z13convert_char2Dv2_d",
"_Z13convert_char2Dv2_f",
@@ -273,6 +401,7 @@
"_Z13convert_char2Dv2_m",
"_Z13convert_char2Dv2_s",
"_Z13convert_char2Dv2_t",
+"_Z13convert_char3Dv3_Dh",
"_Z13convert_char3Dv3_c",
"_Z13convert_char3Dv3_d",
"_Z13convert_char3Dv3_f",
@@ -283,6 +412,7 @@
"_Z13convert_char3Dv3_m",
"_Z13convert_char3Dv3_s",
"_Z13convert_char3Dv3_t",
+"_Z13convert_char4Dv4_Dh",
"_Z13convert_char4Dv4_c",
"_Z13convert_char4Dv4_d",
"_Z13convert_char4Dv4_f",
@@ -293,6 +423,37 @@
"_Z13convert_char4Dv4_m",
"_Z13convert_char4Dv4_s",
"_Z13convert_char4Dv4_t",
+"_Z13convert_half2Dv2_c",
+"_Z13convert_half2Dv2_d",
+"_Z13convert_half2Dv2_f",
+"_Z13convert_half2Dv2_h",
+"_Z13convert_half2Dv2_i",
+"_Z13convert_half2Dv2_j",
+"_Z13convert_half2Dv2_l",
+"_Z13convert_half2Dv2_m",
+"_Z13convert_half2Dv2_s",
+"_Z13convert_half2Dv2_t",
+"_Z13convert_half3Dv3_c",
+"_Z13convert_half3Dv3_d",
+"_Z13convert_half3Dv3_f",
+"_Z13convert_half3Dv3_h",
+"_Z13convert_half3Dv3_i",
+"_Z13convert_half3Dv3_j",
+"_Z13convert_half3Dv3_l",
+"_Z13convert_half3Dv3_m",
+"_Z13convert_half3Dv3_s",
+"_Z13convert_half3Dv3_t",
+"_Z13convert_half4Dv4_c",
+"_Z13convert_half4Dv4_d",
+"_Z13convert_half4Dv4_f",
+"_Z13convert_half4Dv4_h",
+"_Z13convert_half4Dv4_i",
+"_Z13convert_half4Dv4_j",
+"_Z13convert_half4Dv4_l",
+"_Z13convert_half4Dv4_m",
+"_Z13convert_half4Dv4_s",
+"_Z13convert_half4Dv4_t",
+"_Z13convert_long2Dv2_Dh",
"_Z13convert_long2Dv2_c",
"_Z13convert_long2Dv2_d",
"_Z13convert_long2Dv2_f",
@@ -303,6 +464,7 @@
"_Z13convert_long2Dv2_m",
"_Z13convert_long2Dv2_s",
"_Z13convert_long2Dv2_t",
+"_Z13convert_long3Dv3_Dh",
"_Z13convert_long3Dv3_c",
"_Z13convert_long3Dv3_d",
"_Z13convert_long3Dv3_f",
@@ -313,6 +475,7 @@
"_Z13convert_long3Dv3_m",
"_Z13convert_long3Dv3_s",
"_Z13convert_long3Dv3_t",
+"_Z13convert_long4Dv4_Dh",
"_Z13convert_long4Dv4_c",
"_Z13convert_long4Dv4_d",
"_Z13convert_long4Dv4_f",
@@ -323,6 +486,7 @@
"_Z13convert_long4Dv4_m",
"_Z13convert_long4Dv4_s",
"_Z13convert_long4Dv4_t",
+"_Z13convert_uint2Dv2_Dh",
"_Z13convert_uint2Dv2_c",
"_Z13convert_uint2Dv2_d",
"_Z13convert_uint2Dv2_f",
@@ -333,6 +497,7 @@
"_Z13convert_uint2Dv2_m",
"_Z13convert_uint2Dv2_s",
"_Z13convert_uint2Dv2_t",
+"_Z13convert_uint3Dv3_Dh",
"_Z13convert_uint3Dv3_c",
"_Z13convert_uint3Dv3_d",
"_Z13convert_uint3Dv3_f",
@@ -343,6 +508,7 @@
"_Z13convert_uint3Dv3_m",
"_Z13convert_uint3Dv3_s",
"_Z13convert_uint3Dv3_t",
+"_Z13convert_uint4Dv4_Dh",
"_Z13convert_uint4Dv4_c",
"_Z13convert_uint4Dv4_d",
"_Z13convert_uint4Dv4_f",
@@ -357,28 +523,48 @@
"_Z13fast_distanceDv3_fS_",
"_Z13fast_distanceDv4_fS_",
"_Z13fast_distanceff",
+"_Z13native_acospiDh",
+"_Z13native_acospiDv2_Dh",
"_Z13native_acospiDv2_f",
+"_Z13native_acospiDv3_Dh",
"_Z13native_acospiDv3_f",
+"_Z13native_acospiDv4_Dh",
"_Z13native_acospiDv4_f",
"_Z13native_acospif",
+"_Z13native_asinpiDh",
+"_Z13native_asinpiDv2_Dh",
"_Z13native_asinpiDv2_f",
+"_Z13native_asinpiDv3_Dh",
"_Z13native_asinpiDv3_f",
+"_Z13native_asinpiDv4_Dh",
"_Z13native_asinpiDv4_f",
"_Z13native_asinpif",
+"_Z13native_atanpiDh",
+"_Z13native_atanpiDv2_Dh",
"_Z13native_atanpiDv2_f",
+"_Z13native_atanpiDv3_Dh",
"_Z13native_atanpiDv3_f",
+"_Z13native_atanpiDv4_Dh",
"_Z13native_atanpiDv4_f",
"_Z13native_atanpif",
+"_Z13native_divideDhDh",
+"_Z13native_divideDv2_DhS_",
"_Z13native_divideDv2_fS_",
+"_Z13native_divideDv3_DhS_",
"_Z13native_divideDv3_fS_",
+"_Z13native_divideDv4_DhS_",
"_Z13native_divideDv4_fS_",
"_Z13native_divideff",
"_Z13native_lengthDv2_f",
"_Z13native_lengthDv3_f",
"_Z13native_lengthDv4_f",
"_Z13native_lengthf",
+"_Z13native_sincosDhPDh",
+"_Z13native_sincosDv2_DhPS_",
"_Z13native_sincosDv2_fPS_",
+"_Z13native_sincosDv3_DhPS_",
"_Z13native_sincosDv3_fPS_",
+"_Z13native_sincosDv4_DhPS_",
"_Z13native_sincosDv4_fPS_",
"_Z13native_sincosfPf",
"_Z13rsClearObjectP10rs_element",
@@ -396,6 +582,7 @@
"_Z13rsUptimeNanosv",
"_Z13rsgClearColorffff",
"_Z13rsgClearDepthf",
+"_Z14convert_float2Dv2_Dh",
"_Z14convert_float2Dv2_c",
"_Z14convert_float2Dv2_d",
"_Z14convert_float2Dv2_f",
@@ -406,6 +593,7 @@
"_Z14convert_float2Dv2_m",
"_Z14convert_float2Dv2_s",
"_Z14convert_float2Dv2_t",
+"_Z14convert_float3Dv3_Dh",
"_Z14convert_float3Dv3_c",
"_Z14convert_float3Dv3_d",
"_Z14convert_float3Dv3_f",
@@ -416,6 +604,7 @@
"_Z14convert_float3Dv3_m",
"_Z14convert_float3Dv3_s",
"_Z14convert_float3Dv3_t",
+"_Z14convert_float4Dv4_Dh",
"_Z14convert_float4Dv4_c",
"_Z14convert_float4Dv4_d",
"_Z14convert_float4Dv4_f",
@@ -426,6 +615,7 @@
"_Z14convert_float4Dv4_m",
"_Z14convert_float4Dv4_s",
"_Z14convert_float4Dv4_t",
+"_Z14convert_short2Dv2_Dh",
"_Z14convert_short2Dv2_c",
"_Z14convert_short2Dv2_d",
"_Z14convert_short2Dv2_f",
@@ -436,6 +626,7 @@
"_Z14convert_short2Dv2_m",
"_Z14convert_short2Dv2_s",
"_Z14convert_short2Dv2_t",
+"_Z14convert_short3Dv3_Dh",
"_Z14convert_short3Dv3_c",
"_Z14convert_short3Dv3_d",
"_Z14convert_short3Dv3_f",
@@ -446,6 +637,7 @@
"_Z14convert_short3Dv3_m",
"_Z14convert_short3Dv3_s",
"_Z14convert_short3Dv3_t",
+"_Z14convert_short4Dv4_Dh",
"_Z14convert_short4Dv4_c",
"_Z14convert_short4Dv4_d",
"_Z14convert_short4Dv4_f",
@@ -456,6 +648,7 @@
"_Z14convert_short4Dv4_m",
"_Z14convert_short4Dv4_s",
"_Z14convert_short4Dv4_t",
+"_Z14convert_uchar2Dv2_Dh",
"_Z14convert_uchar2Dv2_c",
"_Z14convert_uchar2Dv2_d",
"_Z14convert_uchar2Dv2_f",
@@ -466,6 +659,7 @@
"_Z14convert_uchar2Dv2_m",
"_Z14convert_uchar2Dv2_s",
"_Z14convert_uchar2Dv2_t",
+"_Z14convert_uchar3Dv3_Dh",
"_Z14convert_uchar3Dv3_c",
"_Z14convert_uchar3Dv3_d",
"_Z14convert_uchar3Dv3_f",
@@ -476,6 +670,7 @@
"_Z14convert_uchar3Dv3_m",
"_Z14convert_uchar3Dv3_s",
"_Z14convert_uchar3Dv3_t",
+"_Z14convert_uchar4Dv4_Dh",
"_Z14convert_uchar4Dv4_c",
"_Z14convert_uchar4Dv4_d",
"_Z14convert_uchar4Dv4_f",
@@ -486,6 +681,7 @@
"_Z14convert_uchar4Dv4_m",
"_Z14convert_uchar4Dv4_s",
"_Z14convert_uchar4Dv4_t",
+"_Z14convert_ulong2Dv2_Dh",
"_Z14convert_ulong2Dv2_c",
"_Z14convert_ulong2Dv2_d",
"_Z14convert_ulong2Dv2_f",
@@ -496,6 +692,7 @@
"_Z14convert_ulong2Dv2_m",
"_Z14convert_ulong2Dv2_s",
"_Z14convert_ulong2Dv2_t",
+"_Z14convert_ulong3Dv3_Dh",
"_Z14convert_ulong3Dv3_c",
"_Z14convert_ulong3Dv3_d",
"_Z14convert_ulong3Dv3_f",
@@ -506,6 +703,7 @@
"_Z14convert_ulong3Dv3_m",
"_Z14convert_ulong3Dv3_s",
"_Z14convert_ulong3Dv3_t",
+"_Z14convert_ulong4Dv4_Dh",
"_Z14convert_ulong4Dv4_c",
"_Z14convert_ulong4Dv4_d",
"_Z14convert_ulong4Dv4_f",
@@ -520,8 +718,12 @@
"_Z14fast_normalizeDv3_f",
"_Z14fast_normalizeDv4_f",
"_Z14fast_normalizef",
+"_Z14native_atan2piDhDh",
+"_Z14native_atan2piDv2_DhS_",
"_Z14native_atan2piDv2_fS_",
+"_Z14native_atan2piDv3_DhS_",
"_Z14native_atan2piDv3_fS_",
+"_Z14native_atan2piDv4_DhS_",
"_Z14native_atan2piDv4_fS_",
"_Z14native_atan2piff",
"_Z14rsGetDimArray0PK19rs_kernel_context_t",
@@ -541,6 +743,7 @@
"_Z14rsgBindTexture19rs_program_fragmentj13rs_allocation",
"_Z14rsgMeasureText13rs_allocationPiS0_S0_S0_",
"_Z14rsgMeasureTextPKcPiS1_S1_S1_",
+"_Z15convert_double2Dv2_Dh",
"_Z15convert_double2Dv2_c",
"_Z15convert_double2Dv2_d",
"_Z15convert_double2Dv2_f",
@@ -551,6 +754,7 @@
"_Z15convert_double2Dv2_m",
"_Z15convert_double2Dv2_s",
"_Z15convert_double2Dv2_t",
+"_Z15convert_double3Dv3_Dh",
"_Z15convert_double3Dv3_c",
"_Z15convert_double3Dv3_d",
"_Z15convert_double3Dv3_f",
@@ -561,6 +765,7 @@
"_Z15convert_double3Dv3_m",
"_Z15convert_double3Dv3_s",
"_Z15convert_double3Dv3_t",
+"_Z15convert_double4Dv4_Dh",
"_Z15convert_double4Dv4_c",
"_Z15convert_double4Dv4_d",
"_Z15convert_double4Dv4_f",
@@ -571,6 +776,7 @@
"_Z15convert_double4Dv4_m",
"_Z15convert_double4Dv4_s",
"_Z15convert_double4Dv4_t",
+"_Z15convert_ushort2Dv2_Dh",
"_Z15convert_ushort2Dv2_c",
"_Z15convert_ushort2Dv2_d",
"_Z15convert_ushort2Dv2_f",
@@ -581,6 +787,7 @@
"_Z15convert_ushort2Dv2_m",
"_Z15convert_ushort2Dv2_s",
"_Z15convert_ushort2Dv2_t",
+"_Z15convert_ushort3Dv3_Dh",
"_Z15convert_ushort3Dv3_c",
"_Z15convert_ushort3Dv3_d",
"_Z15convert_ushort3Dv3_f",
@@ -591,6 +798,7 @@
"_Z15convert_ushort3Dv3_m",
"_Z15convert_ushort3Dv3_s",
"_Z15convert_ushort3Dv3_t",
+"_Z15convert_ushort4Dv4_Dh",
"_Z15convert_ushort4Dv4_c",
"_Z15convert_ushort4Dv4_d",
"_Z15convert_ushort4Dv4_f",
@@ -631,7 +839,7 @@
"_Z16rsMatrixMultiplyPK12rs_matrix4x4Dv2_f",
"_Z16rsMatrixMultiplyPK12rs_matrix4x4Dv3_f",
"_Z16rsMatrixMultiplyPK12rs_matrix4x4Dv4_f",
-"_Z17rsForEachInternaliP14rs_script_calliiz",
+"_Z17rsForEachInternaliP14rs_script_calliiP13rs_allocation",
"_Z17rsMatrixLoadOrthoP12rs_matrix4x4ffffff",
"_Z17rsMatrixLoadScaleP12rs_matrix4x4fff",
"_Z17rsMatrixTranslateP12rs_matrix4x4fff",
@@ -1217,34 +1425,65 @@
"_Z3clzj",
"_Z3clzs",
"_Z3clzt",
+"_Z3cosDh",
+"_Z3cosDv2_Dh",
"_Z3cosDv2_f",
+"_Z3cosDv3_Dh",
"_Z3cosDv3_f",
+"_Z3cosDv4_Dh",
"_Z3cosDv4_f",
"_Z3cosf",
+"_Z3dotDhDh",
+"_Z3dotDv2_DhS_",
"_Z3dotDv2_fS_",
+"_Z3dotDv3_DhS_",
"_Z3dotDv3_fS_",
+"_Z3dotDv4_DhS_",
"_Z3dotDv4_fS_",
"_Z3dotff",
+"_Z3erfDh",
+"_Z3erfDv2_Dh",
"_Z3erfDv2_f",
+"_Z3erfDv3_Dh",
"_Z3erfDv3_f",
+"_Z3erfDv4_Dh",
"_Z3erfDv4_f",
"_Z3erff",
+"_Z3expDh",
+"_Z3expDv2_Dh",
"_Z3expDv2_f",
+"_Z3expDv3_Dh",
"_Z3expDv3_f",
+"_Z3expDv4_Dh",
"_Z3expDv4_f",
"_Z3expf",
+"_Z3fmaDhDhDh",
+"_Z3fmaDv2_DhS_S_",
"_Z3fmaDv2_fS_S_",
+"_Z3fmaDv3_DhS_S_",
"_Z3fmaDv3_fS_S_",
+"_Z3fmaDv4_DhS_S_",
"_Z3fmaDv4_fS_S_",
"_Z3fmafff",
+"_Z3logDh",
+"_Z3logDv2_Dh",
"_Z3logDv2_f",
+"_Z3logDv3_Dh",
"_Z3logDv3_f",
+"_Z3logDv4_Dh",
"_Z3logDv4_f",
"_Z3logf",
+"_Z3madDhDhDh",
+"_Z3madDv2_DhS_S_",
"_Z3madDv2_fS_S_",
+"_Z3madDv3_DhS_S_",
"_Z3madDv3_fS_S_",
+"_Z3madDv4_DhS_S_",
"_Z3madDv4_fS_S_",
"_Z3madfff",
+"_Z3maxDhDh",
+"_Z3maxDv2_DhDh",
+"_Z3maxDv2_DhS_",
"_Z3maxDv2_cS_",
"_Z3maxDv2_fS_",
"_Z3maxDv2_ff",
@@ -1255,6 +1494,8 @@
"_Z3maxDv2_mS_",
"_Z3maxDv2_sS_",
"_Z3maxDv2_tS_",
+"_Z3maxDv3_DhDh",
+"_Z3maxDv3_DhS_",
"_Z3maxDv3_cS_",
"_Z3maxDv3_fS_",
"_Z3maxDv3_ff",
@@ -1265,6 +1506,8 @@
"_Z3maxDv3_mS_",
"_Z3maxDv3_sS_",
"_Z3maxDv3_tS_",
+"_Z3maxDv4_DhDh",
+"_Z3maxDv4_DhS_",
"_Z3maxDv4_cS_",
"_Z3maxDv4_fS_",
"_Z3maxDv4_ff",
@@ -1284,6 +1527,9 @@
"_Z3maxmm",
"_Z3maxss",
"_Z3maxtt",
+"_Z3minDhDh",
+"_Z3minDv2_DhDh",
+"_Z3minDv2_DhS_",
"_Z3minDv2_cS_",
"_Z3minDv2_fS_",
"_Z3minDv2_ff",
@@ -1294,6 +1540,8 @@
"_Z3minDv2_mS_",
"_Z3minDv2_sS_",
"_Z3minDv2_tS_",
+"_Z3minDv3_DhDh",
+"_Z3minDv3_DhS_",
"_Z3minDv3_cS_",
"_Z3minDv3_fS_",
"_Z3minDv3_ff",
@@ -1304,6 +1552,8 @@
"_Z3minDv3_mS_",
"_Z3minDv3_sS_",
"_Z3minDv3_tS_",
+"_Z3minDv4_DhDh",
+"_Z3minDv4_DhS_",
"_Z3minDv4_cS_",
"_Z3minDv4_fS_",
"_Z3minDv4_ff",
@@ -1323,150 +1573,292 @@
"_Z3minmm",
"_Z3minss",
"_Z3mintt",
+"_Z3mixDhDhDh",
+"_Z3mixDv2_DhS_Dh",
+"_Z3mixDv2_DhS_S_",
"_Z3mixDv2_fS_S_",
"_Z3mixDv2_fS_f",
+"_Z3mixDv3_DhS_Dh",
+"_Z3mixDv3_DhS_S_",
"_Z3mixDv3_fS_S_",
"_Z3mixDv3_fS_f",
+"_Z3mixDv4_DhS_Dh",
+"_Z3mixDv4_DhS_S_",
"_Z3mixDv4_fS_S_",
"_Z3mixDv4_fS_f",
"_Z3mixfff",
"_Z3nanj",
+"_Z3powDhDh",
+"_Z3powDv2_DhS_",
"_Z3powDv2_fS_",
+"_Z3powDv3_DhS_",
"_Z3powDv3_fS_",
+"_Z3powDv4_DhS_",
"_Z3powDv4_fS_",
"_Z3powff",
+"_Z3sinDh",
+"_Z3sinDv2_Dh",
"_Z3sinDv2_f",
+"_Z3sinDv3_Dh",
"_Z3sinDv3_f",
+"_Z3sinDv4_Dh",
"_Z3sinDv4_f",
"_Z3sinf",
+"_Z3tanDh",
+"_Z3tanDv2_Dh",
"_Z3tanDv2_f",
+"_Z3tanDv3_Dh",
"_Z3tanDv3_f",
+"_Z3tanDv4_Dh",
"_Z3tanDv4_f",
"_Z3tanf",
+"_Z4acosDh",
+"_Z4acosDv2_Dh",
"_Z4acosDv2_f",
+"_Z4acosDv3_Dh",
"_Z4acosDv3_f",
+"_Z4acosDv4_Dh",
"_Z4acosDv4_f",
"_Z4acosf",
+"_Z4asinDh",
+"_Z4asinDv2_Dh",
"_Z4asinDv2_f",
+"_Z4asinDv3_Dh",
"_Z4asinDv3_f",
+"_Z4asinDv4_Dh",
"_Z4asinDv4_f",
"_Z4asinf",
+"_Z4atanDh",
+"_Z4atanDv2_Dh",
"_Z4atanDv2_f",
+"_Z4atanDv3_Dh",
"_Z4atanDv3_f",
+"_Z4atanDv4_Dh",
"_Z4atanDv4_f",
"_Z4atanf",
+"_Z4cbrtDh",
+"_Z4cbrtDv2_Dh",
"_Z4cbrtDv2_f",
+"_Z4cbrtDv3_Dh",
"_Z4cbrtDv3_f",
+"_Z4cbrtDv4_Dh",
"_Z4cbrtDv4_f",
"_Z4cbrtf",
+"_Z4ceilDh",
+"_Z4ceilDv2_Dh",
"_Z4ceilDv2_f",
+"_Z4ceilDv3_Dh",
"_Z4ceilDv3_f",
+"_Z4ceilDv4_Dh",
"_Z4ceilDv4_f",
"_Z4ceilf",
+"_Z4coshDh",
+"_Z4coshDv2_Dh",
"_Z4coshDv2_f",
+"_Z4coshDv3_Dh",
"_Z4coshDv3_f",
+"_Z4coshDv4_Dh",
"_Z4coshDv4_f",
"_Z4coshf",
+"_Z4erfcDh",
+"_Z4erfcDv2_Dh",
"_Z4erfcDv2_f",
+"_Z4erfcDv3_Dh",
"_Z4erfcDv3_f",
+"_Z4erfcDv4_Dh",
"_Z4erfcDv4_f",
"_Z4erfcf",
+"_Z4exp2Dh",
+"_Z4exp2Dv2_Dh",
"_Z4exp2Dv2_f",
+"_Z4exp2Dv3_Dh",
"_Z4exp2Dv3_f",
+"_Z4exp2Dv4_Dh",
"_Z4exp2Dv4_f",
"_Z4exp2f",
+"_Z4fabsDh",
+"_Z4fabsDv2_Dh",
"_Z4fabsDv2_f",
+"_Z4fabsDv3_Dh",
"_Z4fabsDv3_f",
+"_Z4fabsDv4_Dh",
"_Z4fabsDv4_f",
"_Z4fabsf",
+"_Z4fdimDhDh",
+"_Z4fdimDv2_DhS_",
"_Z4fdimDv2_fS_",
+"_Z4fdimDv3_DhS_",
"_Z4fdimDv3_fS_",
+"_Z4fdimDv4_DhS_",
"_Z4fdimDv4_fS_",
"_Z4fdimff",
+"_Z4fmaxDhDh",
+"_Z4fmaxDv2_DhDh",
+"_Z4fmaxDv2_DhS_",
"_Z4fmaxDv2_fS_",
"_Z4fmaxDv2_ff",
+"_Z4fmaxDv3_DhDh",
+"_Z4fmaxDv3_DhS_",
"_Z4fmaxDv3_fS_",
"_Z4fmaxDv3_ff",
+"_Z4fmaxDv4_DhDh",
+"_Z4fmaxDv4_DhS_",
"_Z4fmaxDv4_fS_",
"_Z4fmaxDv4_ff",
"_Z4fmaxff",
+"_Z4fminDhDh",
+"_Z4fminDv2_DhDh",
+"_Z4fminDv2_DhS_",
"_Z4fminDv2_fS_",
"_Z4fminDv2_ff",
+"_Z4fminDv3_DhDh",
+"_Z4fminDv3_DhS_",
"_Z4fminDv3_fS_",
"_Z4fminDv3_ff",
+"_Z4fminDv4_DhDh",
+"_Z4fminDv4_DhS_",
"_Z4fminDv4_fS_",
"_Z4fminDv4_ff",
"_Z4fminff",
+"_Z4fmodDhDh",
+"_Z4fmodDv2_DhS_",
"_Z4fmodDv2_fS_",
+"_Z4fmodDv3_DhS_",
"_Z4fmodDv3_fS_",
+"_Z4fmodDv4_DhS_",
"_Z4fmodDv4_fS_",
"_Z4fmodff",
+"_Z4log2Dh",
+"_Z4log2Dv2_Dh",
"_Z4log2Dv2_f",
+"_Z4log2Dv3_Dh",
"_Z4log2Dv3_f",
+"_Z4log2Dv4_Dh",
"_Z4log2Dv4_f",
"_Z4log2f",
+"_Z4logbDh",
+"_Z4logbDv2_Dh",
"_Z4logbDv2_f",
+"_Z4logbDv3_Dh",
"_Z4logbDv3_f",
+"_Z4logbDv4_Dh",
"_Z4logbDv4_f",
"_Z4logbf",
"_Z4modfDv2_fPS_",
"_Z4modfDv3_fPS_",
"_Z4modfDv4_fPS_",
"_Z4modffPf",
+"_Z4pownDhi",
+"_Z4pownDv2_DhDv2_i",
"_Z4pownDv2_fDv2_i",
+"_Z4pownDv3_DhDv3_i",
"_Z4pownDv3_fDv3_i",
+"_Z4pownDv4_DhDv4_i",
"_Z4pownDv4_fDv4_i",
"_Z4pownfi",
+"_Z4powrDhDh",
+"_Z4powrDv2_DhS_",
"_Z4powrDv2_fS_",
+"_Z4powrDv3_DhS_",
"_Z4powrDv3_fS_",
+"_Z4powrDv4_DhS_",
"_Z4powrDv4_fS_",
"_Z4powrff",
+"_Z4rintDh",
+"_Z4rintDv2_Dh",
"_Z4rintDv2_f",
+"_Z4rintDv3_Dh",
"_Z4rintDv3_f",
+"_Z4rintDv4_Dh",
"_Z4rintDv4_f",
"_Z4rintf",
+"_Z4signDh",
+"_Z4signDv2_Dh",
"_Z4signDv2_f",
+"_Z4signDv3_Dh",
"_Z4signDv3_f",
+"_Z4signDv4_Dh",
"_Z4signDv4_f",
"_Z4signf",
+"_Z4sinhDh",
+"_Z4sinhDv2_Dh",
"_Z4sinhDv2_f",
+"_Z4sinhDv3_Dh",
"_Z4sinhDv3_f",
+"_Z4sinhDv4_Dh",
"_Z4sinhDv4_f",
"_Z4sinhf",
+"_Z4sqrtDh",
+"_Z4sqrtDv2_Dh",
"_Z4sqrtDv2_f",
+"_Z4sqrtDv3_Dh",
"_Z4sqrtDv3_f",
+"_Z4sqrtDv4_Dh",
"_Z4sqrtDv4_f",
"_Z4sqrtf",
+"_Z4stepDhDh",
+"_Z4stepDhDv2_Dh",
+"_Z4stepDhDv3_Dh",
+"_Z4stepDhDv4_Dh",
+"_Z4stepDv2_DhDh",
+"_Z4stepDv2_DhS_",
"_Z4stepDv2_fS_",
"_Z4stepDv2_ff",
+"_Z4stepDv3_DhDh",
+"_Z4stepDv3_DhS_",
"_Z4stepDv3_fS_",
"_Z4stepDv3_ff",
+"_Z4stepDv4_DhDh",
+"_Z4stepDv4_DhS_",
"_Z4stepDv4_fS_",
"_Z4stepDv4_ff",
"_Z4stepfDv2_f",
"_Z4stepfDv3_f",
"_Z4stepfDv4_f",
"_Z4stepff",
+"_Z4tanhDh",
+"_Z4tanhDv2_Dh",
"_Z4tanhDv2_f",
+"_Z4tanhDv3_Dh",
"_Z4tanhDv3_f",
+"_Z4tanhDv4_Dh",
"_Z4tanhDv4_f",
"_Z4tanhf",
+"_Z5acoshDh",
+"_Z5acoshDv2_Dh",
"_Z5acoshDv2_f",
+"_Z5acoshDv3_Dh",
"_Z5acoshDv3_f",
+"_Z5acoshDv4_Dh",
"_Z5acoshDv4_f",
"_Z5acoshf",
+"_Z5asinhDh",
+"_Z5asinhDv2_Dh",
"_Z5asinhDv2_f",
+"_Z5asinhDv3_Dh",
"_Z5asinhDv3_f",
+"_Z5asinhDv4_Dh",
"_Z5asinhDv4_f",
"_Z5asinhf",
+"_Z5atan2DhDh",
+"_Z5atan2Dv2_DhS_",
"_Z5atan2Dv2_fS_",
+"_Z5atan2Dv3_DhS_",
"_Z5atan2Dv3_fS_",
+"_Z5atan2Dv4_DhS_",
"_Z5atan2Dv4_fS_",
"_Z5atan2ff",
+"_Z5atanhDh",
+"_Z5atanhDv2_Dh",
"_Z5atanhDv2_f",
+"_Z5atanhDv3_Dh",
"_Z5atanhDv3_f",
+"_Z5atanhDv4_Dh",
"_Z5atanhDv4_f",
"_Z5atanhf",
+"_Z5clampDhDhDh",
+"_Z5clampDv2_DhDhDh",
+"_Z5clampDv2_DhS_S_",
"_Z5clampDv2_cS_S_",
"_Z5clampDv2_ccc",
"_Z5clampDv2_fS_S_",
@@ -1487,6 +1879,8 @@
"_Z5clampDv2_ttt",
"_Z5clampDv2_yS_S_",
"_Z5clampDv2_yyy",
+"_Z5clampDv3_DhDhDh",
+"_Z5clampDv3_DhS_S_",
"_Z5clampDv3_cS_S_",
"_Z5clampDv3_ccc",
"_Z5clampDv3_fS_S_",
@@ -1507,6 +1901,8 @@
"_Z5clampDv3_ttt",
"_Z5clampDv3_yS_S_",
"_Z5clampDv3_yyy",
+"_Z5clampDv4_DhDhDh",
+"_Z5clampDv4_DhS_S_",
"_Z5clampDv4_cS_S_",
"_Z5clampDv4_ccc",
"_Z5clampDv4_fS_S_",
@@ -1537,22 +1933,40 @@
"_Z5clampsss",
"_Z5clampttt",
"_Z5clampyyy",
+"_Z5cospiDh",
+"_Z5cospiDv2_Dh",
"_Z5cospiDv2_f",
+"_Z5cospiDv3_Dh",
"_Z5cospiDv3_f",
+"_Z5cospiDv4_Dh",
"_Z5cospiDv4_f",
"_Z5cospif",
+"_Z5crossDv3_DhS_",
"_Z5crossDv3_fS_",
+"_Z5crossDv4_DhS_",
"_Z5crossDv4_fS_",
+"_Z5exp10Dh",
+"_Z5exp10Dv2_Dh",
"_Z5exp10Dv2_f",
+"_Z5exp10Dv3_Dh",
"_Z5exp10Dv3_f",
+"_Z5exp10Dv4_Dh",
"_Z5exp10Dv4_f",
"_Z5exp10f",
+"_Z5expm1Dh",
+"_Z5expm1Dv2_Dh",
"_Z5expm1Dv2_f",
+"_Z5expm1Dv3_Dh",
"_Z5expm1Dv3_f",
+"_Z5expm1Dv4_Dh",
"_Z5expm1Dv4_f",
"_Z5expm1f",
+"_Z5floorDh",
+"_Z5floorDv2_Dh",
"_Z5floorDv2_f",
+"_Z5floorDv3_Dh",
"_Z5floorDv3_f",
+"_Z5floorDv4_Dh",
"_Z5floorDv4_f",
"_Z5floorf",
"_Z5fractDv2_fPS_",
@@ -1563,79 +1977,146 @@
"_Z5frexpDv3_fPDv3_i",
"_Z5frexpDv4_fPDv4_i",
"_Z5frexpfPi",
+"_Z5hypotDhDh",
+"_Z5hypotDv2_DhS_",
"_Z5hypotDv2_fS_",
+"_Z5hypotDv3_DhS_",
"_Z5hypotDv3_fS_",
+"_Z5hypotDv4_DhS_",
"_Z5hypotDv4_fS_",
"_Z5hypotff",
"_Z5ilogbDv2_f",
"_Z5ilogbDv3_f",
"_Z5ilogbDv4_f",
"_Z5ilogbf",
+"_Z5ldexpDhi",
+"_Z5ldexpDv2_DhDv2_i",
+"_Z5ldexpDv2_Dhi",
"_Z5ldexpDv2_fDv2_i",
"_Z5ldexpDv2_fi",
+"_Z5ldexpDv3_DhDv3_i",
+"_Z5ldexpDv3_Dhi",
"_Z5ldexpDv3_fDv3_i",
"_Z5ldexpDv3_fi",
+"_Z5ldexpDv4_DhDv4_i",
+"_Z5ldexpDv4_Dhi",
"_Z5ldexpDv4_fDv4_i",
"_Z5ldexpDv4_fi",
"_Z5ldexpfi",
+"_Z5log10Dh",
+"_Z5log10Dv2_Dh",
"_Z5log10Dv2_f",
+"_Z5log10Dv3_Dh",
"_Z5log10Dv3_f",
+"_Z5log10Dv4_Dh",
"_Z5log10Dv4_f",
"_Z5log10f",
+"_Z5log1pDh",
+"_Z5log1pDv2_Dh",
"_Z5log1pDv2_f",
+"_Z5log1pDv3_Dh",
"_Z5log1pDv3_f",
+"_Z5log1pDv4_Dh",
"_Z5log1pDv4_f",
"_Z5log1pf",
+"_Z5rootnDhi",
+"_Z5rootnDv2_DhDv2_i",
"_Z5rootnDv2_fDv2_i",
+"_Z5rootnDv3_DhDv3_i",
"_Z5rootnDv3_fDv3_i",
+"_Z5rootnDv4_DhDv4_i",
"_Z5rootnDv4_fDv4_i",
"_Z5rootnfi",
+"_Z5roundDh",
+"_Z5roundDv2_Dh",
"_Z5roundDv2_f",
+"_Z5roundDv3_Dh",
"_Z5roundDv3_f",
+"_Z5roundDv4_Dh",
"_Z5roundDv4_f",
"_Z5roundf",
+"_Z5rsqrtDh",
+"_Z5rsqrtDv2_Dh",
"_Z5rsqrtDv2_f",
+"_Z5rsqrtDv3_Dh",
"_Z5rsqrtDv3_f",
+"_Z5rsqrtDv4_Dh",
"_Z5rsqrtDv4_f",
"_Z5rsqrtf",
+"_Z5sinpiDh",
+"_Z5sinpiDv2_Dh",
"_Z5sinpiDv2_f",
+"_Z5sinpiDv3_Dh",
"_Z5sinpiDv3_f",
+"_Z5sinpiDv4_Dh",
"_Z5sinpiDv4_f",
"_Z5sinpif",
+"_Z5tanpiDh",
+"_Z5tanpiDv2_Dh",
"_Z5tanpiDv2_f",
+"_Z5tanpiDv3_Dh",
"_Z5tanpiDv3_f",
+"_Z5tanpiDv4_Dh",
"_Z5tanpiDv4_f",
"_Z5tanpif",
+"_Z5truncDh",
+"_Z5truncDv2_Dh",
"_Z5truncDv2_f",
+"_Z5truncDv3_Dh",
"_Z5truncDv3_f",
+"_Z5truncDv4_Dh",
"_Z5truncDv4_f",
"_Z5truncf",
+"_Z6acospiDh",
+"_Z6acospiDv2_Dh",
"_Z6acospiDv2_f",
+"_Z6acospiDv3_Dh",
"_Z6acospiDv3_f",
+"_Z6acospiDv4_Dh",
"_Z6acospiDv4_f",
"_Z6acospif",
+"_Z6asinpiDh",
+"_Z6asinpiDv2_Dh",
"_Z6asinpiDv2_f",
+"_Z6asinpiDv3_Dh",
"_Z6asinpiDv3_f",
+"_Z6asinpiDv4_Dh",
"_Z6asinpiDv4_f",
"_Z6asinpif",
+"_Z6atanpiDh",
+"_Z6atanpiDv2_Dh",
"_Z6atanpiDv2_f",
+"_Z6atanpiDv3_Dh",
"_Z6atanpiDv3_f",
+"_Z6atanpiDv4_Dh",
"_Z6atanpiDv4_f",
"_Z6atanpif",
"_Z6lengthDv2_f",
"_Z6lengthDv3_f",
"_Z6lengthDv4_f",
"_Z6lengthf",
+"_Z6lgammaDh",
+"_Z6lgammaDhPi",
+"_Z6lgammaDv2_Dh",
+"_Z6lgammaDv2_DhPDv2_i",
"_Z6lgammaDv2_f",
"_Z6lgammaDv2_fPDv2_i",
+"_Z6lgammaDv3_Dh",
+"_Z6lgammaDv3_DhPDv3_i",
"_Z6lgammaDv3_f",
"_Z6lgammaDv3_fPDv3_i",
+"_Z6lgammaDv4_Dh",
+"_Z6lgammaDv4_DhPDv4_i",
"_Z6lgammaDv4_f",
"_Z6lgammaDv4_fPDv4_i",
"_Z6lgammaf",
"_Z6lgammafPi",
+"_Z6remquoDhDhPi",
+"_Z6remquoDv2_DhS_PDv2_i",
"_Z6remquoDv2_fS_PDv2_i",
+"_Z6remquoDv3_DhS_PDv3_i",
"_Z6remquoDv3_fS_PDv3_i",
+"_Z6remquoDv4_DhS_PDv4_i",
"_Z6remquoDv4_fS_PDv4_i",
"_Z6remquoffPi",
"_Z6rsFracf",
@@ -1645,24 +2126,44 @@
"_Z6rsRandii",
"_Z6rsTimePi",
"_Z6rsTimePl",
+"_Z6sincosDhPDh",
+"_Z6sincosDv2_DhPS_",
"_Z6sincosDv2_fPS_",
+"_Z6sincosDv3_DhPS_",
"_Z6sincosDv3_fPS_",
+"_Z6sincosDv4_DhPS_",
"_Z6sincosDv4_fPS_",
"_Z6sincosfPf",
+"_Z6tgammaDh",
+"_Z6tgammaDv2_Dh",
"_Z6tgammaDv2_f",
+"_Z6tgammaDv3_Dh",
"_Z6tgammaDv3_f",
+"_Z6tgammaDv4_Dh",
"_Z6tgammaDv4_f",
"_Z6tgammaf",
+"_Z7atan2piDhDh",
+"_Z7atan2piDv2_DhS_",
"_Z7atan2piDv2_fS_",
+"_Z7atan2piDv3_DhS_",
"_Z7atan2piDv3_fS_",
+"_Z7atan2piDv4_DhS_",
"_Z7atan2piDv4_fS_",
"_Z7atan2piff",
+"_Z7degreesDh",
+"_Z7degreesDv2_Dh",
"_Z7degreesDv2_f",
+"_Z7degreesDv3_Dh",
"_Z7degreesDv3_f",
+"_Z7degreesDv4_Dh",
"_Z7degreesDv4_f",
"_Z7degreesf",
+"_Z7radiansDh",
+"_Z7radiansDv2_Dh",
"_Z7radiansDv2_f",
+"_Z7radiansDv3_Dh",
"_Z7radiansDv3_f",
+"_Z7radiansDv4_Dh",
"_Z7radiansDv4_f",
"_Z7radiansf",
"_Z7rsClampccc",
@@ -1728,10 +2229,15 @@
"_Z8copysignDv3_fS_",
"_Z8copysignDv4_fS_",
"_Z8copysignff",
+"_Z8distanceDhDh",
+"_Z8distanceDv2_DhS_",
"_Z8distanceDv2_fS_",
+"_Z8distanceDv3_DhS_",
"_Z8distanceDv3_fS_",
+"_Z8distanceDv4_DhS_",
"_Z8distanceDv4_fS_",
"_Z8distanceff",
+"_Z8nan_halfv",
"_Z8rsGetLodPK19rs_kernel_context_t",
"_Z8rsSample13rs_allocation10rs_samplerDv2_f",
"_Z8rsSample13rs_allocation10rs_samplerDv2_ff",
@@ -1749,8 +2255,12 @@
"_Z9normalizeDv3_f",
"_Z9normalizeDv4_f",
"_Z9normalizef",
+"_Z9remainderDhDh",
+"_Z9remainderDv2_DhS_",
"_Z9remainderDv2_fS_",
+"_Z9remainderDv3_DhS_",
"_Z9remainderDv3_fS_",
+"_Z9remainderDv4_DhS_",
"_Z9remainderDv4_fS_",
"_Z9remainderff",
"_Z9rsForEach9rs_script13rs_allocationS0_",
diff --git a/lib/Renderscript/RSX86CallConvPass.cpp b/lib/Renderscript/RSX86CallConvPass.cpp
index 5a0c990..19c1d9d 100644
--- a/lib/Renderscript/RSX86CallConvPass.cpp
+++ b/lib/Renderscript/RSX86CallConvPass.cpp
@@ -83,6 +83,9 @@
// rsClearObject's first parameter is a pointer
if (FName.find("rsClearObject") != std::string::npos && ArgNo == 0)
return false;
+ // rsForEachInternal's fifth parameter is a pointer
+ if (FName.find("rsForEachInternal") != std::string::npos && ArgNo == 4)
+ return false;
return true;
}
diff --git a/tests/libbcc/test_reduce_general_metadata.ll b/tests/libbcc/test_reduce_general_metadata.ll
new file mode 100644
index 0000000..d23854a
--- /dev/null
+++ b/tests/libbcc/test_reduce_general_metadata.ll
@@ -0,0 +1,333 @@
+; Check that the #rs_export_reduce_new node is recognized.
+
+; RUN: llvm-rs-as %s -o %t
+; RUN: bcinfo %t | FileCheck %s
+
+; CHECK: exportReduceNewCount: 8
+; CHECK: exportReduceNewList[0]: addint - 0x00000001 - 1 - 4
+; CHECK: accumulator(aiAccum)
+; CHECK: exportReduceNewList[1]: mpyint - 0x00000001 - 1 - 4
+; CHECK: initializer(mpyInit)
+; CHECK: accumulator(mpyAccum)
+; CHECK: exportReduceNewList[2]: dp - 0x00000001 - 2 - 4
+; CHECK: accumulator(dpAccum)
+; CHECK: combiner(dpSum)
+; CHECK: exportReduceNewList[3]: findMinAndMax - 0x00000009 - 1 - 16
+; CHECK: initializer(fMMInit)
+; CHECK: accumulator(fMMAccumulator)
+; CHECK: combiner(fMMCombiner)
+; CHECK: outconverter(fMMOutConverter)
+; CHECK: exportReduceNewList[4]: fz - 0x00000009 - 1 - 4
+; CHECK: initializer(fzInit)
+; CHECK: accumulator(fzAccum)
+; CHECK: combiner(fzCombine)
+; CHECK: halter(fzFound)
+; CHECK: exportReduceNewList[5]: fz2 - 0x00000019 - 1 - 8
+; CHECK: initializer(fz2Init)
+; CHECK: accumulator(fz2Accum)
+; CHECK: combiner(fz2Combine)
+; CHECK: halter(fz2Found)
+; CHECK: exportReduceNewList[6]: histogram - 0x00000001 - 1 - 1024
+; CHECK: accumulator(hsgAccum)
+; CHECK: combiner(hsgCombine)
+; CHECK: exportReduceNewList[7]: mode - 0x00000001 - 1 - 1024
+; CHECK: accumulator(hsgAccum)
+; CHECK: combiner(hsgCombine)
+; CHECK: outconverter(modeOutConvert)
+
+; ModuleID = 'reduce_general_examples.bc'
+target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"
+target triple = "aarch64-none-linux-gnueabi"
+
+%struct.MinAndMax.0 = type { %struct.IndexedVal.1, %struct.IndexedVal.1 }
+%struct.IndexedVal.1 = type { float, i32 }
+
+@fMMInit.r = internal unnamed_addr constant %struct.MinAndMax.0 { %struct.IndexedVal.1 { float 0.000000e+00, i32 -1 }, %struct.IndexedVal.1 { float -0.000000e+00, i32 -1 } }, align 4
+@llvm.used = appending global [20 x i8*] [i8* bitcast (void (<2 x i32>*)* @fz2Init to i8*), i8* bitcast (void ([256 x i32]*, [256 x i32]*)* @hsgCombine to i8*), i8* bitcast (i1 (<2 x i32>*)* @fz2Found to i8*), i8* bitcast (void (i32*, i32)* @mpyAccum to i8*), i8* bitcast (void (%struct.MinAndMax.0*)* @fMMInit to i8*), i8* bitcast (void (float*, float, float)* @dpAccum to i8*), i8* bitcast (void (<2 x i32>*, [256 x i32]*)* @modeOutConvert to i8*), i8* bitcast (void ([256 x i32]*, i8)* @hsgAccum to i8*), i8* bitcast (void (i32*)* @mpyInit to i8*), i8* bitcast (void (%struct.MinAndMax.0*, float, i32)* @fMMAccumulator to i8*), i8* bitcast (void (float*, float*)* @dpSum to i8*), i8* bitcast (void (%struct.MinAndMax.0*, %struct.MinAndMax.0*)* @fMMCombiner to i8*), i8* bitcast (void (i32*, i32*)* @fzCombine to i8*), i8* bitcast (void (i32*, i32)* @aiAccum to i8*), i8* bitcast (void (i32*)* @fzInit to i8*), i8* bitcast (void (i32*, i32, i32)* @fzAccum to i8*), i8* bitcast (i1 (i32*)* @fzFound to i8*), i8* bitcast (void (<2 x i32>*, i32, i32, i32)* @fz2Accum to i8*), i8* bitcast (void (<2 x i32>*, %struct.MinAndMax.0*)* @fMMOutConverter to i8*), i8* bitcast (void (<2 x i32>*, <2 x i32>*)* @fz2Combine to i8*)], section "llvm.metadata"
+
+; Function Attrs: nounwind
+define internal void @aiAccum(i32* nocapture %accum, i32 %val) #0 {
+ %1 = load i32, i32* %accum, align 4, !tbaa !18
+ %2 = add nsw i32 %1, %val
+ store i32 %2, i32* %accum, align 4, !tbaa !18
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @mpyInit(i32* nocapture %accum) #0 {
+ store i32 1, i32* %accum, align 4, !tbaa !18
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @mpyAccum(i32* nocapture %accum, i32 %val) #0 {
+ %1 = load i32, i32* %accum, align 4, !tbaa !18
+ %2 = mul nsw i32 %1, %val
+ store i32 %2, i32* %accum, align 4, !tbaa !18
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @dpAccum(float* nocapture %accum, float %in1, float %in2) #0 {
+ %1 = fmul float %in1, %in2
+ %2 = load float, float* %accum, align 4, !tbaa !22
+ %3 = fadd float %1, %2
+ store float %3, float* %accum, align 4, !tbaa !22
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @dpSum(float* nocapture %accum, float* nocapture %val) #0 {
+ %1 = load float, float* %val, align 4, !tbaa !22
+ %2 = load float, float* %accum, align 4, !tbaa !22
+ %3 = fadd float %1, %2
+ store float %3, float* %accum, align 4, !tbaa !22
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fMMInit(%struct.MinAndMax.0* nocapture %accum) #0 {
+ %1 = bitcast %struct.MinAndMax.0* %accum to i8*
+ tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %1, i8* bitcast (%struct.MinAndMax.0* @fMMInit.r to i8*), i64 16, i32 4, i1 false), !tbaa.struct !24
+ ret void
+}
+
+; Function Attrs: nounwind
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1) #0
+
+; Function Attrs: nounwind
+define internal void @fMMAccumulator(%struct.MinAndMax.0* nocapture %accum, float %in, i32 %x) #0 {
+ %1 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %accum, i64 0, i32 0, i32 0
+ %2 = load float, float* %1, align 4, !tbaa !22
+ %3 = fcmp ogt float %2, %in
+ br i1 %3, label %4, label %6
+
+; <label>:4 ; preds = %0
+ store float %in, float* %1, align 4
+ %5 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %accum, i64 0, i32 0, i32 1
+ store i32 %x, i32* %5, align 4
+ br label %6
+
+; <label>:6 ; preds = %4, %0
+ %7 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %accum, i64 0, i32 1, i32 0
+ %8 = load float, float* %7, align 4, !tbaa !22
+ %9 = fcmp olt float %8, %in
+ br i1 %9, label %10, label %12
+
+; <label>:10 ; preds = %6
+ store float %in, float* %7, align 4
+ %11 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %accum, i64 0, i32 1, i32 1
+ store i32 %x, i32* %11, align 4
+ br label %12
+
+; <label>:12 ; preds = %10, %6
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fMMCombiner(%struct.MinAndMax.0* nocapture %accum, %struct.MinAndMax.0* nocapture %val) #0 {
+ %1 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %val, i64 0, i32 0, i32 0
+ %2 = load float, float* %1, align 4, !tbaa !22
+ %3 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %val, i64 0, i32 0, i32 1
+ %4 = load i32, i32* %3, align 4, !tbaa !18
+ tail call void @fMMAccumulator(%struct.MinAndMax.0* %accum, float %2, i32 %4)
+ %5 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %val, i64 0, i32 1, i32 0
+ %6 = load float, float* %5, align 4, !tbaa !22
+ %7 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %val, i64 0, i32 1, i32 1
+ %8 = load i32, i32* %7, align 4, !tbaa !18
+ tail call void @fMMAccumulator(%struct.MinAndMax.0* %accum, float %6, i32 %8)
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fMMOutConverter(<2 x i32>* nocapture %result, %struct.MinAndMax.0* nocapture %val) #0 {
+ %1 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %val, i64 0, i32 0, i32 1
+ %2 = load i32, i32* %1, align 4, !tbaa !18
+ %3 = load <2 x i32>, <2 x i32>* %result, align 8
+ %4 = insertelement <2 x i32> %3, i32 %2, i64 0
+ store <2 x i32> %4, <2 x i32>* %result, align 8
+ %5 = getelementptr inbounds %struct.MinAndMax.0, %struct.MinAndMax.0* %val, i64 0, i32 1, i32 1
+ %6 = load i32, i32* %5, align 4, !tbaa !18
+ %7 = insertelement <2 x i32> %4, i32 %6, i64 1
+ store <2 x i32> %7, <2 x i32>* %result, align 8
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fzInit(i32* nocapture %accumIdx) #0 {
+ store i32 -1, i32* %accumIdx, align 4, !tbaa !18
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fzAccum(i32* nocapture %accumIdx, i32 %inVal, i32 %x) #0 {
+ %1 = icmp eq i32 %inVal, 0
+ br i1 %1, label %2, label %3
+
+; <label>:2 ; preds = %0
+ store i32 %x, i32* %accumIdx, align 4, !tbaa !18
+ br label %3
+
+; <label>:3 ; preds = %2, %0
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fzCombine(i32* nocapture %accumIdx, i32* nocapture %accumIdx2) #0 {
+ %1 = load i32, i32* %accumIdx2, align 4, !tbaa !18
+ %2 = icmp sgt i32 %1, -1
+ br i1 %2, label %3, label %4
+
+; <label>:3 ; preds = %0
+ store i32 %1, i32* %accumIdx, align 4, !tbaa !18
+ br label %4
+
+; <label>:4 ; preds = %3, %0
+ ret void
+}
+
+; Function Attrs: nounwind readonly
+define internal i1 @fzFound(i32* nocapture %accumIdx) #1 {
+ %1 = load i32, i32* %accumIdx, align 4, !tbaa !18
+ %2 = icmp sgt i32 %1, -1
+ ret i1 %2
+}
+
+; Function Attrs: nounwind
+define internal void @fz2Init(<2 x i32>* nocapture %accum) #0 {
+ store <2 x i32> <i32 -1, i32 -1>, <2 x i32>* %accum, align 8
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fz2Accum(<2 x i32>* nocapture %accum, i32 %inVal, i32 %x, i32 %y) #0 {
+ %1 = icmp eq i32 %inVal, 0
+ br i1 %1, label %2, label %5
+
+; <label>:2 ; preds = %0
+ %3 = insertelement <2 x i32> undef, i32 %x, i64 0
+ %4 = insertelement <2 x i32> %3, i32 %y, i64 1
+ store <2 x i32> %4, <2 x i32>* %accum, align 8
+ br label %5
+
+; <label>:5 ; preds = %2, %0
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @fz2Combine(<2 x i32>* nocapture %accum, <2 x i32>* nocapture %accum2) #0 {
+ %1 = load <2 x i32>, <2 x i32>* %accum2, align 8
+ %2 = extractelement <2 x i32> %1, i64 0
+ %3 = icmp sgt i32 %2, -1
+ br i1 %3, label %4, label %5
+
+; <label>:4 ; preds = %0
+ store <2 x i32> %1, <2 x i32>* %accum, align 8, !tbaa !25
+ br label %5
+
+; <label>:5 ; preds = %4, %0
+ ret void
+}
+
+; Function Attrs: nounwind readonly
+define internal i1 @fz2Found(<2 x i32>* nocapture %accum) #1 {
+ %1 = load <2 x i32>, <2 x i32>* %accum, align 8
+ %2 = extractelement <2 x i32> %1, i64 0
+ %3 = icmp sgt i32 %2, -1
+ ret i1 %3
+}
+
+; Function Attrs: nounwind
+define internal void @hsgAccum([256 x i32]* nocapture %h, i8 %in) #0 {
+ %1 = zext i8 %in to i64
+ %2 = getelementptr inbounds [256 x i32], [256 x i32]* %h, i64 0, i64 %1
+ %3 = load i32, i32* %2, align 4, !tbaa !18
+ %4 = add i32 %3, 1
+ store i32 %4, i32* %2, align 4, !tbaa !18
+ ret void
+}
+
+; Function Attrs: nounwind
+define internal void @hsgCombine([256 x i32]* nocapture %accum, [256 x i32]* nocapture %addend) #0 {
+ br label %2
+
+; <label>:1 ; preds = %2
+ ret void
+
+; <label>:2 ; preds = %2, %0
+ %indvars.iv = phi i64 [ 0, %0 ], [ %indvars.iv.next, %2 ]
+ %3 = getelementptr inbounds [256 x i32], [256 x i32]* %addend, i64 0, i64 %indvars.iv
+ %4 = load i32, i32* %3, align 4, !tbaa !18
+ %5 = getelementptr inbounds [256 x i32], [256 x i32]* %accum, i64 0, i64 %indvars.iv
+ %6 = load i32, i32* %5, align 4, !tbaa !18
+ %7 = add i32 %6, %4
+ store i32 %7, i32* %5, align 4, !tbaa !18
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %exitcond = icmp eq i64 %indvars.iv.next, 256
+ br i1 %exitcond, label %1, label %2
+}
+
+; Function Attrs: nounwind
+define internal void @modeOutConvert(<2 x i32>* nocapture %result, [256 x i32]* nocapture %h) #0 {
+ br label %8
+
+; <label>:1 ; preds = %8
+ %2 = load <2 x i32>, <2 x i32>* %result, align 8
+ %3 = insertelement <2 x i32> %2, i32 %i.0.mode.0, i64 0
+ store <2 x i32> %3, <2 x i32>* %result, align 8
+ %4 = zext i32 %i.0.mode.0 to i64
+ %5 = getelementptr inbounds [256 x i32], [256 x i32]* %h, i64 0, i64 %4
+ %6 = load i32, i32* %5, align 4, !tbaa !18
+ %7 = insertelement <2 x i32> %3, i32 %6, i64 1
+ store <2 x i32> %7, <2 x i32>* %result, align 8
+ ret void
+
+; <label>:8 ; preds = %8, %0
+ %indvars.iv = phi i64 [ 1, %0 ], [ %indvars.iv.next, %8 ]
+ %mode.01 = phi i32 [ 0, %0 ], [ %i.0.mode.0, %8 ]
+ %9 = getelementptr inbounds [256 x i32], [256 x i32]* %h, i64 0, i64 %indvars.iv
+ %10 = load i32, i32* %9, align 4, !tbaa !18
+ %11 = zext i32 %mode.01 to i64
+ %12 = getelementptr inbounds [256 x i32], [256 x i32]* %h, i64 0, i64 %11
+ %13 = load i32, i32* %12, align 4, !tbaa !18
+ %14 = icmp ugt i32 %10, %13
+ %15 = trunc i64 %indvars.iv to i32
+ %i.0.mode.0 = select i1 %14, i32 %15, i32 %mode.01
+ %indvars.iv.next = add nuw nsw i64 %indvars.iv, 1
+ %exitcond = icmp eq i64 %indvars.iv.next, 256
+ br i1 %exitcond, label %1, label %8
+}
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!\23pragma = !{!1, !2}
+!\23rs_export_reduce_new = !{!3, !5, !7, !9, !11, !13, !15, !17}
+
+!0 = !{!"clang version 3.6 "}
+!1 = !{!"version", !"1"}
+!2 = !{!"java_package_name", !"examples"}
+!3 = !{!"addint", !"4", !4}
+!4 = !{!"aiAccum", !"1"}
+!5 = !{!"mpyint", !"4", !6, !"mpyInit"}
+!6 = !{!"mpyAccum", !"1"}
+!7 = !{!"dp", !"4", !8, null, !"dpSum"}
+!8 = !{!"dpAccum", !"1"}
+!9 = !{!"findMinAndMax", !"16", !10, !"fMMInit", !"fMMCombiner", !"fMMOutConverter"}
+!10 = !{!"fMMAccumulator", !"9"}
+!11 = !{!"fz", !"4", !12, !"fzInit", !"fzCombine", null, !"fzFound"}
+!12 = !{!"fzAccum", !"9"}
+!13 = !{!"fz2", !"8", !14, !"fz2Init", !"fz2Combine", null, !"fz2Found"}
+!14 = !{!"fz2Accum", !"25"}
+!15 = !{!"histogram", !"1024", !16, null, !"hsgCombine"}
+!16 = !{!"hsgAccum", !"1"}
+!17 = !{!"mode", !"1024", !16, null, !"hsgCombine", !"modeOutConvert"}
+!18 = !{!19, !19, i64 0}
+!19 = !{!"int", !20, i64 0}
+!20 = !{!"omnipotent char", !21, i64 0}
+!21 = !{!"Simple C/C++ TBAA"}
+!22 = !{!23, !23, i64 0}
+!23 = !{!"float", !20, i64 0}
+!24 = !{i64 0, i64 4, !22, i64 4, i64 4, !18, i64 8, i64 4, !22, i64 12, i64 4, !18}
+!25 = !{!20, !20, i64 0}