6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-01 15:11:24 +00:00
Code Issues Projects Releases Wiki Activity

Implement address space attribute for LLVM pointer types. Address spaces are

Browse Source 
regions of memory that have a target specific relationship, as described in the 
Embedded C Technical Report. 

This also implements the 2007-12-11-AddressSpaces test, 
which demonstrates how address space attributes can be used in LLVM IR.

In addition, this patch changes the bitcode signature for stores (in a backwards 
compatible manner), such that the pointer type, rather than the pointee type, is 
encoded. This permits type information in the pointer (e.g. address space) to be 
preserved for stores.

LangRef updates are forthcoming.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@44858 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Christopher Lamb 2007-12-11 08:59:05 +00:00
parent 7431c2ba79
commit fe63fb986d
15 changed files with 151 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/llvm/Bitcode/LLVMBitCodes.h
View File

@ -46,7 +46,7 @@ namespace bitc {
MODULE_CODE_SECTIONNAME = 5, // SECTIONNAME: [strchr x N]
MODULE_CODE_DEPLIB = 6, // DEPLIB: [strchr x N]
// GLOBALVAR: [type, isconst, initid,
// GLOBALVAR: [pointer type, isconst, initid,
// linkage, alignment, section, visibility, threadlocal]
MODULE_CODE_GLOBALVAR = 7,
@ -194,9 +194,13 @@ namespace bitc {
FUNC_CODE_INST_FREE = 18, // FREE: [opty, op]
FUNC_CODE_INST_ALLOCA = 19, // ALLOCA: [instty, op, align]
FUNC_CODE_INST_LOAD = 20, // LOAD: [opty, op, align, vol]
FUNC_CODE_INST_STORE = 21, // STORE: [ptrty,val,ptr, align, vol]
FUNC_CODE_INST_STORE = 21, // STORE: [valty,val,ptr, align, vol]
FUNC_CODE_INST_CALL = 22, // CALL: [attr, fnty, fnid, args...]
FUNC_CODE_INST_VAARG = 23 // VAARG: [valistty, valist, instty]
FUNC_CODE_INST_VAARG = 23, // VAARG: [valistty, valist, instty]
// This store code encodes the pointer type, rather than the value type
// this is so information only available in the pointer type (e.g. address
// spaces) is retained.
FUNC_CODE_INST_STORE2 = 24 // STORE: [ptrty,ptr,val, align, vol]
};
} // End bitc namespace
} // End llvm namespace

9
include/llvm/DerivedTypes.h
View File

@ -363,12 +363,17 @@ public:
///
class PointerType : public SequentialType {
friend class TypeMap<PointerValType, PointerType>;
unsigned AddressSpace;
PointerType(const PointerType &); // Do not implement
const PointerType &operator=(const PointerType &); // Do not implement
explicit PointerType(const Type *ElType);
explicit PointerType(const Type *ElType, unsigned AddrSpace);
public:
/// PointerType::get - This is the only way to construct a new pointer type.
static PointerType *get(const Type *ElementType);
static PointerType *get(const Type *ElementType, unsigned AddressSpace = 0);
/// @brief Return the address space of the Pointer type.
inline unsigned getAddressSpace() const { return AddressSpace; }
// Implement the AbstractTypeUser interface.
virtual void refineAbstractType(const DerivedType *OldTy, const Type *NewTy);

6
include/llvm/GlobalVariable.h
View File

@ -50,12 +50,14 @@ public:
/// automatically inserted into the end of the specified modules global list.
GlobalVariable(const Type *Ty, bool isConstant, LinkageTypes Linkage,
Constant *Initializer = 0, const std::string &Name = "",
Module *Parent = 0, bool ThreadLocal = false);
Module *Parent = 0, bool ThreadLocal = false,
unsigned AddressSpace = 0);
/// GlobalVariable ctor - This creates a global and inserts it before the
/// specified other global.
GlobalVariable(const Type *Ty, bool isConstant, LinkageTypes Linkage,
Constant *Initializer, const std::string &Name,
GlobalVariable *InsertBefore, bool ThreadLocal = false);
GlobalVariable *InsertBefore, bool ThreadLocal = false,
unsigned AddressSpace = 0);
/// isDeclaration - Is this global variable lacking an initializer? If so,
/// the global variable is defined in some other translation unit, and is thus

6
include/llvm/Instructions.h
View File

@ -455,7 +455,8 @@ public:
Instruction *InsertBefore =0)
: Instruction(PointerType::get(
checkType(getIndexedType(Ptr->getType(),
IdxBegin, IdxEnd, true))),
IdxBegin, IdxEnd, true)),
cast<PointerType>(Ptr->getType())->getAddressSpace()),
GetElementPtr, 0, 0, InsertBefore) {
init(Ptr, IdxBegin, IdxEnd, Name,
typename std::iterator_traits<InputIterator>::iterator_category());
@ -465,7 +466,8 @@ public:
const std::string &Name, BasicBlock *InsertAtEnd)
: Instruction(PointerType::get(
checkType(getIndexedType(Ptr->getType(),
IdxBegin, IdxEnd, true))),
IdxBegin, IdxEnd, true)),
cast<PointerType>(Ptr->getType())->getAddressSpace()),
GetElementPtr, 0, 0, InsertAtEnd) {
init(Ptr, IdxBegin, IdxEnd, Name,
typename std::iterator_traits<InputIterator>::iterator_category());

1
lib/AsmParser/LLLexer.cpp
View File

@ -463,6 +463,7 @@ int LLLexer::LexIdentifier() {
KEYWORD("datalayout", DATALAYOUT);
KEYWORD("volatile", VOLATILE);
KEYWORD("align", ALIGN);
KEYWORD("addrspace", ADDRSPACE);
KEYWORD("section", SECTION);
KEYWORD("alias", ALIAS);
KEYWORD("module", MODULE);

31
lib/AsmParser/llvmAsmParser.y
View File

@ -491,7 +491,8 @@ static Value *getVal(const Type *Ty, const ValID &ID) {
if (const FunctionType *FTy = dyn_cast<FunctionType>(ElTy))
V = new Function(FTy, GlobalValue::ExternalLinkage);
else
V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage);
V = new GlobalVariable(ElTy, false, GlobalValue::ExternalLinkage, 0, "",
(Module*)0, false, PTy->getAddressSpace());
break;
}
default:
@ -722,13 +723,14 @@ ParseGlobalVariable(std::string *NameStr,
GlobalValue::LinkageTypes Linkage,
GlobalValue::VisibilityTypes Visibility,
bool isConstantGlobal, const Type *Ty,
Constant *Initializer, bool IsThreadLocal) {
Constant *Initializer, bool IsThreadLocal,
unsigned AddressSpace = 0) {
if (isa<FunctionType>(Ty)) {
GenerateError("Cannot declare global vars of function type");
return 0;
}
const PointerType *PTy = PointerType::get(Ty);
const PointerType *PTy = PointerType::get(Ty, AddressSpace);
std::string Name;
if (NameStr) {
@ -780,7 +782,7 @@ ParseGlobalVariable(std::string *NameStr,
// Otherwise there is no existing GV to use, create one now.
GlobalVariable *GV =
new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
CurModule.CurrentModule, IsThreadLocal);
CurModule.CurrentModule, IsThreadLocal, AddressSpace);
GV->setVisibility(Visibility);
InsertValue(GV, CurModule.Values);
return GV;
@ -1054,7 +1056,7 @@ Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) {
%token DECLARE DEFINE GLOBAL CONSTANT SECTION ALIAS VOLATILE THREAD_LOCAL
%token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
%token DLLIMPORT DLLEXPORT EXTERN_WEAK
%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN
%token OPAQUE EXTERNAL TARGET TRIPLE ALIGN ADDRSPACE
%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
%token CC_TOK CCC_TOK FASTCC_TOK COLDCC_TOK X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
%token DATALAYOUT
@ -1268,6 +1270,7 @@ OptCAlign : /*empty*/ { $$ = 0; } |
};
SectionString : SECTION STRINGCONSTANT {
for (unsigned i = 0, e = $2->length(); i != e; ++i)
if ((*$2)[i] == '"' || (*$2)[i] == '\\')
@ -1320,6 +1323,13 @@ Types
delete $1;
CHECK_FOR_ERROR
}
| Types ADDRSPACE '(' EUINT64VAL ')' '*' { // Pointer type?
if (*$1 == Type::LabelTy)
GEN_ERROR("Cannot form a pointer to a basic block");
$$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1, $4)));
delete $1;
CHECK_FOR_ERROR
}
| SymbolicValueRef { // Named types are also simple types...
const Type* tmp = getTypeVal($1);
CHECK_FOR_ERROR
@ -2073,6 +2083,17 @@ Definition
} GlobalVarAttributes {
CurGV = 0;
}
| OptGlobalAssign GVVisibilityStyle ThreadLocal GlobalType ConstVal
ADDRSPACE '(' EUINT64VAL ')' {
/* "Externally Visible" Linkage with address space qualifier */
if ($5 == 0)
GEN_ERROR("Global value initializer is not a constant");
CurGV = ParseGlobalVariable($1, GlobalValue::ExternalLinkage,
$2, $4, $5->getType(), $5, $3, $8);
CHECK_FOR_ERROR
} GlobalVarAttributes {
CurGV = 0;
}
| OptGlobalAssign GVInternalLinkage GVVisibilityStyle ThreadLocal GlobalType
ConstVal {
if ($6 == 0)

28
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -323,11 +323,16 @@ bool BitcodeReader::ParseTypeTable() {
ResultTy = IntegerType::get(Record[0]);
break;
case bitc::TYPE_CODE_POINTER: // POINTER: [pointee type]
case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
// [pointee type, address space]
if (Record.size() < 1)
return Error("Invalid POINTER type record");
ResultTy = PointerType::get(getTypeByID(Record[0], true));
unsigned AddressSpace = 0;
if (Record.size() == 2)
AddressSpace = Record[1];
ResultTy = PointerType::get(getTypeByID(Record[0], true), AddressSpace);
break;
}
case bitc::TYPE_CODE_FUNCTION: {
// FIXME: attrid is dead, remove it in LLVM 3.0
// FUNCTION: [vararg, attrid, retty, paramty x N]
@ -982,7 +987,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
CollectorTable.push_back(S);
break;
}
// GLOBALVAR: [type, isconst, initid,
// GLOBALVAR: [pointer type, isconst, initid,
// linkage, alignment, section, visibility, threadlocal]
case bitc::MODULE_CODE_GLOBALVAR: {
if (Record.size() < 6)
@ -990,6 +995,7 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
const Type *Ty = getTypeByID(Record[0]);
if (!isa<PointerType>(Ty))
return Error("Global not a pointer type!");
unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace();
Ty = cast<PointerType>(Ty)->getElementType();
bool isConstant = Record[1];
@ -1009,7 +1015,8 @@ bool BitcodeReader::ParseModule(const std::string &ModuleID) {
isThreadLocal = Record[7];
GlobalVariable *NewGV =
new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule);
new GlobalVariable(Ty, isConstant, Linkage, 0, "", TheModule,
isThreadLocal, AddressSpace);
NewGV->setAlignment(Alignment);
if (!Section.empty())
NewGV->setSection(Section);
@ -1485,7 +1492,20 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
break;
}
case bitc::FUNC_CODE_INST_STORE2: { // STORE2:[ptrty, ptr, val, align, vol]
unsigned OpNum = 0;
Value *Val, *Ptr;
if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) ||
getValue(Record, OpNum,
cast<PointerType>(Ptr->getType())->getElementType(), Val) ||
OpNum+2 != Record.size())
return Error("Invalid STORE record");
I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
break;
}
case bitc::FUNC_CODE_INST_STORE: { // STORE:[val, valty, ptr, align, vol]
// FIXME: Legacy form of store instruction. Should be removed in LLVM 3.0.
unsigned OpNum = 0;
Value *Val, *Ptr;
if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||

16
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -197,10 +197,14 @@ static void WriteTypeTable(const ValueEnumerator &VE, BitstreamWriter &Stream) {
TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
break;
case Type::PointerTyID:
// POINTER: [pointee type]
const PointerType *PTy = cast<PointerType>(T);
// POINTER: [pointee type] or [pointee type, address space]
Code = bitc::TYPE_CODE_POINTER;
TypeVals.push_back(VE.getTypeID(cast<PointerType>(T)->getElementType()));
AbbrevToUse = PtrAbbrev;
TypeVals.push_back(VE.getTypeID(PTy->getElementType()));
if (unsigned AddressSpace = PTy->getAddressSpace())
TypeVals.push_back(AddressSpace);
else
AbbrevToUse = PtrAbbrev;
break;
case Type::FunctionTyID: {
@ -829,9 +833,9 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
Vals.push_back(cast<LoadInst>(I).isVolatile());
break;
case Instruction::Store:
Code = bitc::FUNC_CODE_INST_STORE;
PushValueAndType(I.getOperand(0), InstID, Vals, VE); // val.
Vals.push_back(VE.getValueID(I.getOperand(1))); // ptr.
Code = bitc::FUNC_CODE_INST_STORE2;
PushValueAndType(I.getOperand(1), InstID, Vals, VE); // ptrty + ptr
Vals.push_back(VE.getValueID(I.getOperand(0))); // val.
Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
Vals.push_back(cast<StoreInst>(I).isVolatile());
break;

11
lib/VMCore/AsmWriter.cpp
View File

@ -334,11 +334,15 @@ static void calcTypeName(const Type *Ty,
Result += '>';
break;
}
case Type::PointerTyID:
calcTypeName(cast<PointerType>(Ty)->getElementType(),
case Type::PointerTyID: {
const PointerType *PTy = cast<PointerType>(Ty);
calcTypeName(PTy->getElementType(),
TypeStack, TypeNames, Result);
if (unsigned AddressSpace = PTy->getAddressSpace())
Result += " addrspace(" + utostr(AddressSpace) + ")";
Result += "*";
break;
}
case Type::ArrayTyID: {
const ArrayType *ATy = cast<ArrayType>(Ty);
Result += "[" + utostr(ATy->getNumElements()) + " x ";
@ -951,6 +955,9 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
writeOperand(GV->getInitializer(), false);
}
if (unsigned AddressSpace = GV->getType()->getAddressSpace())
Out << " addrspace(" << AddressSpace << ") ";
if (GV->hasSection())
Out << ", section \"" << GV->getSection() << '"';
if (GV->getAlignment())

3
lib/VMCore/Constants.cpp
View File

@ -1860,7 +1860,8 @@ Constant *ConstantExpr::getGetElementPtr(Constant *C, Value* const *Idxs,
const Type *Ty =
GetElementPtrInst::getIndexedType(C->getType(), Idxs, Idxs+NumIdx, true);
assert(Ty && "GEP indices invalid!");
return getGetElementPtrTy(PointerType::get(Ty), C, Idxs, NumIdx);
unsigned As = cast<PointerType>(C->getType())->getAddressSpace();
return getGetElementPtrTy(PointerType::get(Ty, As), C, Idxs, NumIdx);
}
Constant *ConstantExpr::getGetElementPtr(Constant *C, Constant* const *Idxs,

10
lib/VMCore/Globals.cpp
View File

@ -85,8 +85,9 @@ void GlobalValue::destroyConstant() {
GlobalVariable::GlobalVariable(const Type *Ty, bool constant, LinkageTypes Link,
Constant *InitVal, const std::string &Name,
Module *ParentModule, bool ThreadLocal)
: GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal,
Module *ParentModule, bool ThreadLocal,
unsigned AddressSpace)
: GlobalValue(PointerType::get(Ty, AddressSpace), Value::GlobalVariableVal,
&Initializer, InitVal != 0, Link, Name),
isConstantGlobal(constant), isThreadLocalSymbol(ThreadLocal) {
if (InitVal) {
@ -105,8 +106,9 @@ GlobalVariable::GlobalVariable(const Type *Ty, bool constant, LinkageTypes Link,
GlobalVariable::GlobalVariable(const Type *Ty, bool constant, LinkageTypes Link,
Constant *InitVal, const std::string &Name,
GlobalVariable *Before, bool ThreadLocal)
: GlobalValue(PointerType::get(Ty), Value::GlobalVariableVal,
GlobalVariable *Before, bool ThreadLocal,
unsigned AddressSpace)
: GlobalValue(PointerType::get(Ty, AddressSpace), Value::GlobalVariableVal,
&Initializer, InitVal != 0, Link, Name),
isConstantGlobal(constant), isThreadLocalSymbol(ThreadLocal) {
if (InitVal) {

6
lib/VMCore/Instructions.cpp
View File

@ -937,7 +937,8 @@ void GetElementPtrInst::init(Value *Ptr, Value *Idx) {
GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
const std::string &Name, Instruction *InBe)
: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx))),
: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx)),
cast<PointerType>(Ptr->getType())->getAddressSpace()),
GetElementPtr, 0, 0, InBe) {
init(Ptr, Idx);
setName(Name);
@ -945,7 +946,8 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
const std::string &Name, BasicBlock *IAE)
: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx))),
: Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx)),
cast<PointerType>(Ptr->getType())->getAddressSpace()),
GetElementPtr, 0, 0, IAE) {
init(Ptr, Idx);
setName(Name);

31
lib/VMCore/Type.cpp
View File

@ -338,7 +338,10 @@ static std::string getTypeDescription(const Type *Ty,
}
case Type::PointerTyID: {
const PointerType *PTy = cast<PointerType>(Ty);
Result = getTypeDescription(PTy->getElementType(), TypeStack) + " *";
Result = getTypeDescription(PTy->getElementType(), TypeStack);
if (unsigned AddressSpace = PTy->getAddressSpace())
Result += " addrspace(" + utostr(AddressSpace) + ")";
Result += " *";
break;
}
case Type::ArrayTyID: {
@ -492,7 +495,9 @@ VectorType::VectorType(const Type *ElType, unsigned NumEl)
}
PointerType::PointerType(const Type *E) : SequentialType(PointerTyID, E) {
PointerType::PointerType(const Type *E, unsigned AddrSpace)
: SequentialType(PointerTyID, E) {
AddressSpace = AddrSpace;
// Calculate whether or not this type is abstract
setAbstract(E->isAbstract());
}
@ -634,8 +639,9 @@ static bool TypesEqual(const Type *Ty, const Type *Ty2,
const IntegerType *ITy2 = cast<IntegerType>(Ty2);
return ITy->getBitWidth() == ITy2->getBitWidth();
} else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
return TypesEqual(PTy->getElementType(),
cast<PointerType>(Ty2)->getElementType(), EqTypes);
const PointerType *PTy2 = cast<PointerType>(Ty2);
return PTy->getAddressSpace() == PTy2->getAddressSpace() &&
TypesEqual(PTy->getElementType(), PTy2->getElementType(), EqTypes);
} else if (const StructType *STy = dyn_cast<StructType>(Ty)) {
const StructType *STy2 = cast<StructType>(Ty2);
if (STy->getNumElements() != STy2->getNumElements()) return false;
@ -756,6 +762,9 @@ static unsigned getSubElementHash(const Type *Ty) {
case Type::StructTyID:
HashVal ^= cast<StructType>(SubTy)->getNumElements();
break;
case Type::PointerTyID:
HashVal ^= cast<PointerType>(SubTy)->getAddressSpace();
break;
}
}
return HashVal ? HashVal : 1; // Do not return zero unless opaque subty.
@ -1251,11 +1260,12 @@ StructType *StructType::get(const std::vector<const Type*> &ETypes,
namespace llvm {
class PointerValType {
const Type *ValTy;
unsigned AddressSpace;
public:
PointerValType(const Type *val) : ValTy(val) {}
PointerValType(const Type *val, unsigned as) : ValTy(val), AddressSpace(as) {}
static PointerValType get(const PointerType *PT) {
return PointerValType(PT->getElementType());
return PointerValType(PT->getElementType(), PT->getAddressSpace());
}
static unsigned hashTypeStructure(const PointerType *PT) {
@ -1263,25 +1273,26 @@ public:
}
bool operator<(const PointerValType &MTV) const {
return ValTy < MTV.ValTy;
if (AddressSpace < MTV.AddressSpace) return true;
return AddressSpace == MTV.AddressSpace && ValTy < MTV.ValTy;
}
};
}
static ManagedStatic<TypeMap<PointerValType, PointerType> > PointerTypes;
PointerType *PointerType::get(const Type *ValueType) {
PointerType *PointerType::get(const Type *ValueType, unsigned AddressSpace) {
assert(ValueType && "Can't get a pointer to <null> type!");
assert(ValueType != Type::VoidTy &&
"Pointer to void is not valid, use sbyte* instead!");
assert(ValueType != Type::LabelTy && "Pointer to label is not valid!");
PointerValType PVT(ValueType);
PointerValType PVT(ValueType, AddressSpace);
PointerType *PT = PointerTypes->get(PVT);
if (PT) return PT;
// Value not found. Derive a new type!
PointerTypes->add(PVT, PT = new PointerType(ValueType));
PointerTypes->add(PVT, PT = new PointerType(ValueType, AddressSpace));
#ifdef DEBUG_MERGE_TYPES
DOUT << "Derived new type: " << *PT << "\n";

25
test/Assembler/2007-12-11-AddressSpaces.ll Normal file
View File

@ -0,0 +1,25 @@
; RUN: llvm-as < %s | llvm-dis |& grep {addrspace(33)} | count 7
; RUN: llvm-as < %s | llvm-dis |& grep {addrspace(42)} | count 2
; RUN: llvm-as < %s | llvm-dis |& grep {addrspace(66)} | count 2
; RUN: llvm-as < %s | llvm-dis |& grep {addrspace(11)} | count 6
; RUN: llvm-as < %s | llvm-dis |& grep {addrspace(22)} | count 5
%struct.mystruct = type { i32, i32 addrspace(33)*, i32, i32 addrspace(33)* }
@input = global %struct.mystruct zeroinitializer addrspace(42) ; <%struct.mystruct addrspace(42)*> [#uses=1]
@output = global %struct.mystruct zeroinitializer addrspace(66) ; <%struct.mystruct addrspace(66)*> [#uses=1]
@y = global i32 addrspace(11)* addrspace(22)* null addrspace(33) ; <i32 addrspace(11)* addrspace(22)* addrspace(33)*> [#uses=1]
define void @foo() {
entry:
%tmp1 = load i32 addrspace(33)* addrspace(42)* getelementptr (%struct.mystruct addrspace(42)* @input, i32 0, i32 3), align 4 ; <i32 addrspace(33)*> [#uses=1]
store i32 addrspace(33)* %tmp1, i32 addrspace(33)* addrspace(66)* getelementptr (%struct.mystruct addrspace(66)* @output, i32 0, i32 1), align 4
ret void
}
define i32 addrspace(11)* @bar(i32 addrspace(11)* addrspace(22)* addrspace(33)* %x) {
entry:
%tmp1 = load i32 addrspace(11)* addrspace(22)* addrspace(33)* @y, align 4 ; <i32 addrspace(11)* addrspace(22)*> [#uses=2]
store i32 addrspace(11)* addrspace(22)* %tmp1, i32 addrspace(11)* addrspace(22)* addrspace(33)* %x, align 4
%tmp5 = load i32 addrspace(11)* addrspace(22)* %tmp1, align 4 ; <i32 addrspace(11)*> [#uses=1]
ret i32 addrspace(11)* %tmp5
}

1
tools/llvm-bcanalyzer/llvm-bcanalyzer.cpp
View File

@ -197,6 +197,7 @@ static const char *GetCodeName(unsigned CodeID, unsigned BlockID) {
case bitc::FUNC_CODE_INST_STORE: return "INST_STORE";
case bitc::FUNC_CODE_INST_CALL: return "INST_CALL";
case bitc::FUNC_CODE_INST_VAARG: return "INST_VAARG";
case bitc::FUNC_CODE_INST_STORE2: return "INST_STORE2";
}
case bitc::TYPE_SYMTAB_BLOCK_ID:
switch (CodeID) {