Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(660)

Side by Side Diff: src/IceConverter.cpp

Issue 624663002: Introduce model of global initializers in Subzero. (Closed) Base URL: https://chromium.googlesource.com/native_client/pnacl-subzero.git@master
Patch Set: Fix nits. Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/IceConverter.h ('k') | src/IceGlobalInits.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice ---------------===// 1 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice ---------------===//
2 // 2 //
3 // The Subzero Code Generator 3 // The Subzero Code Generator
4 // 4 //
5 // This file is distributed under the University of Illinois Open Source 5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details. 6 // License. See LICENSE.TXT for details.
7 // 7 //
8 //===----------------------------------------------------------------------===// 8 //===----------------------------------------------------------------------===//
9 // 9 //
10 // This file implements the LLVM to ICE converter. 10 // This file implements the LLVM to ICE converter.
11 // 11 //
12 //===----------------------------------------------------------------------===// 12 //===----------------------------------------------------------------------===//
13 13
14 #include <iostream> 14 #include <iostream>
15 15
16 #include "llvm/IR/Constant.h" 16 #include "llvm/IR/Constant.h"
17 #include "llvm/IR/Constants.h" 17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/DataLayout.h" 18 #include "llvm/IR/DataLayout.h"
19 #include "llvm/IR/Instruction.h" 19 #include "llvm/IR/Instruction.h"
20 #include "llvm/IR/Instructions.h" 20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/LLVMContext.h" 21 #include "llvm/IR/LLVMContext.h"
22 #include "llvm/IR/Module.h" 22 #include "llvm/IR/Module.h"
23 23
24 #include "IceCfg.h" 24 #include "IceCfg.h"
25 #include "IceCfgNode.h" 25 #include "IceCfgNode.h"
26 #include "IceClFlags.h" 26 #include "IceClFlags.h"
27 #include "IceConverter.h" 27 #include "IceConverter.h"
28 #include "IceDefs.h" 28 #include "IceDefs.h"
29 #include "IceGlobalContext.h" 29 #include "IceGlobalContext.h"
30 #include "IceGlobalInits.h"
30 #include "IceInst.h" 31 #include "IceInst.h"
31 #include "IceOperand.h" 32 #include "IceOperand.h"
32 #include "IceTargetLowering.h" 33 #include "IceTargetLowering.h"
33 #include "IceTypes.h" 34 #include "IceTypes.h"
34 #include "IceTypeConverter.h" 35 #include "IceTypeConverter.h"
35 36
36 using namespace llvm; 37 using namespace llvm;
37 38
38 namespace { 39 namespace {
39 40
40 // Debugging helper 41 // Debugging helper
41 template <typename T> static std::string LLVMObjectAsString(const T *O) { 42 template <typename T> static std::string LLVMObjectAsString(const T *O) {
42 std::string Dump; 43 std::string Dump;
43 raw_string_ostream Stream(Dump); 44 raw_string_ostream Stream(Dump);
44 O->print(Stream); 45 O->print(Stream);
45 return Stream.str(); 46 return Stream.str();
46 } 47 }
47 48
48 // Converter from LLVM to ICE. The entry point is the convertFunction method. 49 // Base class for converting LLVM to ICE.
49 //
50 // Note: this currently assumes that the given IR was verified to be valid PNaCl
51 // bitcode:
52 // https://developers.google.com/native-client/dev/reference/pnacl-bitcode-abi
53 // If not, all kinds of assertions may fire.
54 //
55 class LLVM2ICEConverter { 50 class LLVM2ICEConverter {
51 LLVM2ICEConverter(const LLVM2ICEConverter &) = delete;
52 LLVM2ICEConverter &operator=(const LLVM2ICEConverter &) = delete;
53
56 public: 54 public:
57 LLVM2ICEConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext) 55 LLVM2ICEConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
58 : Ctx(Ctx), Func(NULL), TypeConverter(LLVMContext) {} 56 : Ctx(Ctx), TypeConverter(LLVMContext) {}
57
58 protected:
59 // Data
60 Ice::GlobalContext *Ctx;
61 const Ice::TypeConverter TypeConverter;
62 };
63
64 // Converter from LLVM functions to ICE. The entry point is the
65 // convertFunction method.
66 //
67 // Note: this currently assumes that the given IR was verified to be
68 // valid PNaCl bitcode. Otherwise, the behavior is undefined.
69 class LLVM2ICEFunctionConverter : LLVM2ICEConverter {
70 LLVM2ICEFunctionConverter(const LLVM2ICEFunctionConverter &) = delete;
71 LLVM2ICEFunctionConverter &
72 operator=(const LLVM2ICEFunctionConverter &) = delete;
73
74 public:
75 LLVM2ICEFunctionConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
76 : LLVM2ICEConverter(Ctx, LLVMContext), Func(NULL) {}
59 77
60 // Caller is expected to delete the returned Ice::Cfg object. 78 // Caller is expected to delete the returned Ice::Cfg object.
61 Ice::Cfg *convertFunction(const Function *F) { 79 Ice::Cfg *convertFunction(const Function *F) {
62 static Ice::TimerIdT IDllvmConvert = 80 static Ice::TimerIdT IDllvmConvert =
63 Ice::GlobalContext::getTimerID("llvmConvert"); 81 Ice::GlobalContext::getTimerID("llvmConvert");
64 Ice::TimerMarker T(IDllvmConvert, Ctx); 82 Ice::TimerMarker T(IDllvmConvert, Ctx);
65 VarMap.clear(); 83 VarMap.clear();
66 NodeMap.clear(); 84 NodeMap.clear();
67 Func = new Ice::Cfg(Ctx); 85 Func = new Ice::Cfg(Ctx);
68 Func->setFunctionName(F->getName()); 86 Func->setFunctionName(F->getName());
(...skipping 17 matching lines...) Expand all
86 Func->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock())); 104 Func->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock()));
87 Func->computePredecessors(); 105 Func->computePredecessors();
88 106
89 return Func; 107 return Func;
90 } 108 }
91 109
92 // convertConstant() does not use Func or require it to be a valid 110 // convertConstant() does not use Func or require it to be a valid
93 // Ice::Cfg pointer. As such, it's suitable for e.g. constructing 111 // Ice::Cfg pointer. As such, it's suitable for e.g. constructing
94 // global initializers. 112 // global initializers.
95 Ice::Constant *convertConstant(const Constant *Const) { 113 Ice::Constant *convertConstant(const Constant *Const) {
96 if (const GlobalValue *GV = dyn_cast<GlobalValue>(Const)) { 114 if (const auto GV = dyn_cast<GlobalValue>(Const)) {
97 return Ctx->getConstantSym(convertToIceType(GV->getType()), 0, 115 return Ctx->getConstantSym(convertToIceType(GV->getType()), 0,
98 GV->getName()); 116 GV->getName());
99 } else if (const ConstantInt *CI = dyn_cast<ConstantInt>(Const)) { 117 } else if (const auto CI = dyn_cast<ConstantInt>(Const)) {
100 Ice::Type Ty = convertToIceType(CI->getType()); 118 Ice::Type Ty = convertToIceType(CI->getType());
101 if (Ty == Ice::IceType_i64) { 119 if (Ty == Ice::IceType_i64) {
102 return Ctx->getConstantInt64(Ty, CI->getSExtValue()); 120 return Ctx->getConstantInt64(Ty, CI->getSExtValue());
103 } else { 121 } else {
104 return Ctx->getConstantInt32(Ty, CI->getSExtValue()); 122 return Ctx->getConstantInt32(Ty, CI->getSExtValue());
105 } 123 }
106 } else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(Const)) { 124 } else if (const auto CFP = dyn_cast<ConstantFP>(Const)) {
107 Ice::Type Type = convertToIceType(CFP->getType()); 125 Ice::Type Type = convertToIceType(CFP->getType());
108 if (Type == Ice::IceType_f32) 126 if (Type == Ice::IceType_f32)
109 return Ctx->getConstantFloat(CFP->getValueAPF().convertToFloat()); 127 return Ctx->getConstantFloat(CFP->getValueAPF().convertToFloat());
110 else if (Type == Ice::IceType_f64) 128 else if (Type == Ice::IceType_f64)
111 return Ctx->getConstantDouble(CFP->getValueAPF().convertToDouble()); 129 return Ctx->getConstantDouble(CFP->getValueAPF().convertToDouble());
112 llvm_unreachable("Unexpected floating point type"); 130 llvm_unreachable("Unexpected floating point type");
113 return NULL; 131 return NULL;
114 } else if (const UndefValue *CU = dyn_cast<UndefValue>(Const)) { 132 } else if (const auto CU = dyn_cast<UndefValue>(Const)) {
115 return Ctx->getConstantUndef(convertToIceType(CU->getType())); 133 return Ctx->getConstantUndef(convertToIceType(CU->getType()));
116 } else { 134 } else {
117 llvm_unreachable("Unhandled constant type"); 135 llvm_unreachable("Unhandled constant type");
118 return NULL; 136 return NULL;
119 } 137 }
120 } 138 }
121 139
122 private: 140 private:
123 // LLVM values (instructions, etc.) are mapped directly to ICE variables. 141 // LLVM values (instructions, etc.) are mapped directly to ICE variables.
124 // mapValueToIceVar has a version that forces an ICE type on the variable, 142 // mapValueToIceVar has a version that forces an ICE type on the variable,
(...skipping 14 matching lines...) Expand all
139 Ice::CfgNode *mapBasicBlockToNode(const BasicBlock *BB) { 157 Ice::CfgNode *mapBasicBlockToNode(const BasicBlock *BB) {
140 if (NodeMap.find(BB) == NodeMap.end()) { 158 if (NodeMap.find(BB) == NodeMap.end()) {
141 NodeMap[BB] = Func->makeNode(BB->getName()); 159 NodeMap[BB] = Func->makeNode(BB->getName());
142 } 160 }
143 return NodeMap[BB]; 161 return NodeMap[BB];
144 } 162 }
145 163
146 Ice::Type convertToIceType(Type *LLVMTy) const { 164 Ice::Type convertToIceType(Type *LLVMTy) const {
147 Ice::Type IceTy = TypeConverter.convertToIceType(LLVMTy); 165 Ice::Type IceTy = TypeConverter.convertToIceType(LLVMTy);
148 if (IceTy == Ice::IceType_NUM) 166 if (IceTy == Ice::IceType_NUM)
149 llvm::report_fatal_error(std::string("Invalid PNaCl type ") + 167 report_fatal_error(std::string("Invalid PNaCl type ") +
150 LLVMObjectAsString(LLVMTy)); 168 LLVMObjectAsString(LLVMTy));
151 return IceTy; 169 return IceTy;
152 } 170 }
153 171
154 // Given an LLVM instruction and an operand number, produce the 172 // Given an LLVM instruction and an operand number, produce the
155 // Ice::Operand this refers to. If there's no such operand, return 173 // Ice::Operand this refers to. If there's no such operand, return
156 // NULL. 174 // NULL.
157 Ice::Operand *convertOperand(const Instruction *Inst, unsigned OpNum) { 175 Ice::Operand *convertOperand(const Instruction *Inst, unsigned OpNum) {
158 if (OpNum >= Inst->getNumOperands()) { 176 if (OpNum >= Inst->getNumOperands()) {
159 return NULL; 177 return NULL;
160 } 178 }
161 const Value *Op = Inst->getOperand(OpNum); 179 const Value *Op = Inst->getOperand(OpNum);
162 return convertValue(Op); 180 return convertValue(Op);
163 } 181 }
164 182
165 Ice::Operand *convertValue(const Value *Op) { 183 Ice::Operand *convertValue(const Value *Op) {
166 if (const Constant *Const = dyn_cast<Constant>(Op)) { 184 if (const auto Const = dyn_cast<Constant>(Op)) {
167 return convertConstant(Const); 185 return convertConstant(Const);
168 } else { 186 } else {
169 return mapValueToIceVar(Op); 187 return mapValueToIceVar(Op);
170 } 188 }
171 } 189 }
172 190
173 // Note: this currently assumes a 1x1 mapping between LLVM IR and Ice 191 // Note: this currently assumes a 1x1 mapping between LLVM IR and Ice
174 // instructions. 192 // instructions.
175 Ice::Inst *convertInstruction(const Instruction *Inst) { 193 Ice::Inst *convertInstruction(const Instruction *Inst) {
176 switch (Inst->getOpcode()) { 194 switch (Inst->getOpcode()) {
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after
286 } 304 }
287 305
288 Ice::Inst *convertStoreInstruction(const StoreInst *Inst) { 306 Ice::Inst *convertStoreInstruction(const StoreInst *Inst) {
289 Ice::Operand *Addr = convertOperand(Inst, 1); 307 Ice::Operand *Addr = convertOperand(Inst, 1);
290 Ice::Operand *Val = convertOperand(Inst, 0); 308 Ice::Operand *Val = convertOperand(Inst, 0);
291 return Ice::InstStore::create(Func, Val, Addr); 309 return Ice::InstStore::create(Func, Val, Addr);
292 } 310 }
293 311
294 Ice::Inst *convertArithInstruction(const Instruction *Inst, 312 Ice::Inst *convertArithInstruction(const Instruction *Inst,
295 Ice::InstArithmetic::OpKind Opcode) { 313 Ice::InstArithmetic::OpKind Opcode) {
296 const BinaryOperator *BinOp = cast<BinaryOperator>(Inst); 314 const auto BinOp = cast<BinaryOperator>(Inst);
297 Ice::Operand *Src0 = convertOperand(Inst, 0); 315 Ice::Operand *Src0 = convertOperand(Inst, 0);
298 Ice::Operand *Src1 = convertOperand(Inst, 1); 316 Ice::Operand *Src1 = convertOperand(Inst, 1);
299 Ice::Variable *Dest = mapValueToIceVar(BinOp); 317 Ice::Variable *Dest = mapValueToIceVar(BinOp);
300 return Ice::InstArithmetic::create(Func, Opcode, Dest, Src0, Src1); 318 return Ice::InstArithmetic::create(Func, Opcode, Dest, Src0, Src1);
301 } 319 }
302 320
303 Ice::Inst *convertPHINodeInstruction(const PHINode *Inst) { 321 Ice::Inst *convertPHINodeInstruction(const PHINode *Inst) {
304 unsigned NumValues = Inst->getNumIncomingValues(); 322 unsigned NumValues = Inst->getNumIncomingValues();
305 Ice::InstPhi *IcePhi = 323 Ice::InstPhi *IcePhi =
306 Ice::InstPhi::create(Func, NumValues, mapValueToIceVar(Inst)); 324 Ice::InstPhi::create(Func, NumValues, mapValueToIceVar(Inst));
(...skipping 197 matching lines...) Expand 10 before | Expand all | Expand 10 after
504 522
505 Ice::Inst *convertCallInstruction(const CallInst *Inst) { 523 Ice::Inst *convertCallInstruction(const CallInst *Inst) {
506 Ice::Variable *Dest = mapValueToIceVar(Inst); 524 Ice::Variable *Dest = mapValueToIceVar(Inst);
507 Ice::Operand *CallTarget = convertValue(Inst->getCalledValue()); 525 Ice::Operand *CallTarget = convertValue(Inst->getCalledValue());
508 unsigned NumArgs = Inst->getNumArgOperands(); 526 unsigned NumArgs = Inst->getNumArgOperands();
509 // Note: Subzero doesn't (yet) do anything special with the Tail 527 // Note: Subzero doesn't (yet) do anything special with the Tail
510 // flag in the bitcode, i.e. CallInst::isTailCall(). 528 // flag in the bitcode, i.e. CallInst::isTailCall().
511 Ice::InstCall *NewInst = NULL; 529 Ice::InstCall *NewInst = NULL;
512 const Ice::Intrinsics::FullIntrinsicInfo *Info = NULL; 530 const Ice::Intrinsics::FullIntrinsicInfo *Info = NULL;
513 531
514 if (Ice::ConstantRelocatable *Target = 532 if (const auto Target = dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
515 llvm::dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
516 // Check if this direct call is to an Intrinsic (starts with "llvm.") 533 // Check if this direct call is to an Intrinsic (starts with "llvm.")
517 static const char LLVMPrefix[] = "llvm."; 534 static const char LLVMPrefix[] = "llvm.";
518 const size_t LLVMPrefixLen = strlen(LLVMPrefix); 535 const size_t LLVMPrefixLen = strlen(LLVMPrefix);
519 Ice::IceString Name = Target->getName(); 536 Ice::IceString Name = Target->getName();
520 if (Name.substr(0, LLVMPrefixLen) == LLVMPrefix) { 537 if (Name.substr(0, LLVMPrefixLen) == LLVMPrefix) {
521 Ice::IceString NameSuffix = Name.substr(LLVMPrefixLen); 538 Ice::IceString NameSuffix = Name.substr(LLVMPrefixLen);
522 Info = Ctx->getIntrinsicsInfo().find(NameSuffix); 539 Info = Ctx->getIntrinsicsInfo().find(NameSuffix);
523 if (!Info) { 540 if (!Info) {
524 report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") + 541 report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") +
525 LLVMObjectAsString(Inst)); 542 LLVMObjectAsString(Inst));
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after
598 << I->getArgType(ArgIndex) 615 << I->getArgType(ArgIndex)
599 << ". Found: " << Call->getArg(ArgIndex)->getType(); 616 << ". Found: " << Call->getArg(ArgIndex)->getType();
600 report_fatal_error(StrBuf.str()); 617 report_fatal_error(StrBuf.str());
601 break; 618 break;
602 } 619 }
603 } 620 }
604 } 621 }
605 622
606 private: 623 private:
607 // Data 624 // Data
608 Ice::GlobalContext *Ctx;
609 Ice::Cfg *Func; 625 Ice::Cfg *Func;
610 std::map<const Value *, Ice::Variable *> VarMap; 626 std::map<const Value *, Ice::Variable *> VarMap;
611 std::map<const BasicBlock *, Ice::CfgNode *> NodeMap; 627 std::map<const BasicBlock *, Ice::CfgNode *> NodeMap;
612 Ice::TypeConverter TypeConverter;
613 }; 628 };
614 629
630 // Converter from LLVM global variables to ICE. The entry point is the
631 // convertGlobalsToIce method.
632 //
633 // Note: this currently assumes that the given IR was verified to be
634 // valid PNaCl bitcode. Othewise, the behavior is undefined.
635 class LLVM2ICEGlobalsConverter : public LLVM2ICEConverter {
636 LLVM2ICEGlobalsConverter(const LLVM2ICEGlobalsConverter &) = delete;
637 LLVM2ICEGlobalsConverter &
638 operator-(const LLVM2ICEGlobalsConverter &) = delete;
639
640 public:
641 LLVM2ICEGlobalsConverter(Ice::GlobalContext *Ctx, LLVMContext &LLVMContext)
642 : LLVM2ICEConverter(Ctx, LLVMContext) {}
643
644 ~LLVM2ICEGlobalsConverter() { DeleteContainerSeconds(GlobalVarAddressMap); }
645
646 /// Converts global variables, and their initializers into ICE global
647 /// addresses, for module Mod. Puts corresponding converted global
648 /// addresses into GlobalAddresses.
649 void convertGlobalsToIce(Module *Mod,
650 Ice::Translator::GlobalAddressList &GlobalAddresses);
651
652 private:
653 typedef std::map<const GlobalVariable *, Ice::GlobalAddress *>
654 GlobalVarAddressMapType;
655 // Map from global variables to their corresponding global address.
656 GlobalVarAddressMapType GlobalVarAddressMap;
657
658 // Adds the Initializer to the list of initializers for Global address.
659 void addGlobalInitializer(Ice::GlobalAddress &Global,
660 const Constant *Initializer) {
661 const bool HasOffset = false;
662 const Ice::GlobalAddress::RelocOffsetType Offset = 0;
663 addGlobalInitializer(Global, Initializer, HasOffset, Offset);
664 }
665
666 // Adds Initializer to the list of initializers for Global
667 // address. HasOffset is true only if Initializer is a relocation
668 // initializer and Offset should be added to the relocation.
669 void addGlobalInitializer(Ice::GlobalAddress &Global,
670 const Constant *Initializer, bool HasOffset,
671 Ice::GlobalAddress::RelocOffsetType Offset);
672
673 // Returns the global address associated with global variable GV.
674 Ice::GlobalAddress *getGlobalVarAddress(const GlobalVariable *GV) {
675 if (GlobalVarAddressMap.find(GV) == GlobalVarAddressMap.end())
676 GlobalVarAddressMap[GV] = new Ice::GlobalAddress();
677 return GlobalVarAddressMap[GV];
678 }
679
680 // Converts the given constant C to the corresponding integer
681 // literal it contains.
682 Ice::GlobalAddress::RelocOffsetType
683 getIntegerLiteralConstant(const Value *C) {
684 const auto CI = dyn_cast<ConstantInt>(C);
685 if (CI && CI->getType()->isIntegerTy(32))
686 return CI->getSExtValue();
687
688 std::string Buffer;
689 raw_string_ostream StrBuf(Buffer);
690 StrBuf << "Constant not i32 literal: " << *C;
691 report_fatal_error(StrBuf.str());
692 return 0;
693 }
694 };
695
696 void LLVM2ICEGlobalsConverter::convertGlobalsToIce(
697 Module *Mod, Ice::Translator::GlobalAddressList &GlobalAddresses) {
698 for (Module::const_global_iterator I = Mod->global_begin(),
699 E = Mod->global_end();
700 I != E; ++I) {
701 if (!I->hasInitializer() && Ctx->getFlags().AllowUninitializedGlobals)
702 continue;
703
704 const auto GV = dyn_cast<GlobalVariable>(I);
705 assert(GV);
706 Ice::IceString Name = GV->getName();
707 if (!GV->hasInternalLinkage()) {
708 std::string Buffer;
709 raw_string_ostream StrBuf(Buffer);
710 StrBuf << "Can't define external global address: " << Name;
711 report_fatal_error(StrBuf.str());
712 }
713
714 Ice::GlobalAddress *Addr = getGlobalVarAddress(GV);
715 GlobalAddresses.push_back(Addr);
716 Addr->setAlignment(GV->getAlignment());
717 Addr->setIsConstant(GV->isConstant());
718 // Note: We allow external for cross tests.
719 Addr->setIsInternal(!GV->isExternallyInitialized());
720 Addr->setName(Name);
721
722 const Constant *Initializer = GV->getInitializer();
723 if (const auto CompoundInit = dyn_cast<ConstantStruct>(Initializer)) {
724 for (ConstantStruct::const_op_iterator I = CompoundInit->op_begin(),
725 E = CompoundInit->op_end();
726 I != E; ++I) {
727 if (const auto Init = dyn_cast<Constant>(I)) {
728 addGlobalInitializer(*Addr, Init);
729 }
730 }
731 } else {
732 addGlobalInitializer(*Addr, Initializer);
733 }
734 }
735 }
736
737 void LLVM2ICEGlobalsConverter::addGlobalInitializer(
738 Ice::GlobalAddress &Global, const Constant *Initializer, bool HasOffset,
739 Ice::GlobalAddress::RelocOffsetType Offset) {
740 assert(HasOffset || Offset == 0);
741
742 if (const auto CDA = dyn_cast<ConstantDataArray>(Initializer)) {
743 assert(!HasOffset && isa<IntegerType>(CDA->getElementType()) &&
744 (cast<IntegerType>(CDA->getElementType())->getBitWidth() == 8));
745 Global.addInitializer(new Ice::GlobalAddress::DataInitializer(
746 CDA->getRawDataValues().data(), CDA->getNumElements()));
747 return;
748 }
749
750 if (isa<ConstantAggregateZero>(Initializer)) {
751 if (const auto AT = dyn_cast<ArrayType>(Initializer->getType())) {
752 assert(!HasOffset && isa<IntegerType>(AT->getElementType()) &&
753 (cast<IntegerType>(AT->getElementType())->getBitWidth() == 8));
754 Global.addInitializer(
755 new Ice::GlobalAddress::ZeroInitializer(AT->getNumElements()));
756 } else {
757 llvm_unreachable("Unhandled constant aggregate zero type");
758 }
759 return;
760 }
761
762 if (const auto Exp = dyn_cast<ConstantExpr>(Initializer)) {
763 switch (Exp->getOpcode()) {
764 case Instruction::Add:
765 assert(!HasOffset);
766 addGlobalInitializer(Global, Exp->getOperand(0), true,
767 getIntegerLiteralConstant(Exp->getOperand(1)));
768 return;
769 case Instruction::PtrToInt: {
770 assert(TypeConverter.convertToIceType(Exp->getType()) ==
771 TypeConverter.getIcePointerType());
772 const auto GV = dyn_cast<GlobalValue>(Exp->getOperand(0));
773 assert(GV);
774 if (const auto Fcn = dyn_cast<Function>(GV)) {
775 Ice::GlobalAddress::RelocationAddress Addr(Fcn);
776 Global.addInitializer(
777 new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
778 return;
779 } else if (const auto Var = dyn_cast<GlobalVariable>(GV)) {
780 Ice::GlobalAddress::RelocationAddress Addr(getGlobalVarAddress(Var));
781 Global.addInitializer(
782 new Ice::GlobalAddress::RelocInitializer(Addr, Offset));
783 return;
784 }
785 break;
786 }
787 default:
788 break;
789 }
790 }
791
792 std::string Buffer;
793 raw_string_ostream StrBuf(Buffer);
794 StrBuf << "Unhandled global initializer: " << Initializer;
795 report_fatal_error(StrBuf.str());
796 }
797
615 } // end of anonymous namespace 798 } // end of anonymous namespace
616 799
617 namespace Ice { 800 namespace Ice {
618 801
619 void Converter::convertToIce() { 802 void Converter::convertToIce() {
620 static TimerIdT IDconvertToIce = GlobalContext::getTimerID("convertToIce"); 803 static TimerIdT IDconvertToIce = GlobalContext::getTimerID("convertToIce");
621 TimerMarker T(IDconvertToIce, Ctx); 804 TimerMarker T(IDconvertToIce, Ctx);
622 nameUnnamedGlobalAddresses(Mod); 805 nameUnnamedGlobalAddresses(Mod);
806 nameUnnamedFunctions(Mod);
623 if (!Ctx->getFlags().DisableGlobals) 807 if (!Ctx->getFlags().DisableGlobals)
624 convertGlobals(Mod); 808 convertGlobals(Mod);
625 convertFunctions(); 809 convertFunctions();
626 } 810 }
627 811
812 void Converter::convertGlobals(Module *Mod) {
813 LLVM2ICEGlobalsConverter GlobalsConverter(Ctx, Mod->getContext());
814 Translator::GlobalAddressList GlobalAddresses;
815 GlobalsConverter.convertGlobalsToIce(Mod, GlobalAddresses);
816 lowerGlobals(GlobalAddresses);
817 }
818
628 void Converter::convertFunctions() { 819 void Converter::convertFunctions() {
629 for (const Function &I : *Mod) { 820 for (const Function &I : *Mod) {
630 if (I.empty()) 821 if (I.empty())
631 continue; 822 continue;
632 LLVM2ICEConverter FunctionConverter(Ctx, Mod->getContext()); 823 LLVM2ICEFunctionConverter FunctionConverter(Ctx, Mod->getContext());
633 824
634 Cfg *Fcn = FunctionConverter.convertFunction(&I); 825 Cfg *Fcn = FunctionConverter.convertFunction(&I);
635 translateFcn(Fcn); 826 translateFcn(Fcn);
636 } 827 }
637 828
638 emitConstants(); 829 emitConstants();
639 } 830 }
640 831
641 } // end of namespace Ice 832 } // end of namespace Ice
OLDNEW
« no previous file with comments | « src/IceConverter.h ('k') | src/IceGlobalInits.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698