oneechanhax/phunix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

passes: updates for LLVM 3.6.1

Browse Source 
This patch also takes the first step to remove backward compatibility
code from the passes.  We only support the in-tree LLVM version.

Change-Id: I7836e524404afba151d1a8bfa539b505e1dbdb8e
This commit is contained in:
David van Moolenbroek 2015-11-11 05:38:27 +01:00 committed by Lionel Sambuc
parent 0ce7112c0b
commit bdb565187c
19 changed files with 102 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
minix/llvm/include/magic_common.h
View File

@ -65,7 +65,7 @@
/* 0=disabled, 1=force no debug output, 2=force no output (for perf. testing).*/ /* 0=disabled, 1=force no debug output, 2=force no output (for perf. testing).*/
#define MAGIC_CHECK_LEVEL 1 #define MAGIC_CHECK_LEVEL 1
/* 2=extra checks, 1=standard checks, 0=no checks (for perf. testing). */ /* 2=extra checks, 1=standard checks, 0=no checks (for perf. testing). */
#define MAGIC_FLATTEN_FUNCTION_ARGS 1 #define MAGIC_FLATTEN_FUNCTION_ARGS 0 /* XXX was 1 but header was not included, seems to break on variadic functions */
#define MAGIC_CHECK_INVARIANTS 1 #define MAGIC_CHECK_INVARIANTS 1
#define MAGIC_SHRINK_TYPE_STR 1 #define MAGIC_SHRINK_TYPE_STR 1
#define MAGIC_MAX_NAME_LEN 64 #define MAGIC_MAX_NAME_LEN 64

2
minix/llvm/passes/Makefile.inc
View File

@ -5,7 +5,7 @@
# #
LLVMPREFIX?=../../../../../obj_llvm.i386/Release+Asserts LLVMPREFIX?=../../../../../obj_llvm.i386/Release+Asserts
CFLAGS += -D__MINIX -D_MINIX_SYSTEM CFLAGS += -D__MINIX -D_MINIX_SYSTEM -DDEBUG_TYPE=\""$PASSNAME"\"
INCLUDES += -I../../include INCLUDES += -I../../include
QUIET=@ QUIET=@

6
minix/llvm/passes/asr/ASRPass.cpp
View File

@ -3,7 +3,7 @@
#include <magic/support/MagicUtil.h> #include <magic/support/MagicUtil.h>
#include <llvm/Transforms/Utils/BasicBlockUtils.h> #include <llvm/Transforms/Utils/BasicBlockUtils.h>
#define MAGIC_IS_MAGIC_FUNC(M, F) (!(F)->getSection().compare(MAGIC_STATIC_FUNCTIONS_SECTION)) #define MAGIC_IS_MAGIC_FUNC(M, F) (!StringRef((F)->getSection()).compare(MAGIC_STATIC_FUNCTIONS_SECTION))
using namespace llvm; using namespace llvm;
@ -392,7 +392,7 @@ bool ASRPass::runOnModule(Module &M) {
* (last found allocation instruction will be at the front), and remove it from the basic block. * (last found allocation instruction will be at the front), and remove it from the basic block.
* */ * */
int hasAddressTaken = 0; int hasAddressTaken = 0;
for (Value::use_iterator UI = allocaInst->use_begin(), E = allocaInst->use_end(); UI != E; ++UI) { for (Value::user_iterator UI = allocaInst->user_begin(), E = allocaInst->user_end(); UI != E; ++UI) {
/* Loop through all the Uses of this allocation function. */ /* Loop through all the Uses of this allocation function. */
@ -555,7 +555,7 @@ bool ASRPass::runOnModule(Module &M) {
assert(ret); assert(ret);
if(stackframe_caller_padding && max_offset > 0) { if(stackframe_caller_padding && max_offset > 0) {
std::vector<User*> Users(F->use_begin(), F->use_end()); std::vector<User*> Users(F->user_begin(), F->user_end());
while (!Users.empty()) { while (!Users.empty()) {
User *U = Users.back(); User *U = Users.back();
Users.pop_back(); Users.pop_back();

30
minix/llvm/passes/include/common/pass_common.h
View File

@ -31,7 +31,7 @@
#define DATA_LAYOUT_TY DataLayout #define DATA_LAYOUT_TY DataLayout
#define ATTRIBUTE_SET_RET_IDX ATTRIBUTE_SET_TY::ReturnIndex #define ATTRIBUTE_SET_RET_IDX ATTRIBUTE_SET_TY::ReturnIndex
#define ATTRIBUTE_SET_FN_IDX ATTRIBUTE_SET_TY::FunctionIndex #define ATTRIBUTE_SET_FN_IDX ATTRIBUTE_SET_TY::FunctionIndex
#include <llvm/DebugInfo.h> #include <llvm/IR/DebugInfo.h>
#if LLVM_VERSION == 32 #if LLVM_VERSION == 32
#include <llvm/DataLayout.h> #include <llvm/DataLayout.h>
#include <llvm/IRBuilder.h> #include <llvm/IRBuilder.h>
@ -145,15 +145,17 @@ class PassUtil {
public: public:
static void writeTypeSymbolic(raw_string_ostream &OS, TYPECONST Type *type, const Module *M); static void writeTypeSymbolic(raw_string_ostream &OS, TYPECONST Type *type, const Module *M);
static const std::string getTypeDescription(TYPECONST Type* type); static const std::string getTypeDescription(TYPECONST Type* type);
static Value *findDbgGlobalDeclare(GlobalVariable *V); static MDNode *findDbgGlobalDeclare(GlobalVariable *V);
static Value *findDbgSubprogramDeclare(const Function *F); static MDNode *findDbgSubprogramDeclare(const Function *F);
static void getDbgLocationInfoRelPath(const std::string &baseDir, const std::string &filename, const std::string &directory, std::string &relPath); static void getDbgLocationInfoRelPath(const std::string &baseDir, const std::string &filename, const std::string &directory, std::string &relPath);
static void getDbgLocationInfo(DIDescriptor &DID, const std::string &baseDir, std::string *filename, std::string *directory, std::string *relPath); static void getDbgLocationInfo(DIDescriptor &DID, const std::string &baseDir, std::string *filename, std::string *directory, std::string *relPath);
static bool getInstrDbgLocationInfo(Instruction *I, const std::string &baseDir, std::string *filename, std::string *directory, std::string *relPath, unsigned int *lineNum, bool expand=true); static bool getInstrDbgLocationInfo(Instruction *I, const std::string &baseDir, std::string *filename, std::string *directory, std::string *relPath, unsigned int *lineNum, bool expand=true);
static unsigned getDbgSubrangeNumElements(const DISubrange &subrange); static unsigned getDbgSubrangeNumElements(const DISubrange &subrange);
static bool isDbgVectorTy(const DIType &type); static bool isDbgVectorTy(const DIType &type);
static DIType getDITypeDerivedFrom(const DIDerivedType &type); static DIType getDITypeDerivedFrom(const DIDerivedType &type);
static DIType getDITypeFromRef(const DITypeRef &ref);
static bool isOpaqueTy(TYPECONST Type *type); static bool isOpaqueTy(TYPECONST Type *type);
static bool isPrimitiveTy(TYPECONST Type *type);
static Constant* getGetElementPtrConstant(Constant *constant, std::vector<Value*> &indexes); static Constant* getGetElementPtrConstant(Constant *constant, std::vector<Value*> &indexes);
static GetElementPtrInst* createGetElementPtrInstruction(Value *ptr, std::vector<Value*> &indexes, const Twine &NameStr="", Instruction *InsertBefore=0); static GetElementPtrInst* createGetElementPtrInstruction(Value *ptr, std::vector<Value*> &indexes, const Twine &NameStr="", Instruction *InsertBefore=0);
static GetElementPtrInst* createGetElementPtrInstruction(Value *ptr, std::vector<Value*> &indexes, const Twine &NameStr="", BasicBlock *InsertAtEnd=0); static GetElementPtrInst* createGetElementPtrInstruction(Value *ptr, std::vector<Value*> &indexes, const Twine &NameStr="", BasicBlock *InsertAtEnd=0);
@ -210,7 +212,7 @@ inline const std::string PassUtil::getTypeDescription(TYPECONST Type* type) {
return string; return string;
} }
inline Value *PassUtil::findDbgGlobalDeclare(GlobalVariable *V) { inline MDNode *PassUtil::findDbgGlobalDeclare(GlobalVariable *V) {
#if LLVM_VERSION >= 30 #if LLVM_VERSION >= 30
const Module *M = V->getParent(); const Module *M = V->getParent();
NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.cu"); NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.cu");
@ -244,7 +246,7 @@ inline Value *PassUtil::findDbgGlobalDeclare(GlobalVariable *V) {
#endif #endif
} }
inline Value *PassUtil::findDbgSubprogramDeclare(const Function *V) { inline MDNode *PassUtil::findDbgSubprogramDeclare(const Function *V) {
#if LLVM_VERSION >= 30 #if LLVM_VERSION >= 30
const Module *M = V->getParent(); const Module *M = V->getParent();
NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.cu"); NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.cu");
@ -428,6 +430,20 @@ inline DIType PassUtil::getDITypeDerivedFrom(const DIDerivedType &type) {
#endif #endif
} }
inline DIType PassUtil::getDITypeFromRef(const DITypeRef &ref) {
static DITypeIdentifierMap TypeIdentifierMap;
static bool TypeMapInitialized = false;
if (!TypeMapInitialized) {
/* TODO: generate the type identifier map only once! */
assert(PassUtil::M && "Set module first!");
if (NamedMDNode *CU_Nodes = PassUtil::M->getNamedMetadata("llvm.dbg.cu")) {
TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
TypeMapInitialized = true;
}
}
return ref.resolve(TypeIdentifierMap);
}
inline bool PassUtil::isOpaqueTy(TYPECONST Type *type) { inline bool PassUtil::isOpaqueTy(TYPECONST Type *type) {
#if LLVM_VERSION >= 30 #if LLVM_VERSION >= 30
return type->isStructTy() && (((TYPECONST StructType*)type)->isOpaque() || type->getNumContainedTypes() == 0); return type->isStructTy() && (((TYPECONST StructType*)type)->isOpaque() || type->getNumContainedTypes() == 0);
@ -436,6 +452,10 @@ inline bool PassUtil::isOpaqueTy(TYPECONST Type *type) {
#endif #endif
} }
inline bool PassUtil::isPrimitiveTy(TYPECONST Type *type) {
return type->isVoidTy() || type->isFloatingPointTy() || type->isLabelTy() || type->isMetadataTy() || type->isX86_MMXTy();
}
inline Constant* PassUtil::getGetElementPtrConstant(Constant *constant, std::vector<Value*> &indexes) { inline Constant* PassUtil::getGetElementPtrConstant(Constant *constant, std::vector<Value*> &indexes) {
#if LLVM_VERSION >= 30 #if LLVM_VERSION >= 30
ArrayRef<Value*> ref(indexes); ArrayRef<Value*> ref(indexes);

1
minix/llvm/passes/include/magic/MagicPass.h
View File

@ -4,7 +4,6 @@
#include <pass.h> #include <pass.h>
#include <magic/magic.h> #include <magic/magic.h>
#include <magic/support/Backports.h>
#include <magic/support/MagicUtil.h> #include <magic/support/MagicUtil.h>
#include <magic/support/SmartType.h> #include <magic/support/SmartType.h>
#include <magic/support/TypeInfo.h> #include <magic/support/TypeInfo.h>

24
minix/llvm/passes/include/magic/support/Backports.h
View File

@ -1,24 +0,0 @@
#ifndef BACKPORTS_H
#define BACKPORTS_H
#include <pass.h>
using namespace llvm;
namespace llvm {
class Backports {
public:
//From DbgInfoPrinter.cpp (LLVM 2.9)
static Value *findDbgGlobalDeclare(GlobalVariable *V);
static Value *findDbgSubprogramDeclare(Function *V);
static const DbgDeclareInst *findDbgDeclare(const Value *V);
//From Local.cpp (LLVM 2.9)
static DbgDeclareInst *FindAllocaDbgDeclare(Value *V);
};
}
#endif

3
minix/llvm/passes/include/magic/support/EDIType.h
View File

@ -37,6 +37,7 @@ class EDIType {
const DIDerivedType& getMember(unsigned i) const; const DIDerivedType& getMember(unsigned i) const;
bool isUnionOrStructTy(bool isStruct=true, bool isUnion=true) const; bool isUnionOrStructTy(bool isStruct=true, bool isUnion=true) const;
bool hasInnerPointers() const; bool hasInnerPointers() const;
unsigned int getTypeArrayNum() const;
DIArray getTypeArray() const; DIArray getTypeArray() const;
const EDIType* getTopStructType(unsigned index) const; const EDIType* getTopStructType(unsigned index) const;
@ -262,7 +263,7 @@ inline bool EDIType::isPointerTy() const {
} }
inline bool EDIType::isOpaqueTy() const { inline bool EDIType::isOpaqueTy() const {
return (isCompositeType() && getTypeArray().getNumElements() == 0); return (isCompositeType() && getTypeArrayNum() == 0);
} }
inline void EDIType::writeTypeSymbolic(raw_string_ostream &OS, TYPECONST Type *type, const Module *M) { inline void EDIType::writeTypeSymbolic(raw_string_ostream &OS, TYPECONST Type *type, const Module *M) {

6
minix/llvm/passes/include/magic/support/MagicDebugFunction.h
View File

@ -122,7 +122,7 @@ inline void MagicDebugFunction::fixCalls(Module &M, const std::string &baseDir)
bool ret = MagicDebugFunction::inlineHookCalls(debugFunction, hooks, flags, argsMapping, trailingArgs); bool ret = MagicDebugFunction::inlineHookCalls(debugFunction, hooks, flags, argsMapping, trailingArgs);
assert(ret && "Unable to inline the calls to the hook functions."); assert(ret && "Unable to inline the calls to the hook functions.");
std::vector<User*> Users(function->use_begin(), function->use_end()); std::vector<User*> Users(function->user_begin(), function->user_end());
std::vector<Value*> EqPointers; std::vector<Value*> EqPointers;
while (!Users.empty()) { while (!Users.empty()) {
User *U = Users.back(); User *U = Users.back();
@ -153,11 +153,11 @@ inline void MagicDebugFunction::fixCalls(Module &M, const std::string &baseDir)
MagicUtil::replaceCallInst(I, newInst, 1); MagicUtil::replaceCallInst(I, newInst, 1);
} }
} else if (GlobalValue * GV = dyn_cast<GlobalValue>(U)) { } else if (GlobalValue * GV = dyn_cast<GlobalValue>(U)) {
Users.insert(Users.end(), GV->use_begin(), GV->use_end()); Users.insert(Users.end(), GV->user_begin(), GV->user_end());
EqPointers.push_back(GV); EqPointers.push_back(GV);
} else if (ConstantExpr * CE = dyn_cast<ConstantExpr>(U)) { } else if (ConstantExpr * CE = dyn_cast<ConstantExpr>(U)) {
if (CE->isCast()) { if (CE->isCast()) {
Users.insert(Users.end(), CE->use_begin(), CE->use_end()); Users.insert(Users.end(), CE->user_begin(), CE->user_end());
EqPointers.push_back(CE); EqPointers.push_back(CE);
} }
} }

2
minix/llvm/passes/include/magic/support/MagicMmapCtlFunction.h
View File

@ -88,7 +88,7 @@ inline Function* MagicMmapCtlFunction::getFunction() const {
/* This assumes in-band metadata of 1 page before every mmapped region. */ /* This assumes in-band metadata of 1 page before every mmapped region. */
inline void MagicMmapCtlFunction::fixCalls(Module &M, Function *magicGetPageSizeFunc) const { inline void MagicMmapCtlFunction::fixCalls(Module &M, Function *magicGetPageSizeFunc) const {
std::vector<User*> Users(function->use_begin(), function->use_end()); std::vector<User*> Users(function->user_begin(), function->user_end());
while (!Users.empty()) { while (!Users.empty()) {
User *U = Users.back(); User *U = Users.back();
Users.pop_back(); Users.pop_back();

3
minix/llvm/passes/include/magic/support/SmartType.h
View File

@ -2,7 +2,6 @@
#define SMART_TYPE_H #define SMART_TYPE_H
#include <pass.h> #include <pass.h>
#include <magic/support/Backports.h>
#include <magic/support/EDIType.h> #include <magic/support/EDIType.h>
#include <magic/support/TypeUtil.h> #include <magic/support/TypeUtil.h>
#include <magic/support/BitFieldAggregation.h> #include <magic/support/BitFieldAggregation.h>
@ -144,7 +143,7 @@ inline bool SmartType::isPrimitiveTy() const {
assert(type->isStructTy()); assert(type->isStructTy());
return true; return true;
} }
return isTy(type->isPrimitiveType(), aEDIType.isPrimitiveType(), "isPrimitiveTy"); return isTy(PassUtil::isPrimitiveTy(type), aEDIType.isPrimitiveType(), "isPrimitiveTy");
} }
inline bool SmartType::isAggregateType() const { inline bool SmartType::isAggregateType() const {

5
minix/llvm/passes/include/pass.h
View File

@ -14,12 +14,11 @@
#include <llvm/ADT/Statistic.h> #include <llvm/ADT/Statistic.h>
#include <llvm/Support/Regex.h> #include <llvm/Support/Regex.h>
#include <llvm/Assembly/Writer.h> #include <llvm/IR/CallSite.h>
#include <llvm/Support/CallSite.h>
#include <llvm/Support/CommandLine.h> #include <llvm/Support/CommandLine.h>
#include <llvm/Analysis/LoopInfo.h> #include <llvm/Analysis/LoopInfo.h>
#include <llvm/Support/InstIterator.h> #include <llvm/IR/InstIterator.h>
#include <llvm/Transforms/Utils/Local.h> #include <llvm/Transforms/Utils/Local.h>
#include <llvm/Transforms/Scalar.h> #include <llvm/Transforms/Scalar.h>

5
minix/llvm/passes/include/sectionify/SectionifyPass.h
View File

@ -2,7 +2,6 @@
#define SECTIONIFY_PASS_H #define SECTIONIFY_PASS_H
#define DEBUG_TYPE "sectionify"
#include <pass.h> #include <pass.h>
using namespace llvm; using namespace llvm;
@ -25,8 +24,8 @@ class SectionifyPass : public ModulePass {
std::vector<Regex*> dataRegexList; std::vector<Regex*> dataRegexList;
std::string moduleName; std::string moduleName;
bool sectionifyFromRegex(GlobalValue *value, Regex *regex, std::string &section); bool sectionifyFromRegex(GlobalObject *value, Regex *regex, std::string &section);
bool sectionify(GlobalValue *value, std::vector<Regex*> &regexList, std::map<Regex*, std::string> &regexMap); bool sectionify(GlobalObject *value, std::vector<Regex*> &regexList, std::map<Regex*, std::string> &regexMap);
void parseAndInitRegexMap(cl::list<std::string> &stringListOpt, std::vector<Regex*> &regexList, std::map<Regex*, std::string> &regexMap, std::string regexType); void parseAndInitRegexMap(cl::list<std::string> &stringListOpt, std::vector<Regex*> &regexList, std::map<Regex*, std::string> &regexMap, std::string regexType);
bool initRegexMap(std::map<Regex*, std::string> &regexMap, std::vector<Regex*> &regexList, std::map<std::string, std::string> &stringMap, std::vector<std::string> &stringList, std::string regexType); bool initRegexMap(std::map<Regex*, std::string> &regexMap, std::vector<Regex*> &regexList, std::map<std::string, std::string> &stringMap, std::vector<std::string> &stringList, std::string regexType);
bool parseStringMapOpt(std::map<std::string, std::string> &map, std::vector<std::string> &keyList, std::vector<std::string> &stringList); bool parseStringMapOpt(std::map<std::string, std::string> &map, std::vector<std::string> &keyList, std::vector<std::string> &stringList);

12
minix/llvm/passes/magic/MagicPass.cpp
View File

@ -977,7 +977,7 @@ bool MagicPass::runOnModule(Module &M) {
while(!magicMemFunctions.empty()) { while(!magicMemFunctions.empty()) {
MagicMemFunction magicMemFunction = magicMemFunctions.front(); MagicMemFunction magicMemFunction = magicMemFunctions.front();
magicMemFunctions.erase(magicMemFunctions.begin()); magicMemFunctions.erase(magicMemFunctions.begin());
std::vector<User*> Users(magicMemFunction.getFunction()->use_begin(), magicMemFunction.getFunction()->use_end()); std::vector<User*> Users(magicMemFunction.getFunction()->user_begin(), magicMemFunction.getFunction()->user_end());
std::vector<Value*> EqPointers; std::vector<Value*> EqPointers;
while (!Users.empty()) { while (!Users.empty()) {
int annotation; int annotation;
@ -1139,11 +1139,11 @@ bool MagicPass::runOnModule(Module &M) {
} }
} }
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(U)) { } else if (GlobalValue *GV = dyn_cast<GlobalValue>(U)) {
Users.insert(Users.end(), GV->use_begin(), GV->use_end()); Users.insert(Users.end(), GV->user_begin(), GV->user_end());
EqPointers.push_back(GV); EqPointers.push_back(GV);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) { } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U)) {
if (CE->isCast()) { if (CE->isCast()) {
Users.insert(Users.end(), CE->use_begin(), CE->use_end()); Users.insert(Users.end(), CE->user_begin(), CE->user_end());
EqPointers.push_back(CE); EqPointers.push_back(CE);
} }
} }
@ -1962,7 +1962,7 @@ void MagicPass::findPointerVariables(Function* function, Value *value, std::vect
DEBUG_VALUE(" ************************************************************ findPointerVariables: Unknown value: ", value); DEBUG_VALUE(" ************************************************************ findPointerVariables: Unknown value: ", value);
RETURN_IF(true); RETURN_IF(true);
} }
for (Value::use_iterator i = value->use_begin(), e = value->use_end(); i != e; ++i) { for (Value::user_iterator i = value->user_begin(), e = value->user_end(); i != e; ++i) {
User *user = *i; User *user = *i;
Instruction *instruction = dyn_cast<Instruction>(user); Instruction *instruction = dyn_cast<Instruction>(user);
if(!instruction || instruction->getParent()->getParent() != function) { if(!instruction || instruction->getParent()->getParent() != function) {
@ -2789,7 +2789,7 @@ void MagicPass::fillStackInstrumentedFunctions(std::vector<Function*> &stackIntr
} }
} }
stackIntrumentedFuncs.push_back(deepestLLFunction); stackIntrumentedFuncs.push_back(deepestLLFunction);
for (Value::use_iterator i = deepestLLFunction->use_begin(), e = deepestLLFunction->use_end(); i != e; ++i) { for (Value::user_iterator i = deepestLLFunction->user_begin(), e = deepestLLFunction->user_end(); i != e; ++i) {
User *user = *i; User *user = *i;
if(Instruction *I = dyn_cast<Instruction>(user)) { if(Instruction *I = dyn_cast<Instruction>(user)) {
fillStackInstrumentedFunctions(stackIntrumentedFuncs, I->getParent()->getParent()); fillStackInstrumentedFunctions(stackIntrumentedFuncs, I->getParent()->getParent());
@ -2944,7 +2944,7 @@ bool MagicPass::isMagicGV(Module &M, GlobalVariable *GV)
if (GV->isThreadLocal() && (GV->getName().startswith(MAGIC_PREFIX_STR) || GV->getName().startswith("rcu"))) { if (GV->isThreadLocal() && (GV->getName().startswith(MAGIC_PREFIX_STR) || GV->getName().startswith("rcu"))) {
return true; return true;
} }
if (!GV->getSection().compare(MAGIC_LLVM_METADATA_SECTION)) { if (!StringRef(GV->getSection()).compare(MAGIC_LLVM_METADATA_SECTION)) {
return true; return true;
} }
if (GV->getName().startswith("__start") || GV->getName().startswith("__stop") || GV->getName().startswith("llvm.")) { if (GV->getName().startswith("__start") || GV->getName().startswith("__stop") || GV->getName().startswith("llvm.")) {

2
minix/llvm/passes/magic/Makefile
View File

@ -1,6 +1,6 @@
PASSNAME = magic PASSNAME = magic
OBJS = support/Backports.o support/EDIType.o support/TypeUtil.o support/BitFieldAggregation.o support/SmartType.o support/VariableRefs.o support/MagicUtil.o MagicPass.o OBJS = support/EDIType.o support/TypeUtil.o support/BitFieldAggregation.o support/SmartType.o support/VariableRefs.o support/MagicUtil.o MagicPass.o
HEADERS = $(wildcard ../include/magic/support/*.h) HEADERS = $(wildcard ../include/magic/support/*.h)
include ../Makefile.inc include ../Makefile.inc

172
minix/llvm/passes/magic/support/Backports.cpp
View File

@ -1,172 +0,0 @@
#include <pass.h>
#include <magic/support/Backports.h>
#include <magic/support/EDIType.h>
#include <magic/support/SmartType.h>
using namespace llvm;
namespace llvm {
//===----------------------------------------------------------------------===//
// Public static methods
//===----------------------------------------------------------------------===//
/// Find the debug info descriptor corresponding to this global variable.
Value *Backports::findDbgGlobalDeclare(GlobalVariable *V) {
return PassUtil::findDbgGlobalDeclare(V);
}
/// Find the debug info descriptor corresponding to this function.
Value *Backports::findDbgSubprogramDeclare(Function *V) {
return PassUtil::findDbgSubprogramDeclare(V);
}
/// Finds the llvm.dbg.declare intrinsic corresponding to this value if any.
/// It looks through pointer casts too.
const DbgDeclareInst *Backports::findDbgDeclare(const Value *V) {
V = V->stripPointerCasts();
if (!isa<Instruction>(V) && !isa<Argument>(V))
return 0;
const Function *F = NULL;
if (const Instruction *I = dyn_cast<Instruction>(V))
F = I->getParent()->getParent();
else if (const Argument *A = dyn_cast<Argument>(V))
F = A->getParent();
for (Function::const_iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI)
for (BasicBlock::const_iterator BI = (*FI).begin(), BE = (*FI).end();
BI != BE; ++BI)
if (const DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI))
if (DDI->getAddress() == V)
return DDI;
return 0;
}
/// FindAllocaDbgDeclare - Finds the llvm.dbg.declare intrinsic describing the
/// alloca 'V', if any.
DbgDeclareInst *Backports::FindAllocaDbgDeclare(Value *V) {
#if LLVM_VERSION >= 33
if (MDNode *DebugNode = MDNode::getIfExists(V->getContext(), V))
for (Value::use_iterator UI = DebugNode->use_begin(),
E = DebugNode->use_end(); UI != E; ++UI)
if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(*UI))
return DDI;
return 0;
#else
///
/// There is an unfixed bug (http://llvm.org/bugs/show_bug.cgi?id=10887)
/// that drops debug information references for local variables at linking time.
/// This is way the method FindAllocaDbgDeclare() will always return NULL and
/// we need to resort to some ugly workaround.
///
AllocaInst *AI = dyn_cast<AllocaInst>(V);
if(!AI) {
return NULL;
}
BasicBlock *varParent = AI->getParent();
Function *varFunc = varParent->getParent();
if(!AI->hasName() || !AI->getName().compare("retval")) {
return NULL;
}
StringRef varName = AI->getName();
bool isInlinedVar = false;
bool isScopedVar = false;
DIType aDIType, aAddrDIType, tmpDIType;
DbgDeclareInst *DDI = NULL, *addrDDI = NULL;
SmallVector< StringRef, 8 > vector;
varName.split(vector, ".");
if(vector.size() >= 2 && vector[1][0] == 'i') {
isInlinedVar = true;
varName = vector[0];
}
if(!isInlinedVar) {
//for non-inlined variables we have to look in the first bb first.
for(BasicBlock::iterator i=varParent->begin(), e=varParent->end();i!=e;i++) {
if(DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(i)) {
MDNode *node = DI->getVariable();
assert(node);
DIVariable DIV(node);
if(!DIV.getName().compare(varName)) {
aDIType = DIV.getType();
DDI = DI;
break;
}
StringRef addrVarName(DIV.getName().str() + "_addr");
if(!addrVarName.compare(varName)) {
aAddrDIType = DIV.getType();
addrDDI = DI;
break;
}
}
}
if(!DDI && !addrDDI) {
//not found? probably a scoped variable, look anywhere else.
isScopedVar = true;
}
}
if(isInlinedVar || isScopedVar) {
//for inlined/scoped variables we have to look everywhere in the function and name clashing could also occur.
bool isDuplicate = false;
for (inst_iterator it = inst_begin(varFunc), et = inst_end(varFunc); it != et; ++it) {
Instruction *inst = &(*it);
if(DbgDeclareInst *DI = dyn_cast<DbgDeclareInst>(inst)) {
MDNode *node = DI->getVariable();
assert(node);
DIVariable DIV(node);
StringRef addrVarName(DIV.getName().str() + "_addr");
if(!DIV.getName().compare(varName) || !addrVarName.compare(varName)) {
tmpDIType = DIV.getType();
EDIType tmpEDIType(tmpDIType);
if(!SmartType::isTypeConsistent(AI->getAllocatedType(), &tmpEDIType)) {
continue;
}
bool skipDIType = false;
if(DDI) {
EDIType aEDIType(aDIType);
skipDIType = true;
if(!aEDIType.equals(&tmpEDIType)) {
isDuplicate = true;
}
}
if(addrDDI) {
EDIType aAddrEDIType(aAddrDIType);
skipDIType = true;
if(!aAddrEDIType.equals(&tmpEDIType)) {
isDuplicate = true;
}
}
if(!skipDIType && !DIV.getName().compare(varName)) {
aDIType = tmpDIType;
DDI = DI;
continue;
}
if(!skipDIType && !addrVarName.compare(varName)) {
aAddrDIType = tmpDIType;
addrDDI = DI;
continue;
}
}
}
}
if(isDuplicate) {
//name clashing problem with inline/scoped variables, pretend nothing was found
DDI = NULL;
addrDDI = NULL;
}
}
if(!DDI && !addrDDI) {
return (DbgDeclareInst*)-1;
}
assert((DDI && !addrDDI) || (!DDI && addrDDI));
DDI = DDI ? DDI : addrDDI;
return DDI;
#endif
}
}

34
minix/llvm/passes/magic/support/EDIType.cpp
View File

@ -56,11 +56,16 @@ const EDIType& EDIType::getContainedType(unsigned i, bool norm) const {
} }
return subType; return subType;
} }
if (isFunctionTy()) {
DITypeArray DTA = ((const DISubroutineType)aDIType).getTypeArray();
subType = PassUtil::getDITypeFromRef(DTA.getElement(i));
} else {
DIArray aDIArray = getTypeArray(); DIArray aDIArray = getTypeArray();
unsigned numContainedTypes = aDIArray.getNumElements(); unsigned numContainedTypes = aDIArray.getNumElements();
assert(i < numContainedTypes); assert(i < numContainedTypes);
EDIType tmpType((const DIType) aDIArray.getElement(i), norm); EDIType tmpType((const DIType) aDIArray.getElement(i), norm);
subType = tmpType; subType = tmpType;
}
return subType; return subType;
} }
@ -72,9 +77,7 @@ unsigned EDIType::getNumContainedTypes() const {
if(isDerivedType() || isArrayOrVectorTy) { if(isDerivedType() || isArrayOrVectorTy) {
return 1; return 1;
} }
DIArray aDIArray = getTypeArray(); return getTypeArrayNum();
unsigned numContainedTypes = aDIArray.getNumElements();
return numContainedTypes;
} }
const DIDerivedType& EDIType::getMember(unsigned i) const { const DIDerivedType& EDIType::getMember(unsigned i) const {
@ -128,11 +131,23 @@ bool EDIType::hasInnerPointers() const {
return false; return false;
} }
unsigned int EDIType::getTypeArrayNum() const {
EDIType_assert(isCompositeType());
/* This function is used from isOpaqueTy(), so do not use isFunctionTy() here. */
if (getTag() == dwarf::DW_TAG_subroutine_type) {
DITypeArray DTA = ((const DISubroutineType)aDIType).getTypeArray();
return DTA.getNumElements();
} else {
return getTypeArray().getNumElements();
}
}
DIArray EDIType::getTypeArray() const { DIArray EDIType::getTypeArray() const {
static std::set<std::string> nonOpaqueEmptyTypes; static std::set<std::string> nonOpaqueEmptyTypes;
static std::set<std::string>::iterator nonOpaqueEmptyTypesIt; static std::set<std::string>::iterator nonOpaqueEmptyTypesIt;
EDIType_assert(isCompositeType()); EDIType_assert(isCompositeType());
DIArray aDIArray = ((const DICompositeType)aDIType).getTypeArray(); EDIType_assert(getTag() != dwarf::DW_TAG_subroutine_type); /* as above, no isFunctionTy() */
DIArray aDIArray = ((const DICompositeType)aDIType).getElements();
if(aDIArray.getNumElements() == 0 && checkOpaqueTypes && myNames.size() > 0) { if(aDIArray.getNumElements() == 0 && checkOpaqueTypes && myNames.size() > 0) {
const EDIType *aType = NULL; const EDIType *aType = NULL;
std::string name; std::string name;
@ -144,7 +159,7 @@ DIArray EDIType::getTypeArray() const {
} }
} }
if(aType) { if(aType) {
aDIArray = ((const DICompositeType *)aType->getDIType())->getTypeArray(); aDIArray = ((const DICompositeType *)aType->getDIType())->getElements();
nonOpaqueEmptyTypesIt = nonOpaqueEmptyTypes.find(name); nonOpaqueEmptyTypesIt = nonOpaqueEmptyTypes.find(name);
if(nonOpaqueEmptyTypesIt == nonOpaqueEmptyTypes.end()) { if(nonOpaqueEmptyTypesIt == nonOpaqueEmptyTypes.end()) {
EDITypeLog("Found a non-opaque composite type with 0 members! Name is: " << name); EDITypeLog("Found a non-opaque composite type with 0 members! Name is: " << name);
@ -390,9 +405,8 @@ bool EDIType::equals(const EDIType *other) const {
std::string EDIType::lookupTypedefName(std::string &typedefName) { std::string EDIType::lookupTypedefName(std::string &typedefName) {
static std::string noName; static std::string noName;
for (DebugInfoFinder::iterator I = DIFinder.type_begin(), for (const DIType aDITypeIt : DIFinder.types()) {
E = DIFinder.type_end(); I != E; ++I) { DIType aDIType(aDITypeIt);
DIType aDIType(*I);
if(aDIType.getTag() == dwarf::DW_TAG_typedef && aDIType.getName().compare(typedefName)) { if(aDIType.getTag() == dwarf::DW_TAG_typedef && aDIType.getName().compare(typedefName)) {
while(aDIType.getTag() == dwarf::DW_TAG_typedef) { while(aDIType.getTag() == dwarf::DW_TAG_typedef) {
aDIType = PassUtil::getDITypeDerivedFrom((const DIDerivedType)aDIType); aDIType = PassUtil::getDITypeDerivedFrom((const DIDerivedType)aDIType);
@ -426,9 +440,7 @@ std::string EDIType::lookupUnionMemberName(TYPECONST Type* type) {
const EDIType* EDIType::getStructEDITypeByName(std::string &typeName) { const EDIType* EDIType::getStructEDITypeByName(std::string &typeName) {
static EDIType aEDIType; static EDIType aEDIType;
assert(module); assert(module);
for (DebugInfoFinder::iterator I = DIFinder.type_begin(), for (const DIType aDIType : DIFinder.types()) {
E = DIFinder.type_end(); I != E; ++I) {
const DIType aDIType(*I);
//skip zero-element stuct types, necessary to avoid infinite recursion during opaque type lookup //skip zero-element stuct types, necessary to avoid infinite recursion during opaque type lookup
//xxx opaque type lookup should not be necessary but is there a bug in the frontend that leaves certain concrete types unnecessarily opaque? //xxx opaque type lookup should not be necessary but is there a bug in the frontend that leaves certain concrete types unnecessarily opaque?
const EDIType tmpEDIType(aDIType, NORMALIZE, DO_NOT_CHECK_OPAQUE_TYPES); const EDIType tmpEDIType(aDIType, NORMALIZE, DO_NOT_CHECK_OPAQUE_TYPES);

32
minix/llvm/passes/magic/support/MagicUtil.cpp
View File

@ -27,9 +27,9 @@ unsigned getModuleHash(DIDescriptor DID, const std::string &baseDir, StringRef e
StringRef MagicUtil::getGVSourceName(Module &M, GlobalVariable *GV, DIGlobalVariable **DIGVP, const std::string &baseDir) { StringRef MagicUtil::getGVSourceName(Module &M, GlobalVariable *GV, DIGlobalVariable **DIGVP, const std::string &baseDir) {
static DIGlobalVariable Var; static DIGlobalVariable Var;
Value *DIGV = Backports::findDbgGlobalDeclare(GV); MDNode *DIGV = PassUtil::findDbgGlobalDeclare(GV);
if(DIGV) { if(DIGV) {
Var = DIGlobalVariable(cast<MDNode>(DIGV)); Var = DIGlobalVariable(DIGV);
if(DIGVP) *DIGVP = &Var; if(DIGVP) *DIGVP = &Var;
if(GV->getLinkage() == GlobalValue::InternalLinkage){ if(GV->getLinkage() == GlobalValue::InternalLinkage){
/* static variable */ /* static variable */
@ -50,9 +50,9 @@ StringRef MagicUtil::getGVSourceName(Module &M, GlobalVariable *GV, DIGlobalVari
Module::GlobalListType &globalList = M.getGlobalList(); Module::GlobalListType &globalList = M.getGlobalList();
for (Module::global_iterator it = globalList.begin(); it != globalList.end(); ++it) { for (Module::global_iterator it = globalList.begin(); it != globalList.end(); ++it) {
GlobalVariable *OtherGV = &(*it); GlobalVariable *OtherGV = &(*it);
Value *OtherDIGV = Backports::findDbgGlobalDeclare(OtherGV); MDNode *OtherDIGV = PassUtil::findDbgGlobalDeclare(OtherGV);
if(OtherDIGV) { if(OtherDIGV) {
DIGlobalVariable OtherVar(cast<MDNode>(OtherDIGV)); DIGlobalVariable OtherVar(OtherDIGV);
DIScope otherScope = OtherVar.getContext(); DIScope otherScope = OtherVar.getContext();
if(otherScope.isLexicalBlock()){ if(otherScope.isLexicalBlock()){
@ -101,7 +101,7 @@ StringRef MagicUtil::getGVSourceName(Module &M, GlobalVariable *GV, DIGlobalVari
StringRef MagicUtil::getLVSourceName(Module &M, AllocaInst *V, DIVariable **DIVP) { StringRef MagicUtil::getLVSourceName(Module &M, AllocaInst *V, DIVariable **DIVP) {
static DIVariable Var; static DIVariable Var;
const DbgDeclareInst *DDI = Backports::FindAllocaDbgDeclare(V); const DbgDeclareInst *DDI = FindAllocaDbgDeclare(V);
if(DDI && DDI != (const DbgDeclareInst *) -1){ if(DDI && DDI != (const DbgDeclareInst *) -1){
Var = DIVariable(cast<MDNode>(DDI->getVariable())); Var = DIVariable(cast<MDNode>(DDI->getVariable()));
if(DIVP) *DIVP = &Var; if(DIVP) *DIVP = &Var;
@ -136,9 +136,9 @@ StringRef MagicUtil::getLVSourceName(Module &M, AllocaInst *V, DIVariable **DIVP
StringRef MagicUtil::getFunctionSourceName(Module &M, Function *F, DISubprogram **DISP, const std::string &baseDir) { StringRef MagicUtil::getFunctionSourceName(Module &M, Function *F, DISubprogram **DISP, const std::string &baseDir) {
static DISubprogram Func; static DISubprogram Func;
Value *DIF = Backports::findDbgSubprogramDeclare(F); MDNode *DIF = PassUtil::findDbgSubprogramDeclare(F);
if(DIF) { if(DIF) {
Func = DISubprogram(cast<MDNode>(DIF)); Func = DISubprogram(DIF);
if(DISP) *DISP = &Func; if(DISP) *DISP = &Func;
if(F->getLinkage() == GlobalValue::InternalLinkage){ if(F->getLinkage() == GlobalValue::InternalLinkage){
std::stringstream stm; std::stringstream stm;
@ -709,9 +709,8 @@ bool MagicUtil::hasAddressTaken(const GlobalValue *GV, bool includeMembers) {
std::vector<const User*> sourceUsers; std::vector<const User*> sourceUsers;
sourceUsers.push_back(GV); sourceUsers.push_back(GV);
if(includeMembers && isa<GlobalVariable>(GV)) { if(includeMembers && isa<GlobalVariable>(GV)) {
for (Value::const_use_iterator UI = GV->use_begin(), E = GV->use_end(); for (const Use &UI : GV->uses()) {
UI != E; ++UI) { const User *U = UI.getUser();
const User *U = *UI;
const ConstantExpr *constantExpr = dyn_cast<ConstantExpr>(U); const ConstantExpr *constantExpr = dyn_cast<ConstantExpr>(U);
if(isa<GetElementPtrInst>(U)) { if(isa<GetElementPtrInst>(U)) {
sourceUsers.push_back(U); sourceUsers.push_back(U);
@ -723,16 +722,15 @@ bool MagicUtil::hasAddressTaken(const GlobalValue *GV, bool includeMembers) {
} }
for(unsigned i=0;i<sourceUsers.size();i++) { for(unsigned i=0;i<sourceUsers.size();i++) {
for (Value::const_use_iterator UI = sourceUsers[i]->use_begin(), E = sourceUsers[i]->use_end(); for (const Use &UI : sourceUsers[i]->uses()) {
UI != E; ++UI) { const User *U = UI.getUser();
const User *U = *UI;
if (const StoreInst *SI = dyn_cast<StoreInst>(U)) { if (const StoreInst *SI = dyn_cast<StoreInst>(U)) {
if (SI->getOperand(0) == sourceUsers[i] || SI->isVolatile()) if (SI->getOperand(0) == sourceUsers[i] || SI->isVolatile())
return true; // Storing addr of sourceUsers[i]. return true; // Storing addr of sourceUsers[i].
} else if (isa<InvokeInst>(U) || isa<CallInst>(U)) { } else if (isa<InvokeInst>(U) || isa<CallInst>(U)) {
// Make sure we are calling the function, not passing the address. // Make sure we are calling the function, not passing the address.
ImmutableCallSite CS(cast<Instruction>(U)); ImmutableCallSite CS(cast<Instruction>(U));
if (!CS.isCallee(UI)) if (!CS.isCallee(&UI))
return true; return true;
} else if (const LoadInst *LI = dyn_cast<LoadInst>(U)) { } else if (const LoadInst *LI = dyn_cast<LoadInst>(U)) {
if (LI->isVolatile()) if (LI->isVolatile())
@ -764,7 +762,7 @@ bool MagicUtil::lookupValueSet(const GlobalVariable *GV, std::vector<int> &value
GV->removeDeadConstantUsers(); GV->removeDeadConstantUsers();
std::set<int> set; std::set<int> set;
for (Value::const_use_iterator UI = GV->use_begin(), E = GV->use_end(); for (Value::const_user_iterator UI = GV->user_begin(), E = GV->user_end();
UI != E; ++UI) { UI != E; ++UI) {
const User *U = *UI; const User *U = *UI;
if (const StoreInst *SI = dyn_cast<StoreInst>(U)) { if (const StoreInst *SI = dyn_cast<StoreInst>(U)) {
@ -811,7 +809,7 @@ Value* MagicUtil::getStringOwner(GlobalVariable *GV)
std::vector<User*> sourceUsers; std::vector<User*> sourceUsers;
sourceUsers.push_back(GV); sourceUsers.push_back(GV);
for (Value::use_iterator UI = GV->use_begin(), E = GV->use_end(); for (Value::user_iterator UI = GV->user_begin(), E = GV->user_end();
UI != E; ++UI) { UI != E; ++UI) {
User *U = *UI; User *U = *UI;
ConstantExpr *constantExpr = dyn_cast<ConstantExpr>(U); ConstantExpr *constantExpr = dyn_cast<ConstantExpr>(U);
@ -825,7 +823,7 @@ Value* MagicUtil::getStringOwner(GlobalVariable *GV)
Value *stringOwner = NULL; Value *stringOwner = NULL;
for(unsigned i=0;i<sourceUsers.size();i++) { for(unsigned i=0;i<sourceUsers.size();i++) {
for (Value::use_iterator UI = sourceUsers[i]->use_begin(), E = sourceUsers[i]->use_end(); for (Value::user_iterator UI = sourceUsers[i]->user_begin(), E = sourceUsers[i]->user_end();
UI != E; ++UI) { UI != E; ++UI) {
User *U = *UI; User *U = *UI;
Value *V = U; Value *V = U;

15
minix/llvm/passes/magic/support/SmartType.cpp
View File

@ -1,3 +1,4 @@
#include <magic_common.h>
#include <magic/support/SmartType.h> #include <magic/support/SmartType.h>
#include <limits.h> #include <limits.h>
@ -341,12 +342,12 @@ const SmartType* SmartType::getSmartTypeFromGV(Module &M, GlobalVariable *GV, DI
if(GV->getName().startswith(".str")) { if(GV->getName().startswith(".str")) {
return NULL; return NULL;
} }
Value *DIGV = Backports::findDbgGlobalDeclare(GV); MDNode *DIGV = PassUtil::findDbgGlobalDeclare(GV);
if (!DIGV) { if (!DIGV) {
return NULL; return NULL;
} }
DIGlobalVariable Var(cast<MDNode>(DIGV)); DIGlobalVariable Var(DIGV);
DIType aDIType = Var.getType(); DIType aDIType = PassUtil::getDITypeFromRef(Var.getType());
const SmartType* retSmartType = new SmartType(GV->getType()->getElementType(), &aDIType); const SmartType* retSmartType = new SmartType(GV->getType()->getElementType(), &aDIType);
if(DIG) { if(DIG) {
*DIG = Var; *DIG = Var;
@ -355,7 +356,7 @@ const SmartType* SmartType::getSmartTypeFromGV(Module &M, GlobalVariable *GV, DI
} }
const SmartType* SmartType::getSmartTypeFromLV(Module &M, AllocaInst *AI, DIVariable *DIV) { const SmartType* SmartType::getSmartTypeFromLV(Module &M, AllocaInst *AI, DIVariable *DIV) {
const DbgDeclareInst *DDI = Backports::FindAllocaDbgDeclare(AI); const DbgDeclareInst *DDI = FindAllocaDbgDeclare(AI);
if (!DDI) { if (!DDI) {
return NULL; return NULL;
} }
@ -363,7 +364,7 @@ const SmartType* SmartType::getSmartTypeFromLV(Module &M, AllocaInst *AI, DIVari
return (const SmartType*)-1; return (const SmartType*)-1;
} }
DIVariable Var(cast<MDNode>(DDI->getVariable())); DIVariable Var(cast<MDNode>(DDI->getVariable()));
DIType aDIType = Var.getType(); DIType aDIType = PassUtil::getDITypeFromRef(Var.getType());
if(DIV) { if(DIV) {
*DIV = Var; *DIV = Var;
} }
@ -372,11 +373,11 @@ const SmartType* SmartType::getSmartTypeFromLV(Module &M, AllocaInst *AI, DIVari
} }
const SmartType* SmartType::getSmartTypeFromFunction(Module &M, Function *F, DISubprogram *DIS) { const SmartType* SmartType::getSmartTypeFromFunction(Module &M, Function *F, DISubprogram *DIS) {
Value *DIF = Backports::findDbgSubprogramDeclare(F); MDNode *DIF = PassUtil::findDbgSubprogramDeclare(F);
if (!DIF) { if (!DIF) {
return NULL; return NULL;
} }
DISubprogram Sub(cast<MDNode>(DIF)); DISubprogram Sub(DIF);
DIType aDIType = Sub.getType(); DIType aDIType = Sub.getType();
const SmartType* retSmartType = new SmartType(F->getType()->getElementType(), &aDIType); const SmartType* retSmartType = new SmartType(F->getType()->getElementType(), &aDIType);
if(DIS) { if(DIS) {

6
minix/llvm/passes/sectionify/SectionifyPass.cpp
View File

@ -127,7 +127,7 @@ bool SectionifyPass::runOnModule(Module &M) {
return sectionified; return sectionified;
} }
bool SectionifyPass::sectionifyFromRegex(GlobalValue *value, Regex *regex, std::string &section) bool SectionifyPass::sectionifyFromRegex(GlobalObject *value, Regex *regex, std::string &section)
{ {
bool returnValue = false; bool returnValue = false;
@ -142,7 +142,7 @@ bool SectionifyPass::sectionifyFromRegex(GlobalValue *value, Regex *regex, std::
DEBUG(errs() << "Sectionified " << valueStrPrefix << (isa<Function>(value) ? "Function " : "GlobalVariable ") << value->getName() << " with section " << trgSection << "\n"); DEBUG(errs() << "Sectionified " << valueStrPrefix << (isa<Function>(value) ? "Function " : "GlobalVariable ") << value->getName() << " with section " << trgSection << "\n");
value->setSection(trgSection); value->setSection(trgSection);
if (value->hasCommonLinkage()) { if (value->hasCommonLinkage()) {
value->setLinkage(GlobalValue::WeakAnyLinkage); value->setLinkage(GlobalObject::WeakAnyLinkage);
} }
returnValue = true; returnValue = true;
} }
@ -167,7 +167,7 @@ bool SectionifyPass::sectionifyFromRegex(GlobalValue *value, Regex *regex, std::
return returnValue; return returnValue;
} }
bool SectionifyPass::sectionify(GlobalValue *value, std::vector<Regex*> &regexList, std::map<Regex*, std::string> &regexMap) bool SectionifyPass::sectionify(GlobalObject *value, std::vector<Regex*> &regexList, std::map<Regex*, std::string> &regexMap)
{ {
std::map<Regex*, std::string>::iterator regexMapIt; std::map<Regex*, std::string>::iterator regexMapIt;
for (std::vector<Regex*>::iterator it = regexList.begin(); it != regexList.end(); ++it) { for (std::vector<Regex*>::iterator it = regexList.begin(); it != regexList.end(); ++it) {