Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1 | //===- BitcodeReader.cpp - Internal BitcodeReader implementation ----------===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This header defines the BitcodeReader class. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 14 | #include "llvm/Bitcode/ReaderWriter.h" |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 15 | #include "BitcodeReader.h" |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 16 | #include "llvm/Constants.h" |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 17 | #include "llvm/DerivedTypes.h" |
Chris Lattner | 2bce93a | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 18 | #include "llvm/InlineAsm.h" |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 19 | #include "llvm/IntrinsicInst.h" |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 20 | #include "llvm/Module.h" |
Dan Gohman | 1224c38 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 21 | #include "llvm/Operator.h" |
Chandler Carruth | 6994040 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 22 | #include "llvm/AutoUpgrade.h" |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/SmallString.h" |
Devang Patel | f4511cd | 2008-02-26 19:38:17 +0000 | [diff] [blame] | 24 | #include "llvm/ADT/SmallVector.h" |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 25 | #include "llvm/Support/DataStream.h" |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 26 | #include "llvm/Support/MathExtras.h" |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 27 | #include "llvm/Support/MemoryBuffer.h" |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 28 | #include "llvm/OperandTraits.h" |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 29 | using namespace llvm; |
| 30 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 31 | enum { |
| 32 | SWITCH_INST_MAGIC = 0x4B5 // May 2012 => 1205 => Hex |
| 33 | }; |
| 34 | |
Rafael Espindola | 47f79bb | 2012-01-02 07:49:53 +0000 | [diff] [blame] | 35 | void BitcodeReader::materializeForwardReferencedFunctions() { |
| 36 | while (!BlockAddrFwdRefs.empty()) { |
| 37 | Function *F = BlockAddrFwdRefs.begin()->first; |
| 38 | F->Materialize(); |
| 39 | } |
| 40 | } |
| 41 | |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 42 | void BitcodeReader::FreeState() { |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 43 | if (BufferOwned) |
| 44 | delete Buffer; |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 45 | Buffer = 0; |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 46 | std::vector<Type*>().swap(TypeList); |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 47 | ValueList.clear(); |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 48 | MDValueList.clear(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 49 | |
Devang Patel | 19c8746 | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 50 | std::vector<AttrListPtr>().swap(MAttributes); |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 51 | std::vector<BasicBlock*>().swap(FunctionBBs); |
| 52 | std::vector<Function*>().swap(FunctionsWithBodies); |
| 53 | DeferredFunctionInfo.clear(); |
Dan Gohman | 19538d1 | 2010-07-20 21:42:28 +0000 | [diff] [blame] | 54 | MDKindMap.clear(); |
Benjamin Kramer | 122f5e5 | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 55 | |
| 56 | assert(BlockAddrFwdRefs.empty() && "Unresolved blockaddress fwd references"); |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 57 | } |
| 58 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 59 | //===----------------------------------------------------------------------===// |
| 60 | // Helper functions to implement forward reference resolution, etc. |
| 61 | //===----------------------------------------------------------------------===// |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 62 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 63 | /// ConvertToString - Convert a string from a record into an std::string, return |
| 64 | /// true on failure. |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 65 | template<typename StrTy> |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 66 | static bool ConvertToString(ArrayRef<uint64_t> Record, unsigned Idx, |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 67 | StrTy &Result) { |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 68 | if (Idx > Record.size()) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 69 | return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 70 | |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 71 | for (unsigned i = Idx, e = Record.size(); i != e; ++i) |
| 72 | Result += (char)Record[i]; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 73 | return false; |
| 74 | } |
| 75 | |
| 76 | static GlobalValue::LinkageTypes GetDecodedLinkage(unsigned Val) { |
| 77 | switch (Val) { |
| 78 | default: // Map unknown/new linkages to external |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 79 | case 0: return GlobalValue::ExternalLinkage; |
| 80 | case 1: return GlobalValue::WeakAnyLinkage; |
| 81 | case 2: return GlobalValue::AppendingLinkage; |
| 82 | case 3: return GlobalValue::InternalLinkage; |
| 83 | case 4: return GlobalValue::LinkOnceAnyLinkage; |
| 84 | case 5: return GlobalValue::DLLImportLinkage; |
| 85 | case 6: return GlobalValue::DLLExportLinkage; |
| 86 | case 7: return GlobalValue::ExternalWeakLinkage; |
| 87 | case 8: return GlobalValue::CommonLinkage; |
| 88 | case 9: return GlobalValue::PrivateLinkage; |
Duncan Sands | 667d4b8 | 2009-03-07 15:45:40 +0000 | [diff] [blame] | 89 | case 10: return GlobalValue::WeakODRLinkage; |
| 90 | case 11: return GlobalValue::LinkOnceODRLinkage; |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 91 | case 12: return GlobalValue::AvailableExternallyLinkage; |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 92 | case 13: return GlobalValue::LinkerPrivateLinkage; |
Bill Wendling | 5e721d7 | 2010-07-01 21:55:59 +0000 | [diff] [blame] | 93 | case 14: return GlobalValue::LinkerPrivateWeakLinkage; |
Bill Wendling | 32811be | 2012-08-17 18:33:14 +0000 | [diff] [blame] | 94 | case 15: return GlobalValue::LinkOnceODRAutoHideLinkage; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 95 | } |
| 96 | } |
| 97 | |
| 98 | static GlobalValue::VisibilityTypes GetDecodedVisibility(unsigned Val) { |
| 99 | switch (Val) { |
| 100 | default: // Map unknown visibilities to default. |
| 101 | case 0: return GlobalValue::DefaultVisibility; |
| 102 | case 1: return GlobalValue::HiddenVisibility; |
Anton Korobeynikov | 9cd3ccf | 2007-04-29 20:56:48 +0000 | [diff] [blame] | 103 | case 2: return GlobalValue::ProtectedVisibility; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 104 | } |
| 105 | } |
| 106 | |
Hans Wennborg | ce718ff | 2012-06-23 11:37:03 +0000 | [diff] [blame] | 107 | static GlobalVariable::ThreadLocalMode GetDecodedThreadLocalMode(unsigned Val) { |
| 108 | switch (Val) { |
| 109 | case 0: return GlobalVariable::NotThreadLocal; |
| 110 | default: // Map unknown non-zero value to general dynamic. |
| 111 | case 1: return GlobalVariable::GeneralDynamicTLSModel; |
| 112 | case 2: return GlobalVariable::LocalDynamicTLSModel; |
| 113 | case 3: return GlobalVariable::InitialExecTLSModel; |
| 114 | case 4: return GlobalVariable::LocalExecTLSModel; |
| 115 | } |
| 116 | } |
| 117 | |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 118 | static int GetDecodedCastOpcode(unsigned Val) { |
| 119 | switch (Val) { |
| 120 | default: return -1; |
| 121 | case bitc::CAST_TRUNC : return Instruction::Trunc; |
| 122 | case bitc::CAST_ZEXT : return Instruction::ZExt; |
| 123 | case bitc::CAST_SEXT : return Instruction::SExt; |
| 124 | case bitc::CAST_FPTOUI : return Instruction::FPToUI; |
| 125 | case bitc::CAST_FPTOSI : return Instruction::FPToSI; |
| 126 | case bitc::CAST_UITOFP : return Instruction::UIToFP; |
| 127 | case bitc::CAST_SITOFP : return Instruction::SIToFP; |
| 128 | case bitc::CAST_FPTRUNC : return Instruction::FPTrunc; |
| 129 | case bitc::CAST_FPEXT : return Instruction::FPExt; |
| 130 | case bitc::CAST_PTRTOINT: return Instruction::PtrToInt; |
| 131 | case bitc::CAST_INTTOPTR: return Instruction::IntToPtr; |
| 132 | case bitc::CAST_BITCAST : return Instruction::BitCast; |
| 133 | } |
| 134 | } |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 135 | static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) { |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 136 | switch (Val) { |
| 137 | default: return -1; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 138 | case bitc::BINOP_ADD: |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 139 | return Ty->isFPOrFPVectorTy() ? Instruction::FAdd : Instruction::Add; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 140 | case bitc::BINOP_SUB: |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 141 | return Ty->isFPOrFPVectorTy() ? Instruction::FSub : Instruction::Sub; |
Dan Gohman | ae3a0be | 2009-06-04 22:49:04 +0000 | [diff] [blame] | 142 | case bitc::BINOP_MUL: |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 143 | return Ty->isFPOrFPVectorTy() ? Instruction::FMul : Instruction::Mul; |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 144 | case bitc::BINOP_UDIV: return Instruction::UDiv; |
| 145 | case bitc::BINOP_SDIV: |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 146 | return Ty->isFPOrFPVectorTy() ? Instruction::FDiv : Instruction::SDiv; |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 147 | case bitc::BINOP_UREM: return Instruction::URem; |
| 148 | case bitc::BINOP_SREM: |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 149 | return Ty->isFPOrFPVectorTy() ? Instruction::FRem : Instruction::SRem; |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 150 | case bitc::BINOP_SHL: return Instruction::Shl; |
| 151 | case bitc::BINOP_LSHR: return Instruction::LShr; |
| 152 | case bitc::BINOP_ASHR: return Instruction::AShr; |
| 153 | case bitc::BINOP_AND: return Instruction::And; |
| 154 | case bitc::BINOP_OR: return Instruction::Or; |
| 155 | case bitc::BINOP_XOR: return Instruction::Xor; |
| 156 | } |
| 157 | } |
| 158 | |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 159 | static AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) { |
| 160 | switch (Val) { |
| 161 | default: return AtomicRMWInst::BAD_BINOP; |
| 162 | case bitc::RMW_XCHG: return AtomicRMWInst::Xchg; |
| 163 | case bitc::RMW_ADD: return AtomicRMWInst::Add; |
| 164 | case bitc::RMW_SUB: return AtomicRMWInst::Sub; |
| 165 | case bitc::RMW_AND: return AtomicRMWInst::And; |
| 166 | case bitc::RMW_NAND: return AtomicRMWInst::Nand; |
| 167 | case bitc::RMW_OR: return AtomicRMWInst::Or; |
| 168 | case bitc::RMW_XOR: return AtomicRMWInst::Xor; |
| 169 | case bitc::RMW_MAX: return AtomicRMWInst::Max; |
| 170 | case bitc::RMW_MIN: return AtomicRMWInst::Min; |
| 171 | case bitc::RMW_UMAX: return AtomicRMWInst::UMax; |
| 172 | case bitc::RMW_UMIN: return AtomicRMWInst::UMin; |
| 173 | } |
| 174 | } |
| 175 | |
Eli Friedman | 47f3513 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 176 | static AtomicOrdering GetDecodedOrdering(unsigned Val) { |
| 177 | switch (Val) { |
| 178 | case bitc::ORDERING_NOTATOMIC: return NotAtomic; |
| 179 | case bitc::ORDERING_UNORDERED: return Unordered; |
| 180 | case bitc::ORDERING_MONOTONIC: return Monotonic; |
| 181 | case bitc::ORDERING_ACQUIRE: return Acquire; |
| 182 | case bitc::ORDERING_RELEASE: return Release; |
| 183 | case bitc::ORDERING_ACQREL: return AcquireRelease; |
| 184 | default: // Map unknown orderings to sequentially-consistent. |
| 185 | case bitc::ORDERING_SEQCST: return SequentiallyConsistent; |
| 186 | } |
| 187 | } |
| 188 | |
| 189 | static SynchronizationScope GetDecodedSynchScope(unsigned Val) { |
| 190 | switch (Val) { |
| 191 | case bitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread; |
| 192 | default: // Map unknown scopes to cross-thread. |
| 193 | case bitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread; |
| 194 | } |
| 195 | } |
| 196 | |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 197 | namespace llvm { |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 198 | namespace { |
| 199 | /// @brief A class for maintaining the slot number definition |
| 200 | /// as a placeholder for the actual definition for forward constants defs. |
| 201 | class ConstantPlaceHolder : public ConstantExpr { |
Craig Topper | 86a1c32 | 2012-09-15 17:09:36 +0000 | [diff] [blame] | 202 | void operator=(const ConstantPlaceHolder &) LLVM_DELETED_FUNCTION; |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 203 | public: |
| 204 | // allocate space for exactly one operand |
| 205 | void *operator new(size_t s) { |
| 206 | return User::operator new(s, 1); |
| 207 | } |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 208 | explicit ConstantPlaceHolder(Type *Ty, LLVMContext& Context) |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 209 | : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 210 | Op<0>() = UndefValue::get(Type::getInt32Ty(Context)); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 211 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 212 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 213 | /// @brief Methods to support type inquiry through isa, cast, and dyn_cast. |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 214 | static bool classof(const Value *V) { |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 215 | return isa<ConstantExpr>(V) && |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 216 | cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1; |
| 217 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 218 | |
| 219 | |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 220 | /// Provide fast operand accessors |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 221 | //DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 222 | }; |
| 223 | } |
| 224 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 225 | // FIXME: can we inherit this from ConstantExpr? |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 226 | template <> |
Jay Foad | 67c619b | 2011-01-11 15:07:38 +0000 | [diff] [blame] | 227 | struct OperandTraits<ConstantPlaceHolder> : |
| 228 | public FixedNumOperandTraits<ConstantPlaceHolder, 1> { |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 229 | }; |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 230 | } |
| 231 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 232 | |
| 233 | void BitcodeReaderValueList::AssignValue(Value *V, unsigned Idx) { |
| 234 | if (Idx == size()) { |
| 235 | push_back(V); |
| 236 | return; |
| 237 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 238 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 239 | if (Idx >= size()) |
| 240 | resize(Idx+1); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 241 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 242 | WeakVH &OldV = ValuePtrs[Idx]; |
| 243 | if (OldV == 0) { |
| 244 | OldV = V; |
| 245 | return; |
| 246 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 247 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 248 | // Handle constants and non-constants (e.g. instrs) differently for |
| 249 | // efficiency. |
| 250 | if (Constant *PHC = dyn_cast<Constant>(&*OldV)) { |
| 251 | ResolveConstants.push_back(std::make_pair(PHC, Idx)); |
| 252 | OldV = V; |
| 253 | } else { |
| 254 | // If there was a forward reference to this value, replace it. |
| 255 | Value *PrevVal = OldV; |
| 256 | OldV->replaceAllUsesWith(V); |
| 257 | delete PrevVal; |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 258 | } |
| 259 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 260 | |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 261 | |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 262 | Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 263 | Type *Ty) { |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 264 | if (Idx >= size()) |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 265 | resize(Idx + 1); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 266 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 267 | if (Value *V = ValuePtrs[Idx]) { |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 268 | assert(Ty == V->getType() && "Type mismatch in constant table!"); |
| 269 | return cast<Constant>(V); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 270 | } |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 271 | |
| 272 | // Create and return a placeholder, which will later be RAUW'd. |
Owen Anderson | 74a7781 | 2009-07-07 20:18:58 +0000 | [diff] [blame] | 273 | Constant *C = new ConstantPlaceHolder(Ty, Context); |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 274 | ValuePtrs[Idx] = C; |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 275 | return C; |
| 276 | } |
| 277 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 278 | Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty) { |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 279 | if (Idx >= size()) |
Gabor Greif | efe6536 | 2008-05-10 08:32:32 +0000 | [diff] [blame] | 280 | resize(Idx + 1); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 281 | |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 282 | if (Value *V = ValuePtrs[Idx]) { |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 283 | assert((Ty == 0 || Ty == V->getType()) && "Type mismatch in value table!"); |
| 284 | return V; |
| 285 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 286 | |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 287 | // No type specified, must be invalid reference. |
| 288 | if (Ty == 0) return 0; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 289 | |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 290 | // Create and return a placeholder, which will later be RAUW'd. |
| 291 | Value *V = new Argument(Ty); |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 292 | ValuePtrs[Idx] = V; |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 293 | return V; |
| 294 | } |
| 295 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 296 | /// ResolveConstantForwardRefs - Once all constants are read, this method bulk |
| 297 | /// resolves any forward references. The idea behind this is that we sometimes |
| 298 | /// get constants (such as large arrays) which reference *many* forward ref |
| 299 | /// constants. Replacing each of these causes a lot of thrashing when |
| 300 | /// building/reuniquing the constant. Instead of doing this, we look at all the |
| 301 | /// uses and rewrite all the place holders at once for any constant that uses |
| 302 | /// a placeholder. |
| 303 | void BitcodeReaderValueList::ResolveConstantForwardRefs() { |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 304 | // Sort the values by-pointer so that they are efficient to look up with a |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 305 | // binary search. |
| 306 | std::sort(ResolveConstants.begin(), ResolveConstants.end()); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 307 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 308 | SmallVector<Constant*, 64> NewOps; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 309 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 310 | while (!ResolveConstants.empty()) { |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 311 | Value *RealVal = operator[](ResolveConstants.back().second); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 312 | Constant *Placeholder = ResolveConstants.back().first; |
| 313 | ResolveConstants.pop_back(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 314 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 315 | // Loop over all users of the placeholder, updating them to reference the |
| 316 | // new value. If they reference more than one placeholder, update them all |
| 317 | // at once. |
| 318 | while (!Placeholder->use_empty()) { |
Chris Lattner | b6135a0 | 2008-08-21 17:31:45 +0000 | [diff] [blame] | 319 | Value::use_iterator UI = Placeholder->use_begin(); |
Gabor Greif | c654d1b | 2010-07-09 16:01:21 +0000 | [diff] [blame] | 320 | User *U = *UI; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 321 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 322 | // If the using object isn't uniqued, just update the operands. This |
| 323 | // handles instructions and initializers for global variables. |
Gabor Greif | c654d1b | 2010-07-09 16:01:21 +0000 | [diff] [blame] | 324 | if (!isa<Constant>(U) || isa<GlobalValue>(U)) { |
Chris Lattner | b6135a0 | 2008-08-21 17:31:45 +0000 | [diff] [blame] | 325 | UI.getUse().set(RealVal); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 326 | continue; |
| 327 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 328 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 329 | // Otherwise, we have a constant that uses the placeholder. Replace that |
| 330 | // constant with a new constant that has *all* placeholder uses updated. |
Gabor Greif | c654d1b | 2010-07-09 16:01:21 +0000 | [diff] [blame] | 331 | Constant *UserC = cast<Constant>(U); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 332 | for (User::op_iterator I = UserC->op_begin(), E = UserC->op_end(); |
| 333 | I != E; ++I) { |
| 334 | Value *NewOp; |
| 335 | if (!isa<ConstantPlaceHolder>(*I)) { |
| 336 | // Not a placeholder reference. |
| 337 | NewOp = *I; |
| 338 | } else if (*I == Placeholder) { |
| 339 | // Common case is that it just references this one placeholder. |
| 340 | NewOp = RealVal; |
| 341 | } else { |
| 342 | // Otherwise, look up the placeholder in ResolveConstants. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 343 | ResolveConstantsTy::iterator It = |
| 344 | std::lower_bound(ResolveConstants.begin(), ResolveConstants.end(), |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 345 | std::pair<Constant*, unsigned>(cast<Constant>(*I), |
| 346 | 0)); |
| 347 | assert(It != ResolveConstants.end() && It->first == *I); |
Chris Lattner | 46e7740 | 2009-03-31 22:55:09 +0000 | [diff] [blame] | 348 | NewOp = operator[](It->second); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 349 | } |
| 350 | |
| 351 | NewOps.push_back(cast<Constant>(NewOp)); |
| 352 | } |
| 353 | |
| 354 | // Make the new constant. |
| 355 | Constant *NewC; |
| 356 | if (ConstantArray *UserCA = dyn_cast<ConstantArray>(UserC)) { |
Jay Foad | 2670108 | 2011-06-22 09:24:39 +0000 | [diff] [blame] | 357 | NewC = ConstantArray::get(UserCA->getType(), NewOps); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 358 | } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) { |
Chris Lattner | b065b06 | 2011-06-20 04:01:31 +0000 | [diff] [blame] | 359 | NewC = ConstantStruct::get(UserCS->getType(), NewOps); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 360 | } else if (isa<ConstantVector>(UserC)) { |
Chris Lattner | 2ca5c86 | 2011-02-15 00:14:00 +0000 | [diff] [blame] | 361 | NewC = ConstantVector::get(NewOps); |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 362 | } else { |
| 363 | assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr."); |
Jay Foad | b81e457 | 2011-04-13 13:46:01 +0000 | [diff] [blame] | 364 | NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 365 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 366 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 367 | UserC->replaceAllUsesWith(NewC); |
| 368 | UserC->destroyConstant(); |
| 369 | NewOps.clear(); |
| 370 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 371 | |
Nick Lewycky | cb33799 | 2009-05-10 20:57:05 +0000 | [diff] [blame] | 372 | // Update all ValueHandles, they should be the only users at this point. |
| 373 | Placeholder->replaceAllUsesWith(RealVal); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 374 | delete Placeholder; |
| 375 | } |
| 376 | } |
| 377 | |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 378 | void BitcodeReaderMDValueList::AssignValue(Value *V, unsigned Idx) { |
| 379 | if (Idx == size()) { |
| 380 | push_back(V); |
| 381 | return; |
| 382 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 383 | |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 384 | if (Idx >= size()) |
| 385 | resize(Idx+1); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 386 | |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 387 | WeakVH &OldV = MDValuePtrs[Idx]; |
| 388 | if (OldV == 0) { |
| 389 | OldV = V; |
| 390 | return; |
| 391 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 392 | |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 393 | // If there was a forward reference to this value, replace it. |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 394 | MDNode *PrevVal = cast<MDNode>(OldV); |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 395 | OldV->replaceAllUsesWith(V); |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 396 | MDNode::deleteTemporary(PrevVal); |
Devang Patel | c0ff8c8 | 2009-09-03 01:38:02 +0000 | [diff] [blame] | 397 | // Deleting PrevVal sets Idx value in MDValuePtrs to null. Set new |
| 398 | // value for Idx. |
| 399 | MDValuePtrs[Idx] = V; |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 400 | } |
| 401 | |
| 402 | Value *BitcodeReaderMDValueList::getValueFwdRef(unsigned Idx) { |
| 403 | if (Idx >= size()) |
| 404 | resize(Idx + 1); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 405 | |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 406 | if (Value *V = MDValuePtrs[Idx]) { |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 407 | assert(V->getType()->isMetadataTy() && "Type mismatch in value table!"); |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 408 | return V; |
| 409 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 410 | |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 411 | // Create and return a placeholder, which will later be RAUW'd. |
Jay Foad | ec9186b | 2011-04-21 19:59:31 +0000 | [diff] [blame] | 412 | Value *V = MDNode::getTemporary(Context, ArrayRef<Value*>()); |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 413 | MDValuePtrs[Idx] = V; |
| 414 | return V; |
| 415 | } |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 416 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 417 | Type *BitcodeReader::getTypeByID(unsigned ID) { |
| 418 | // The type table size is always specified correctly. |
| 419 | if (ID >= TypeList.size()) |
| 420 | return 0; |
Derek Schuff | fccf062 | 2012-02-06 19:03:04 +0000 | [diff] [blame] | 421 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 422 | if (Type *Ty = TypeList[ID]) |
| 423 | return Ty; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 424 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 425 | // If we have a forward reference, the only possible case is when it is to a |
| 426 | // named struct. Just create a placeholder for now. |
Chris Lattner | 3ebb649 | 2011-08-12 18:06:37 +0000 | [diff] [blame] | 427 | return TypeList[ID] = StructType::create(Context); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 428 | } |
| 429 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 430 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 431 | //===----------------------------------------------------------------------===// |
| 432 | // Functions for parsing blocks from the bitcode file |
| 433 | //===----------------------------------------------------------------------===// |
| 434 | |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 435 | bool BitcodeReader::ParseAttributeBlock() { |
Chris Lattner | e17b658 | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 436 | if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID)) |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 437 | return Error("Malformed block record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 438 | |
Devang Patel | 19c8746 | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 439 | if (!MAttributes.empty()) |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 440 | return Error("Multiple PARAMATTR blocks found!"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 441 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 442 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 443 | |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 444 | SmallVector<AttributeWithIndex, 8> Attrs; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 445 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 446 | // Read all the records. |
| 447 | while (1) { |
| 448 | unsigned Code = Stream.ReadCode(); |
| 449 | if (Code == bitc::END_BLOCK) { |
| 450 | if (Stream.ReadBlockEnd()) |
| 451 | return Error("Error at end of PARAMATTR block"); |
| 452 | return false; |
| 453 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 454 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 455 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 456 | // No known subblocks, always skip them. |
| 457 | Stream.ReadSubBlockID(); |
| 458 | if (Stream.SkipBlock()) |
| 459 | return Error("Malformed block record"); |
| 460 | continue; |
| 461 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 462 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 463 | if (Code == bitc::DEFINE_ABBREV) { |
| 464 | Stream.ReadAbbrevRecord(); |
| 465 | continue; |
| 466 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 467 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 468 | // Read a record. |
| 469 | Record.clear(); |
| 470 | switch (Stream.ReadRecord(Code, Record)) { |
| 471 | default: // Default behavior: ignore. |
| 472 | break; |
| 473 | case bitc::PARAMATTR_CODE_ENTRY: { // ENTRY: [paramidx0, attr0, ...] |
| 474 | if (Record.size() & 1) |
| 475 | return Error("Invalid ENTRY record"); |
| 476 | |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 477 | for (unsigned i = 0, e = Record.size(); i != e; i += 2) { |
Meador Inge | e99f8be | 2012-05-28 15:45:43 +0000 | [diff] [blame] | 478 | Attributes ReconstitutedAttr = |
Bill Wendling | cb3de0b | 2012-10-15 04:46:55 +0000 | [diff] [blame] | 479 | Attributes::decodeLLVMAttributesForBitcode(Context, Record[i+1]); |
Kostya Serebryany | 164b86b | 2012-01-20 17:56:17 +0000 | [diff] [blame] | 480 | Record[i+1] = ReconstitutedAttr.Raw(); |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 481 | } |
Chris Lattner | 461edd9 | 2008-03-12 02:25:52 +0000 | [diff] [blame] | 482 | |
Devang Patel | 19c8746 | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 483 | for (unsigned i = 0, e = Record.size(); i != e; i += 2) { |
Bill Wendling | 702cc91 | 2012-10-15 20:35:56 +0000 | [diff] [blame] | 484 | AttrBuilder B(Record[i+1]); |
Bill Wendling | cb3de0b | 2012-10-15 04:46:55 +0000 | [diff] [blame] | 485 | if (B.hasAttributes()) |
Kostya Serebryany | 164b86b | 2012-01-20 17:56:17 +0000 | [diff] [blame] | 486 | Attrs.push_back(AttributeWithIndex::get(Record[i], |
Bill Wendling | cb3de0b | 2012-10-15 04:46:55 +0000 | [diff] [blame] | 487 | Attributes::get(Context, B))); |
Devang Patel | 19c8746 | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 488 | } |
Devang Patel | 19c8746 | 2008-09-26 22:53:05 +0000 | [diff] [blame] | 489 | |
Bill Wendling | 0976e00 | 2012-11-20 05:09:20 +0000 | [diff] [blame] | 490 | MAttributes.push_back(AttrListPtr::get(Context, Attrs)); |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 491 | Attrs.clear(); |
| 492 | break; |
| 493 | } |
Duncan Sands | 5e41f65 | 2007-11-20 14:09:29 +0000 | [diff] [blame] | 494 | } |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 495 | } |
| 496 | } |
| 497 | |
Chris Lattner | 8669714 | 2007-05-01 05:01:34 +0000 | [diff] [blame] | 498 | bool BitcodeReader::ParseTypeTable() { |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 499 | if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW)) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 500 | return Error("Malformed block record"); |
Derek Schuff | fccf062 | 2012-02-06 19:03:04 +0000 | [diff] [blame] | 501 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 502 | return ParseTypeTableBody(); |
| 503 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 504 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 505 | bool BitcodeReader::ParseTypeTableBody() { |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 506 | if (!TypeList.empty()) |
| 507 | return Error("Multiple TYPE_BLOCKs found!"); |
| 508 | |
| 509 | SmallVector<uint64_t, 64> Record; |
| 510 | unsigned NumRecords = 0; |
| 511 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 512 | SmallString<64> TypeName; |
Derek Schuff | fccf062 | 2012-02-06 19:03:04 +0000 | [diff] [blame] | 513 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 514 | // Read all the records for this type table. |
| 515 | while (1) { |
| 516 | unsigned Code = Stream.ReadCode(); |
| 517 | if (Code == bitc::END_BLOCK) { |
| 518 | if (NumRecords != TypeList.size()) |
| 519 | return Error("Invalid type forward reference in TYPE_BLOCK"); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 520 | if (Stream.ReadBlockEnd()) |
| 521 | return Error("Error at end of type table block"); |
| 522 | return false; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 523 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 524 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 525 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 526 | // No known subblocks, always skip them. |
| 527 | Stream.ReadSubBlockID(); |
| 528 | if (Stream.SkipBlock()) |
| 529 | return Error("Malformed block record"); |
| 530 | continue; |
| 531 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 532 | |
Chris Lattner | 36d5e7d | 2007-04-23 16:04:05 +0000 | [diff] [blame] | 533 | if (Code == bitc::DEFINE_ABBREV) { |
Chris Lattner | d127c1b | 2007-04-23 18:58:34 +0000 | [diff] [blame] | 534 | Stream.ReadAbbrevRecord(); |
| 535 | continue; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 536 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 537 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 538 | // Read a record. |
| 539 | Record.clear(); |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 540 | Type *ResultTy = 0; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 541 | switch (Stream.ReadRecord(Code, Record)) { |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 542 | default: return Error("unknown type in type table"); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 543 | case bitc::TYPE_CODE_NUMENTRY: // TYPE_CODE_NUMENTRY: [numentries] |
| 544 | // TYPE_CODE_NUMENTRY contains a count of the number of types in the |
| 545 | // type list. This allows us to reserve space. |
| 546 | if (Record.size() < 1) |
| 547 | return Error("Invalid TYPE_CODE_NUMENTRY record"); |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 548 | TypeList.resize(Record[0]); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 549 | continue; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 550 | case bitc::TYPE_CODE_VOID: // VOID |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 551 | ResultTy = Type::getVoidTy(Context); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 552 | break; |
Dan Gohman | ce16339 | 2011-12-17 00:04:22 +0000 | [diff] [blame] | 553 | case bitc::TYPE_CODE_HALF: // HALF |
| 554 | ResultTy = Type::getHalfTy(Context); |
| 555 | break; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 556 | case bitc::TYPE_CODE_FLOAT: // FLOAT |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 557 | ResultTy = Type::getFloatTy(Context); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 558 | break; |
| 559 | case bitc::TYPE_CODE_DOUBLE: // DOUBLE |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 560 | ResultTy = Type::getDoubleTy(Context); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 561 | break; |
Dale Johannesen | 320fc8a | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 562 | case bitc::TYPE_CODE_X86_FP80: // X86_FP80 |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 563 | ResultTy = Type::getX86_FP80Ty(Context); |
Dale Johannesen | 320fc8a | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 564 | break; |
| 565 | case bitc::TYPE_CODE_FP128: // FP128 |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 566 | ResultTy = Type::getFP128Ty(Context); |
Dale Johannesen | 320fc8a | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 567 | break; |
| 568 | case bitc::TYPE_CODE_PPC_FP128: // PPC_FP128 |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 569 | ResultTy = Type::getPPC_FP128Ty(Context); |
Dale Johannesen | 320fc8a | 2007-08-03 01:03:46 +0000 | [diff] [blame] | 570 | break; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 571 | case bitc::TYPE_CODE_LABEL: // LABEL |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 572 | ResultTy = Type::getLabelTy(Context); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 573 | break; |
Nick Lewycky | 7a0370f | 2009-05-30 05:06:04 +0000 | [diff] [blame] | 574 | case bitc::TYPE_CODE_METADATA: // METADATA |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 575 | ResultTy = Type::getMetadataTy(Context); |
Nick Lewycky | 7a0370f | 2009-05-30 05:06:04 +0000 | [diff] [blame] | 576 | break; |
Dale Johannesen | bb811a2 | 2010-09-10 20:55:01 +0000 | [diff] [blame] | 577 | case bitc::TYPE_CODE_X86_MMX: // X86_MMX |
| 578 | ResultTy = Type::getX86_MMXTy(Context); |
| 579 | break; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 580 | case bitc::TYPE_CODE_INTEGER: // INTEGER: [width] |
| 581 | if (Record.size() < 1) |
| 582 | return Error("Invalid Integer type record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 583 | |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 584 | ResultTy = IntegerType::get(Context, Record[0]); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 585 | break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 586 | case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 587 | // [pointee type, address space] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 588 | if (Record.size() < 1) |
| 589 | return Error("Invalid POINTER type record"); |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 590 | unsigned AddressSpace = 0; |
| 591 | if (Record.size() == 2) |
| 592 | AddressSpace = Record[1]; |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 593 | ResultTy = getTypeByID(Record[0]); |
| 594 | if (ResultTy == 0) return Error("invalid element type in pointer type"); |
| 595 | ResultTy = PointerType::get(ResultTy, AddressSpace); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 596 | break; |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 597 | } |
Nuno Lopes | ee8100d | 2012-05-23 15:19:39 +0000 | [diff] [blame] | 598 | case bitc::TYPE_CODE_FUNCTION_OLD: { |
| 599 | // FIXME: attrid is dead, remove it in LLVM 4.0 |
| 600 | // FUNCTION: [vararg, attrid, retty, paramty x N] |
| 601 | if (Record.size() < 3) |
| 602 | return Error("Invalid FUNCTION type record"); |
| 603 | SmallVector<Type*, 8> ArgTys; |
| 604 | for (unsigned i = 3, e = Record.size(); i != e; ++i) { |
| 605 | if (Type *T = getTypeByID(Record[i])) |
| 606 | ArgTys.push_back(T); |
| 607 | else |
| 608 | break; |
| 609 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 610 | |
Nuno Lopes | ee8100d | 2012-05-23 15:19:39 +0000 | [diff] [blame] | 611 | ResultTy = getTypeByID(Record[2]); |
| 612 | if (ResultTy == 0 || ArgTys.size() < Record.size()-3) |
| 613 | return Error("invalid type in function type"); |
| 614 | |
| 615 | ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); |
| 616 | break; |
| 617 | } |
Chad Rosier | cde5464 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 618 | case bitc::TYPE_CODE_FUNCTION: { |
| 619 | // FUNCTION: [vararg, retty, paramty x N] |
| 620 | if (Record.size() < 2) |
| 621 | return Error("Invalid FUNCTION type record"); |
Chris Lattner | d629efa | 2012-01-27 03:15:49 +0000 | [diff] [blame] | 622 | SmallVector<Type*, 8> ArgTys; |
Chad Rosier | cde5464 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 623 | for (unsigned i = 2, e = Record.size(); i != e; ++i) { |
| 624 | if (Type *T = getTypeByID(Record[i])) |
| 625 | ArgTys.push_back(T); |
| 626 | else |
| 627 | break; |
| 628 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 629 | |
Chad Rosier | cde5464 | 2011-11-03 00:14:01 +0000 | [diff] [blame] | 630 | ResultTy = getTypeByID(Record[1]); |
| 631 | if (ResultTy == 0 || ArgTys.size() < Record.size()-2) |
| 632 | return Error("invalid type in function type"); |
| 633 | |
| 634 | ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]); |
| 635 | break; |
| 636 | } |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 637 | case bitc::TYPE_CODE_STRUCT_ANON: { // STRUCT: [ispacked, eltty x N] |
Chris Lattner | 7108dce | 2007-05-06 08:21:50 +0000 | [diff] [blame] | 638 | if (Record.size() < 1) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 639 | return Error("Invalid STRUCT type record"); |
Chris Lattner | d629efa | 2012-01-27 03:15:49 +0000 | [diff] [blame] | 640 | SmallVector<Type*, 8> EltTys; |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 641 | for (unsigned i = 1, e = Record.size(); i != e; ++i) { |
| 642 | if (Type *T = getTypeByID(Record[i])) |
| 643 | EltTys.push_back(T); |
| 644 | else |
| 645 | break; |
| 646 | } |
| 647 | if (EltTys.size() != Record.size()-1) |
| 648 | return Error("invalid type in struct type"); |
Owen Anderson | d7f2a6c | 2009-08-05 23:16:16 +0000 | [diff] [blame] | 649 | ResultTy = StructType::get(Context, EltTys, Record[0]); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 650 | break; |
| 651 | } |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 652 | case bitc::TYPE_CODE_STRUCT_NAME: // STRUCT_NAME: [strchr x N] |
| 653 | if (ConvertToString(Record, 0, TypeName)) |
| 654 | return Error("Invalid STRUCT_NAME record"); |
| 655 | continue; |
| 656 | |
| 657 | case bitc::TYPE_CODE_STRUCT_NAMED: { // STRUCT: [ispacked, eltty x N] |
| 658 | if (Record.size() < 1) |
| 659 | return Error("Invalid STRUCT type record"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 660 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 661 | if (NumRecords >= TypeList.size()) |
| 662 | return Error("invalid TYPE table"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 663 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 664 | // Check to see if this was forward referenced, if so fill in the temp. |
| 665 | StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); |
| 666 | if (Res) { |
| 667 | Res->setName(TypeName); |
| 668 | TypeList[NumRecords] = 0; |
| 669 | } else // Otherwise, create a new struct. |
Chris Lattner | 3ebb649 | 2011-08-12 18:06:37 +0000 | [diff] [blame] | 670 | Res = StructType::create(Context, TypeName); |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 671 | TypeName.clear(); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 672 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 673 | SmallVector<Type*, 8> EltTys; |
| 674 | for (unsigned i = 1, e = Record.size(); i != e; ++i) { |
| 675 | if (Type *T = getTypeByID(Record[i])) |
| 676 | EltTys.push_back(T); |
| 677 | else |
| 678 | break; |
| 679 | } |
| 680 | if (EltTys.size() != Record.size()-1) |
| 681 | return Error("invalid STRUCT type record"); |
| 682 | Res->setBody(EltTys, Record[0]); |
| 683 | ResultTy = Res; |
| 684 | break; |
| 685 | } |
| 686 | case bitc::TYPE_CODE_OPAQUE: { // OPAQUE: [] |
| 687 | if (Record.size() != 1) |
| 688 | return Error("Invalid OPAQUE type record"); |
| 689 | |
| 690 | if (NumRecords >= TypeList.size()) |
| 691 | return Error("invalid TYPE table"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 692 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 693 | // Check to see if this was forward referenced, if so fill in the temp. |
| 694 | StructType *Res = cast_or_null<StructType>(TypeList[NumRecords]); |
| 695 | if (Res) { |
| 696 | Res->setName(TypeName); |
| 697 | TypeList[NumRecords] = 0; |
| 698 | } else // Otherwise, create a new struct with no body. |
Chris Lattner | 3ebb649 | 2011-08-12 18:06:37 +0000 | [diff] [blame] | 699 | Res = StructType::create(Context, TypeName); |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 700 | TypeName.clear(); |
| 701 | ResultTy = Res; |
| 702 | break; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 703 | } |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 704 | case bitc::TYPE_CODE_ARRAY: // ARRAY: [numelts, eltty] |
| 705 | if (Record.size() < 2) |
| 706 | return Error("Invalid ARRAY type record"); |
| 707 | if ((ResultTy = getTypeByID(Record[1]))) |
| 708 | ResultTy = ArrayType::get(ResultTy, Record[0]); |
| 709 | else |
| 710 | return Error("Invalid ARRAY type element"); |
| 711 | break; |
| 712 | case bitc::TYPE_CODE_VECTOR: // VECTOR: [numelts, eltty] |
| 713 | if (Record.size() < 2) |
| 714 | return Error("Invalid VECTOR type record"); |
| 715 | if ((ResultTy = getTypeByID(Record[1]))) |
| 716 | ResultTy = VectorType::get(ResultTy, Record[0]); |
| 717 | else |
| 718 | return Error("Invalid ARRAY type element"); |
| 719 | break; |
| 720 | } |
| 721 | |
| 722 | if (NumRecords >= TypeList.size()) |
| 723 | return Error("invalid TYPE table"); |
| 724 | assert(ResultTy && "Didn't read a type?"); |
| 725 | assert(TypeList[NumRecords] == 0 && "Already read type?"); |
| 726 | TypeList[NumRecords++] = ResultTy; |
| 727 | } |
| 728 | } |
| 729 | |
Chris Lattner | 8669714 | 2007-05-01 05:01:34 +0000 | [diff] [blame] | 730 | bool BitcodeReader::ParseValueSymbolTable() { |
Chris Lattner | e17b658 | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 731 | if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID)) |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 732 | return Error("Malformed block record"); |
| 733 | |
| 734 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 735 | |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 736 | // Read all the records for this value table. |
| 737 | SmallString<128> ValueName; |
| 738 | while (1) { |
| 739 | unsigned Code = Stream.ReadCode(); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 740 | if (Code == bitc::END_BLOCK) { |
| 741 | if (Stream.ReadBlockEnd()) |
| 742 | return Error("Error at end of value symbol table block"); |
| 743 | return false; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 744 | } |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 745 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 746 | // No known subblocks, always skip them. |
| 747 | Stream.ReadSubBlockID(); |
| 748 | if (Stream.SkipBlock()) |
| 749 | return Error("Malformed block record"); |
| 750 | continue; |
| 751 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 752 | |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 753 | if (Code == bitc::DEFINE_ABBREV) { |
| 754 | Stream.ReadAbbrevRecord(); |
| 755 | continue; |
| 756 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 757 | |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 758 | // Read a record. |
| 759 | Record.clear(); |
Bill Wendling | 5d7a5a4 | 2011-04-10 23:18:04 +0000 | [diff] [blame] | 760 | switch (Stream.ReadRecord(Code, Record)) { |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 761 | default: // Default behavior: unknown type. |
| 762 | break; |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 763 | case bitc::VST_CODE_ENTRY: { // VST_ENTRY: [valueid, namechar x N] |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 764 | if (ConvertToString(Record, 1, ValueName)) |
Nick Lewycky | 88b7293 | 2009-05-31 06:07:28 +0000 | [diff] [blame] | 765 | return Error("Invalid VST_ENTRY record"); |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 766 | unsigned ValueID = Record[0]; |
| 767 | if (ValueID >= ValueList.size()) |
| 768 | return Error("Invalid Value ID in VST_ENTRY record"); |
| 769 | Value *V = ValueList[ValueID]; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 770 | |
Daniel Dunbar | 3f53fa9 | 2009-07-26 00:34:27 +0000 | [diff] [blame] | 771 | V->setName(StringRef(ValueName.data(), ValueName.size())); |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 772 | ValueName.clear(); |
| 773 | break; |
Reid Spencer | c8f8a24 | 2007-05-04 01:43:33 +0000 | [diff] [blame] | 774 | } |
Bill Wendling | 5d7a5a4 | 2011-04-10 23:18:04 +0000 | [diff] [blame] | 775 | case bitc::VST_CODE_BBENTRY: { |
Chris Lattner | e825ed5 | 2007-05-03 22:18:21 +0000 | [diff] [blame] | 776 | if (ConvertToString(Record, 1, ValueName)) |
| 777 | return Error("Invalid VST_BBENTRY record"); |
| 778 | BasicBlock *BB = getBasicBlock(Record[0]); |
| 779 | if (BB == 0) |
| 780 | return Error("Invalid BB ID in VST_BBENTRY record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 781 | |
Daniel Dunbar | 3f53fa9 | 2009-07-26 00:34:27 +0000 | [diff] [blame] | 782 | BB->setName(StringRef(ValueName.data(), ValueName.size())); |
Chris Lattner | e825ed5 | 2007-05-03 22:18:21 +0000 | [diff] [blame] | 783 | ValueName.clear(); |
| 784 | break; |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 785 | } |
Reid Spencer | c8f8a24 | 2007-05-04 01:43:33 +0000 | [diff] [blame] | 786 | } |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 787 | } |
| 788 | } |
| 789 | |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 790 | bool BitcodeReader::ParseMetadata() { |
Devang Patel | 2359850 | 2010-01-11 18:52:33 +0000 | [diff] [blame] | 791 | unsigned NextMDValueNo = MDValueList.size(); |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 792 | |
| 793 | if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID)) |
| 794 | return Error("Malformed block record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 795 | |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 796 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 797 | |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 798 | // Read all the records. |
| 799 | while (1) { |
| 800 | unsigned Code = Stream.ReadCode(); |
| 801 | if (Code == bitc::END_BLOCK) { |
| 802 | if (Stream.ReadBlockEnd()) |
| 803 | return Error("Error at end of PARAMATTR block"); |
| 804 | return false; |
| 805 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 806 | |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 807 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 808 | // No known subblocks, always skip them. |
| 809 | Stream.ReadSubBlockID(); |
| 810 | if (Stream.SkipBlock()) |
| 811 | return Error("Malformed block record"); |
| 812 | continue; |
| 813 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 814 | |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 815 | if (Code == bitc::DEFINE_ABBREV) { |
| 816 | Stream.ReadAbbrevRecord(); |
| 817 | continue; |
| 818 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 819 | |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 820 | bool IsFunctionLocal = false; |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 821 | // Read a record. |
| 822 | Record.clear(); |
Dan Gohman | 9b10dfb | 2010-09-13 18:00:48 +0000 | [diff] [blame] | 823 | Code = Stream.ReadRecord(Code, Record); |
| 824 | switch (Code) { |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 825 | default: // Default behavior: ignore. |
| 826 | break; |
Devang Patel | aa99314 | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 827 | case bitc::METADATA_NAME: { |
| 828 | // Read named of the named metadata. |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 829 | SmallString<8> Name(Record.begin(), Record.end()); |
Devang Patel | aa99314 | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 830 | Record.clear(); |
| 831 | Code = Stream.ReadCode(); |
| 832 | |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 833 | // METADATA_NAME is always followed by METADATA_NAMED_NODE. |
Dan Gohman | 70c2fc0 | 2010-09-09 23:12:39 +0000 | [diff] [blame] | 834 | unsigned NextBitCode = Stream.ReadRecord(Code, Record); |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 835 | assert(NextBitCode == bitc::METADATA_NAMED_NODE); (void)NextBitCode; |
Devang Patel | aa99314 | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 836 | |
| 837 | // Read named metadata elements. |
| 838 | unsigned Size = Record.size(); |
Dan Gohman | 17aa92c | 2010-07-21 23:38:33 +0000 | [diff] [blame] | 839 | NamedMDNode *NMD = TheModule->getOrInsertNamedMetadata(Name); |
Devang Patel | aa99314 | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 840 | for (unsigned i = 0; i != Size; ++i) { |
Chris Lattner | 70644e9 | 2010-01-09 02:02:37 +0000 | [diff] [blame] | 841 | MDNode *MD = dyn_cast<MDNode>(MDValueList.getValueFwdRef(Record[i])); |
| 842 | if (MD == 0) |
| 843 | return Error("Malformed metadata record"); |
Dan Gohman | 17aa92c | 2010-07-21 23:38:33 +0000 | [diff] [blame] | 844 | NMD->addOperand(MD); |
Devang Patel | aa99314 | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 845 | } |
Devang Patel | aa99314 | 2009-07-29 22:34:41 +0000 | [diff] [blame] | 846 | break; |
| 847 | } |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 848 | case bitc::METADATA_FN_NODE: |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 849 | IsFunctionLocal = true; |
| 850 | // fall-through |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 851 | case bitc::METADATA_NODE: { |
Dan Gohman | ac80975 | 2010-07-13 19:33:27 +0000 | [diff] [blame] | 852 | if (Record.size() % 2 == 1) |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 853 | return Error("Invalid METADATA_NODE record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 854 | |
Devang Patel | 104cf9e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 855 | unsigned Size = Record.size(); |
| 856 | SmallVector<Value*, 8> Elts; |
| 857 | for (unsigned i = 0; i != Size; i += 2) { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 858 | Type *Ty = getTypeByID(Record[i]); |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 859 | if (!Ty) return Error("Invalid METADATA_NODE record"); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 860 | if (Ty->isMetadataTy()) |
Devang Patel | d5ac404 | 2009-08-04 06:00:18 +0000 | [diff] [blame] | 861 | Elts.push_back(MDValueList.getValueFwdRef(Record[i+1])); |
Benjamin Kramer | f012705 | 2010-01-05 13:12:22 +0000 | [diff] [blame] | 862 | else if (!Ty->isVoidTy()) |
Devang Patel | 104cf9e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 863 | Elts.push_back(ValueList.getValueFwdRef(Record[i+1], Ty)); |
| 864 | else |
| 865 | Elts.push_back(NULL); |
| 866 | } |
Jay Foad | ec9186b | 2011-04-21 19:59:31 +0000 | [diff] [blame] | 867 | Value *V = MDNode::getWhenValsUnresolved(Context, Elts, IsFunctionLocal); |
Victor Hernandez | 24e64df | 2010-01-10 07:14:18 +0000 | [diff] [blame] | 868 | IsFunctionLocal = false; |
Devang Patel | 2359850 | 2010-01-11 18:52:33 +0000 | [diff] [blame] | 869 | MDValueList.AssignValue(V, NextMDValueNo++); |
Devang Patel | 104cf9e | 2009-07-23 01:07:34 +0000 | [diff] [blame] | 870 | break; |
| 871 | } |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 872 | case bitc::METADATA_STRING: { |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 873 | SmallString<8> String(Record.begin(), Record.end()); |
| 874 | Value *V = MDString::get(Context, String); |
Devang Patel | 2359850 | 2010-01-11 18:52:33 +0000 | [diff] [blame] | 875 | MDValueList.AssignValue(V, NextMDValueNo++); |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 876 | break; |
| 877 | } |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 878 | case bitc::METADATA_KIND: { |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 879 | if (Record.size() < 2) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 880 | return Error("Invalid METADATA_KIND record"); |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 881 | |
Devang Patel | a214840 | 2009-09-28 21:14:55 +0000 | [diff] [blame] | 882 | unsigned Kind = Record[0]; |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 883 | SmallString<8> Name(Record.begin()+1, Record.end()); |
| 884 | |
Chris Lattner | 0811347 | 2009-12-29 09:01:33 +0000 | [diff] [blame] | 885 | unsigned NewKind = TheModule->getMDKindID(Name.str()); |
Dan Gohman | 19538d1 | 2010-07-20 21:42:28 +0000 | [diff] [blame] | 886 | if (!MDKindMap.insert(std::make_pair(Kind, NewKind)).second) |
| 887 | return Error("Conflicting METADATA_KIND records"); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 888 | break; |
| 889 | } |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 890 | } |
| 891 | } |
| 892 | } |
| 893 | |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 894 | /// decodeSignRotatedValue - Decode a signed value stored with the sign bit in |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 895 | /// the LSB for dense VBR encoding. |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 896 | uint64_t BitcodeReader::decodeSignRotatedValue(uint64_t V) { |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 897 | if ((V & 1) == 0) |
| 898 | return V >> 1; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 899 | if (V != 1) |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 900 | return -(V >> 1); |
| 901 | // There is no such thing as -0 with integers. "-0" really means MININT. |
| 902 | return 1ULL << 63; |
| 903 | } |
| 904 | |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 905 | /// ResolveGlobalAndAliasInits - Resolve all of the initializers for global |
| 906 | /// values and aliases that we can. |
| 907 | bool BitcodeReader::ResolveGlobalAndAliasInits() { |
| 908 | std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInitWorklist; |
| 909 | std::vector<std::pair<GlobalAlias*, unsigned> > AliasInitWorklist; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 910 | |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 911 | GlobalInitWorklist.swap(GlobalInits); |
| 912 | AliasInitWorklist.swap(AliasInits); |
| 913 | |
| 914 | while (!GlobalInitWorklist.empty()) { |
Chris Lattner | 198f34a | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 915 | unsigned ValID = GlobalInitWorklist.back().second; |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 916 | if (ValID >= ValueList.size()) { |
| 917 | // Not ready to resolve this yet, it requires something later in the file. |
Chris Lattner | 198f34a | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 918 | GlobalInits.push_back(GlobalInitWorklist.back()); |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 919 | } else { |
| 920 | if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) |
| 921 | GlobalInitWorklist.back().first->setInitializer(C); |
| 922 | else |
| 923 | return Error("Global variable initializer is not a constant!"); |
| 924 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 925 | GlobalInitWorklist.pop_back(); |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 926 | } |
| 927 | |
| 928 | while (!AliasInitWorklist.empty()) { |
| 929 | unsigned ValID = AliasInitWorklist.back().second; |
| 930 | if (ValID >= ValueList.size()) { |
| 931 | AliasInits.push_back(AliasInitWorklist.back()); |
| 932 | } else { |
| 933 | if (Constant *C = dyn_cast<Constant>(ValueList[ValID])) |
Anton Korobeynikov | 7dde0ff | 2007-04-28 14:57:59 +0000 | [diff] [blame] | 934 | AliasInitWorklist.back().first->setAliasee(C); |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 935 | else |
| 936 | return Error("Alias initializer is not a constant!"); |
| 937 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 938 | AliasInitWorklist.pop_back(); |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 939 | } |
| 940 | return false; |
| 941 | } |
| 942 | |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 943 | static APInt ReadWideAPInt(ArrayRef<uint64_t> Vals, unsigned TypeBits) { |
| 944 | SmallVector<uint64_t, 8> Words(Vals.size()); |
| 945 | std::transform(Vals.begin(), Vals.end(), Words.begin(), |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 946 | BitcodeReader::decodeSignRotatedValue); |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 947 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 948 | return APInt(TypeBits, Words); |
| 949 | } |
| 950 | |
Chris Lattner | 8669714 | 2007-05-01 05:01:34 +0000 | [diff] [blame] | 951 | bool BitcodeReader::ParseConstants() { |
Chris Lattner | e17b658 | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 952 | if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID)) |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 953 | return Error("Malformed block record"); |
| 954 | |
| 955 | SmallVector<uint64_t, 64> Record; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 956 | |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 957 | // Read all the records for this value table. |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 958 | Type *CurTy = Type::getInt32Ty(Context); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 959 | unsigned NextCstNo = ValueList.size(); |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 960 | while (1) { |
| 961 | unsigned Code = Stream.ReadCode(); |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 962 | if (Code == bitc::END_BLOCK) |
| 963 | break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 964 | |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 965 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 966 | // No known subblocks, always skip them. |
| 967 | Stream.ReadSubBlockID(); |
| 968 | if (Stream.SkipBlock()) |
| 969 | return Error("Malformed block record"); |
| 970 | continue; |
| 971 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 972 | |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 973 | if (Code == bitc::DEFINE_ABBREV) { |
| 974 | Stream.ReadAbbrevRecord(); |
| 975 | continue; |
| 976 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 977 | |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 978 | // Read a record. |
| 979 | Record.clear(); |
| 980 | Value *V = 0; |
Dan Gohman | 1224c38 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 981 | unsigned BitCode = Stream.ReadRecord(Code, Record); |
| 982 | switch (BitCode) { |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 983 | default: // Default behavior: unknown constant |
| 984 | case bitc::CST_CODE_UNDEF: // UNDEF |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 985 | V = UndefValue::get(CurTy); |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 986 | break; |
| 987 | case bitc::CST_CODE_SETTYPE: // SETTYPE: [typeid] |
| 988 | if (Record.empty()) |
| 989 | return Error("Malformed CST_SETTYPE record"); |
| 990 | if (Record[0] >= TypeList.size()) |
| 991 | return Error("Invalid Type ID in CST_SETTYPE record"); |
| 992 | CurTy = TypeList[Record[0]]; |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 993 | continue; // Skip the ValueList manipulation. |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 994 | case bitc::CST_CODE_NULL: // NULL |
Owen Anderson | a7235ea | 2009-07-31 20:28:14 +0000 | [diff] [blame] | 995 | V = Constant::getNullValue(CurTy); |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 996 | break; |
| 997 | case bitc::CST_CODE_INTEGER: // INTEGER: [intval] |
Duncan Sands | 1df9859 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 998 | if (!CurTy->isIntegerTy() || Record.empty()) |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 999 | return Error("Invalid CST_INTEGER record"); |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 1000 | V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0])); |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 1001 | break; |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1002 | case bitc::CST_CODE_WIDE_INTEGER: {// WIDE_INTEGER: [n x intval] |
Duncan Sands | 1df9859 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 1003 | if (!CurTy->isIntegerTy() || Record.empty()) |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 1004 | return Error("Invalid WIDE_INTEGER record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1005 | |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 1006 | APInt VInt = ReadWideAPInt(Record, |
| 1007 | cast<IntegerType>(CurTy)->getBitWidth()); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 1008 | V = ConstantInt::get(Context, VInt); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1009 | |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 1010 | break; |
| 1011 | } |
Dale Johannesen | 3f6eb74 | 2007-09-11 18:32:33 +0000 | [diff] [blame] | 1012 | case bitc::CST_CODE_FLOAT: { // FLOAT: [fpval] |
Chris Lattner | 0eef080 | 2007-04-24 04:04:35 +0000 | [diff] [blame] | 1013 | if (Record.empty()) |
| 1014 | return Error("Invalid FLOAT record"); |
Dan Gohman | ce16339 | 2011-12-17 00:04:22 +0000 | [diff] [blame] | 1015 | if (CurTy->isHalfTy()) |
| 1016 | V = ConstantFP::get(Context, APFloat(APInt(16, (uint16_t)Record[0]))); |
| 1017 | else if (CurTy->isFloatTy()) |
Owen Anderson | 6f83c9c | 2009-07-27 20:59:43 +0000 | [diff] [blame] | 1018 | V = ConstantFP::get(Context, APFloat(APInt(32, (uint32_t)Record[0]))); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1019 | else if (CurTy->isDoubleTy()) |
Owen Anderson | 6f83c9c | 2009-07-27 20:59:43 +0000 | [diff] [blame] | 1020 | V = ConstantFP::get(Context, APFloat(APInt(64, Record[0]))); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1021 | else if (CurTy->isX86_FP80Ty()) { |
Dale Johannesen | 1b25cb2 | 2009-03-23 21:16:53 +0000 | [diff] [blame] | 1022 | // Bits are not stored the same way as a normal i80 APInt, compensate. |
| 1023 | uint64_t Rearrange[2]; |
| 1024 | Rearrange[0] = (Record[1] & 0xffffLL) | (Record[0] << 16); |
| 1025 | Rearrange[1] = Record[0] >> 48; |
Jeffrey Yasskin | 3ba292d | 2011-07-18 21:45:40 +0000 | [diff] [blame] | 1026 | V = ConstantFP::get(Context, APFloat(APInt(80, Rearrange))); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1027 | } else if (CurTy->isFP128Ty()) |
Jeffrey Yasskin | 3ba292d | 2011-07-18 21:45:40 +0000 | [diff] [blame] | 1028 | V = ConstantFP::get(Context, APFloat(APInt(128, Record), true)); |
Chris Lattner | cf0fe8d | 2009-10-05 05:54:46 +0000 | [diff] [blame] | 1029 | else if (CurTy->isPPC_FP128Ty()) |
Jeffrey Yasskin | 3ba292d | 2011-07-18 21:45:40 +0000 | [diff] [blame] | 1030 | V = ConstantFP::get(Context, APFloat(APInt(128, Record))); |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1031 | else |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 1032 | V = UndefValue::get(CurTy); |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1033 | break; |
Dale Johannesen | 3f6eb74 | 2007-09-11 18:32:33 +0000 | [diff] [blame] | 1034 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1035 | |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1036 | case bitc::CST_CODE_AGGREGATE: {// AGGREGATE: [n x value number] |
| 1037 | if (Record.empty()) |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1038 | return Error("Invalid CST_AGGREGATE record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1039 | |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1040 | unsigned Size = Record.size(); |
Chris Lattner | d629efa | 2012-01-27 03:15:49 +0000 | [diff] [blame] | 1041 | SmallVector<Constant*, 16> Elts; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1042 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1043 | if (StructType *STy = dyn_cast<StructType>(CurTy)) { |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1044 | for (unsigned i = 0; i != Size; ++i) |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1045 | Elts.push_back(ValueList.getConstantFwdRef(Record[i], |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1046 | STy->getElementType(i))); |
Owen Anderson | 8fa3338 | 2009-07-27 22:29:26 +0000 | [diff] [blame] | 1047 | V = ConstantStruct::get(STy, Elts); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1048 | } else if (ArrayType *ATy = dyn_cast<ArrayType>(CurTy)) { |
| 1049 | Type *EltTy = ATy->getElementType(); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1050 | for (unsigned i = 0; i != Size; ++i) |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1051 | Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); |
Owen Anderson | 1fd7096 | 2009-07-28 18:32:17 +0000 | [diff] [blame] | 1052 | V = ConstantArray::get(ATy, Elts); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1053 | } else if (VectorType *VTy = dyn_cast<VectorType>(CurTy)) { |
| 1054 | Type *EltTy = VTy->getElementType(); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1055 | for (unsigned i = 0; i != Size; ++i) |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1056 | Elts.push_back(ValueList.getConstantFwdRef(Record[i], EltTy)); |
Owen Anderson | af7ec97 | 2009-07-28 21:19:26 +0000 | [diff] [blame] | 1057 | V = ConstantVector::get(Elts); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1058 | } else { |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 1059 | V = UndefValue::get(CurTy); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1060 | } |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1061 | break; |
| 1062 | } |
Chris Lattner | 2237f84 | 2012-02-05 02:41:35 +0000 | [diff] [blame] | 1063 | case bitc::CST_CODE_STRING: // STRING: [values] |
Chris Lattner | cb3d91b | 2007-05-06 00:53:07 +0000 | [diff] [blame] | 1064 | case bitc::CST_CODE_CSTRING: { // CSTRING: [values] |
| 1065 | if (Record.empty()) |
Chris Lattner | 2237f84 | 2012-02-05 02:41:35 +0000 | [diff] [blame] | 1066 | return Error("Invalid CST_STRING record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1067 | |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 1068 | SmallString<16> Elts(Record.begin(), Record.end()); |
Chris Lattner | 2237f84 | 2012-02-05 02:41:35 +0000 | [diff] [blame] | 1069 | V = ConstantDataArray::getString(Context, Elts, |
| 1070 | BitCode == bitc::CST_CODE_CSTRING); |
Chris Lattner | cb3d91b | 2007-05-06 00:53:07 +0000 | [diff] [blame] | 1071 | break; |
| 1072 | } |
Chris Lattner | d408f06 | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 1073 | case bitc::CST_CODE_DATA: {// DATA: [n x value] |
| 1074 | if (Record.empty()) |
| 1075 | return Error("Invalid CST_DATA record"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1076 | |
Chris Lattner | d408f06 | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 1077 | Type *EltTy = cast<SequentialType>(CurTy)->getElementType(); |
| 1078 | unsigned Size = Record.size(); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1079 | |
Chris Lattner | d408f06 | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 1080 | if (EltTy->isIntegerTy(8)) { |
| 1081 | SmallVector<uint8_t, 16> Elts(Record.begin(), Record.end()); |
| 1082 | if (isa<VectorType>(CurTy)) |
| 1083 | V = ConstantDataVector::get(Context, Elts); |
| 1084 | else |
| 1085 | V = ConstantDataArray::get(Context, Elts); |
| 1086 | } else if (EltTy->isIntegerTy(16)) { |
| 1087 | SmallVector<uint16_t, 16> Elts(Record.begin(), Record.end()); |
| 1088 | if (isa<VectorType>(CurTy)) |
| 1089 | V = ConstantDataVector::get(Context, Elts); |
| 1090 | else |
| 1091 | V = ConstantDataArray::get(Context, Elts); |
| 1092 | } else if (EltTy->isIntegerTy(32)) { |
| 1093 | SmallVector<uint32_t, 16> Elts(Record.begin(), Record.end()); |
| 1094 | if (isa<VectorType>(CurTy)) |
| 1095 | V = ConstantDataVector::get(Context, Elts); |
| 1096 | else |
| 1097 | V = ConstantDataArray::get(Context, Elts); |
| 1098 | } else if (EltTy->isIntegerTy(64)) { |
| 1099 | SmallVector<uint64_t, 16> Elts(Record.begin(), Record.end()); |
| 1100 | if (isa<VectorType>(CurTy)) |
| 1101 | V = ConstantDataVector::get(Context, Elts); |
| 1102 | else |
| 1103 | V = ConstantDataArray::get(Context, Elts); |
| 1104 | } else if (EltTy->isFloatTy()) { |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 1105 | SmallVector<float, 16> Elts(Size); |
| 1106 | std::transform(Record.begin(), Record.end(), Elts.begin(), BitsToFloat); |
Chris Lattner | d408f06 | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 1107 | if (isa<VectorType>(CurTy)) |
| 1108 | V = ConstantDataVector::get(Context, Elts); |
| 1109 | else |
| 1110 | V = ConstantDataArray::get(Context, Elts); |
| 1111 | } else if (EltTy->isDoubleTy()) { |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 1112 | SmallVector<double, 16> Elts(Size); |
| 1113 | std::transform(Record.begin(), Record.end(), Elts.begin(), |
| 1114 | BitsToDouble); |
Chris Lattner | d408f06 | 2012-01-30 00:51:16 +0000 | [diff] [blame] | 1115 | if (isa<VectorType>(CurTy)) |
| 1116 | V = ConstantDataVector::get(Context, Elts); |
| 1117 | else |
| 1118 | V = ConstantDataArray::get(Context, Elts); |
| 1119 | } else { |
| 1120 | return Error("Unknown element type in CE_DATA"); |
| 1121 | } |
| 1122 | break; |
| 1123 | } |
| 1124 | |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1125 | case bitc::CST_CODE_CE_BINOP: { // CE_BINOP: [opcode, opval, opval] |
| 1126 | if (Record.size() < 3) return Error("Invalid CE_BINOP record"); |
| 1127 | int Opc = GetDecodedBinaryOpcode(Record[0], CurTy); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1128 | if (Opc < 0) { |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 1129 | V = UndefValue::get(CurTy); // Unknown binop. |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1130 | } else { |
| 1131 | Constant *LHS = ValueList.getConstantFwdRef(Record[1], CurTy); |
| 1132 | Constant *RHS = ValueList.getConstantFwdRef(Record[2], CurTy); |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 1133 | unsigned Flags = 0; |
| 1134 | if (Record.size() >= 4) { |
| 1135 | if (Opc == Instruction::Add || |
| 1136 | Opc == Instruction::Sub || |
Chris Lattner | f067d58 | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 1137 | Opc == Instruction::Mul || |
| 1138 | Opc == Instruction::Shl) { |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 1139 | if (Record[3] & (1 << bitc::OBO_NO_SIGNED_WRAP)) |
| 1140 | Flags |= OverflowingBinaryOperator::NoSignedWrap; |
| 1141 | if (Record[3] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) |
| 1142 | Flags |= OverflowingBinaryOperator::NoUnsignedWrap; |
Chris Lattner | 35bda89 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 1143 | } else if (Opc == Instruction::SDiv || |
Chris Lattner | f067d58 | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 1144 | Opc == Instruction::UDiv || |
| 1145 | Opc == Instruction::LShr || |
| 1146 | Opc == Instruction::AShr) { |
Chris Lattner | 35bda89 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 1147 | if (Record[3] & (1 << bitc::PEO_EXACT)) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 1148 | Flags |= SDivOperator::IsExact; |
| 1149 | } |
| 1150 | } |
| 1151 | V = ConstantExpr::get(Opc, LHS, RHS, Flags); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1152 | } |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1153 | break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1154 | } |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1155 | case bitc::CST_CODE_CE_CAST: { // CE_CAST: [opcode, opty, opval] |
| 1156 | if (Record.size() < 3) return Error("Invalid CE_CAST record"); |
| 1157 | int Opc = GetDecodedCastOpcode(Record[0]); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1158 | if (Opc < 0) { |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 1159 | V = UndefValue::get(CurTy); // Unknown cast. |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1160 | } else { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1161 | Type *OpTy = getTypeByID(Record[1]); |
Chris Lattner | bfcc380 | 2007-05-06 07:33:01 +0000 | [diff] [blame] | 1162 | if (!OpTy) return Error("Invalid CE_CAST record"); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1163 | Constant *Op = ValueList.getConstantFwdRef(Record[2], OpTy); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1164 | V = ConstantExpr::getCast(Opc, Op, CurTy); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1165 | } |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1166 | break; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1167 | } |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 1168 | case bitc::CST_CODE_CE_INBOUNDS_GEP: |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1169 | case bitc::CST_CODE_CE_GEP: { // CE_GEP: [n x operands] |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1170 | if (Record.size() & 1) return Error("Invalid CE_GEP record"); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1171 | SmallVector<Constant*, 16> Elts; |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1172 | for (unsigned i = 0, e = Record.size(); i != e; i += 2) { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1173 | Type *ElTy = getTypeByID(Record[i]); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1174 | if (!ElTy) return Error("Invalid CE_GEP record"); |
| 1175 | Elts.push_back(ValueList.getConstantFwdRef(Record[i+1], ElTy)); |
| 1176 | } |
Jay Foad | dab3d29 | 2011-07-21 14:31:17 +0000 | [diff] [blame] | 1177 | ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end()); |
Jay Foad | 4b5e207 | 2011-07-21 15:15:37 +0000 | [diff] [blame] | 1178 | V = ConstantExpr::getGetElementPtr(Elts[0], Indices, |
| 1179 | BitCode == |
| 1180 | bitc::CST_CODE_CE_INBOUNDS_GEP); |
Chris Lattner | f66d20d | 2007-04-24 18:15:21 +0000 | [diff] [blame] | 1181 | break; |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1182 | } |
| 1183 | case bitc::CST_CODE_CE_SELECT: // CE_SELECT: [opval#, opval#, opval#] |
| 1184 | if (Record.size() < 3) return Error("Invalid CE_SELECT record"); |
Joe Abbey | e46b14a | 2012-11-19 19:22:55 +0000 | [diff] [blame] | 1185 | V = ConstantExpr::getSelect( |
| 1186 | ValueList.getConstantFwdRef(Record[0], |
| 1187 | Type::getInt1Ty(Context)), |
| 1188 | ValueList.getConstantFwdRef(Record[1],CurTy), |
| 1189 | ValueList.getConstantFwdRef(Record[2],CurTy)); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1190 | break; |
| 1191 | case bitc::CST_CODE_CE_EXTRACTELT: { // CE_EXTRACTELT: [opty, opval, opval] |
| 1192 | if (Record.size() < 3) return Error("Invalid CE_EXTRACTELT record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1193 | VectorType *OpTy = |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1194 | dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); |
| 1195 | if (OpTy == 0) return Error("Invalid CE_EXTRACTELT record"); |
| 1196 | Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); |
Joe Abbey | e46b14a | 2012-11-19 19:22:55 +0000 | [diff] [blame] | 1197 | Constant *Op1 = ValueList.getConstantFwdRef(Record[2], |
| 1198 | Type::getInt32Ty(Context)); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1199 | V = ConstantExpr::getExtractElement(Op0, Op1); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1200 | break; |
| 1201 | } |
| 1202 | case bitc::CST_CODE_CE_INSERTELT: { // CE_INSERTELT: [opval, opval, opval] |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1203 | VectorType *OpTy = dyn_cast<VectorType>(CurTy); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1204 | if (Record.size() < 3 || OpTy == 0) |
| 1205 | return Error("Invalid CE_INSERTELT record"); |
| 1206 | Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); |
| 1207 | Constant *Op1 = ValueList.getConstantFwdRef(Record[1], |
| 1208 | OpTy->getElementType()); |
Joe Abbey | e46b14a | 2012-11-19 19:22:55 +0000 | [diff] [blame] | 1209 | Constant *Op2 = ValueList.getConstantFwdRef(Record[2], |
| 1210 | Type::getInt32Ty(Context)); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1211 | V = ConstantExpr::getInsertElement(Op0, Op1, Op2); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1212 | break; |
| 1213 | } |
| 1214 | case bitc::CST_CODE_CE_SHUFFLEVEC: { // CE_SHUFFLEVEC: [opval, opval, opval] |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1215 | VectorType *OpTy = dyn_cast<VectorType>(CurTy); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1216 | if (Record.size() < 3 || OpTy == 0) |
Nate Begeman | 0f123cf | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 1217 | return Error("Invalid CE_SHUFFLEVEC record"); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1218 | Constant *Op0 = ValueList.getConstantFwdRef(Record[0], OpTy); |
| 1219 | Constant *Op1 = ValueList.getConstantFwdRef(Record[1], OpTy); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1220 | Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), |
Owen Anderson | 74a7781 | 2009-07-07 20:18:58 +0000 | [diff] [blame] | 1221 | OpTy->getNumElements()); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1222 | Constant *Op2 = ValueList.getConstantFwdRef(Record[2], ShufTy); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1223 | V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1224 | break; |
| 1225 | } |
Nate Begeman | 0f123cf | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 1226 | case bitc::CST_CODE_CE_SHUFVEC_EX: { // [opty, opval, opval, opval] |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1227 | VectorType *RTy = dyn_cast<VectorType>(CurTy); |
| 1228 | VectorType *OpTy = |
Duncan Sands | f22b746 | 2010-10-28 15:47:26 +0000 | [diff] [blame] | 1229 | dyn_cast_or_null<VectorType>(getTypeByID(Record[0])); |
Nate Begeman | 0f123cf | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 1230 | if (Record.size() < 4 || RTy == 0 || OpTy == 0) |
| 1231 | return Error("Invalid CE_SHUFVEC_EX record"); |
| 1232 | Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); |
| 1233 | Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1234 | Type *ShufTy = VectorType::get(Type::getInt32Ty(Context), |
Owen Anderson | 74a7781 | 2009-07-07 20:18:58 +0000 | [diff] [blame] | 1235 | RTy->getNumElements()); |
Nate Begeman | 0f123cf | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 1236 | Constant *Op2 = ValueList.getConstantFwdRef(Record[3], ShufTy); |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1237 | V = ConstantExpr::getShuffleVector(Op0, Op1, Op2); |
Nate Begeman | 0f123cf | 2009-02-12 21:28:33 +0000 | [diff] [blame] | 1238 | break; |
| 1239 | } |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1240 | case bitc::CST_CODE_CE_CMP: { // CE_CMP: [opty, opval, opval, pred] |
| 1241 | if (Record.size() < 4) return Error("Invalid CE_CMP record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1242 | Type *OpTy = getTypeByID(Record[0]); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1243 | if (OpTy == 0) return Error("Invalid CE_CMP record"); |
| 1244 | Constant *Op0 = ValueList.getConstantFwdRef(Record[1], OpTy); |
| 1245 | Constant *Op1 = ValueList.getConstantFwdRef(Record[2], OpTy); |
| 1246 | |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 1247 | if (OpTy->isFPOrFPVectorTy()) |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1248 | V = ConstantExpr::getFCmp(Record[3], Op0, Op1); |
Nate Begeman | ac80ade | 2008-05-12 19:01:56 +0000 | [diff] [blame] | 1249 | else |
Owen Anderson | baf3c40 | 2009-07-29 18:55:55 +0000 | [diff] [blame] | 1250 | V = ConstantExpr::getICmp(Record[3], Op0, Op1); |
Chris Lattner | f581c3b | 2007-04-24 07:07:11 +0000 | [diff] [blame] | 1251 | break; |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1252 | } |
Chad Rosier | 581600b | 2012-09-05 19:00:49 +0000 | [diff] [blame] | 1253 | // This maintains backward compatibility, pre-asm dialect keywords. |
Chad Rosier | 27b25c2 | 2012-09-05 06:28:52 +0000 | [diff] [blame] | 1254 | // FIXME: Remove with the 4.0 release. |
Chad Rosier | f16ae58 | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 1255 | case bitc::CST_CODE_INLINEASM_OLD: { |
Chris Lattner | 2bce93a | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 1256 | if (Record.size() < 2) return Error("Invalid INLINEASM record"); |
| 1257 | std::string AsmStr, ConstrStr; |
Dale Johannesen | 4360298 | 2009-10-13 20:46:56 +0000 | [diff] [blame] | 1258 | bool HasSideEffects = Record[0] & 1; |
Dale Johannesen | 8ba2d5b | 2009-10-21 23:28:00 +0000 | [diff] [blame] | 1259 | bool IsAlignStack = Record[0] >> 1; |
Chris Lattner | 2bce93a | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 1260 | unsigned AsmStrSize = Record[1]; |
| 1261 | if (2+AsmStrSize >= Record.size()) |
| 1262 | return Error("Invalid INLINEASM record"); |
| 1263 | unsigned ConstStrSize = Record[2+AsmStrSize]; |
| 1264 | if (3+AsmStrSize+ConstStrSize > Record.size()) |
| 1265 | return Error("Invalid INLINEASM record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1266 | |
Chris Lattner | 2bce93a | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 1267 | for (unsigned i = 0; i != AsmStrSize; ++i) |
| 1268 | AsmStr += (char)Record[2+i]; |
| 1269 | for (unsigned i = 0; i != ConstStrSize; ++i) |
| 1270 | ConstrStr += (char)Record[3+AsmStrSize+i]; |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1271 | PointerType *PTy = cast<PointerType>(CurTy); |
Chris Lattner | 2bce93a | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 1272 | V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), |
Dale Johannesen | 8ba2d5b | 2009-10-21 23:28:00 +0000 | [diff] [blame] | 1273 | AsmStr, ConstrStr, HasSideEffects, IsAlignStack); |
Chris Lattner | 2bce93a | 2007-05-06 01:58:20 +0000 | [diff] [blame] | 1274 | break; |
| 1275 | } |
Chad Rosier | 581600b | 2012-09-05 19:00:49 +0000 | [diff] [blame] | 1276 | // This version adds support for the asm dialect keywords (e.g., |
| 1277 | // inteldialect). |
Chad Rosier | f16ae58 | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 1278 | case bitc::CST_CODE_INLINEASM: { |
| 1279 | if (Record.size() < 2) return Error("Invalid INLINEASM record"); |
| 1280 | std::string AsmStr, ConstrStr; |
| 1281 | bool HasSideEffects = Record[0] & 1; |
| 1282 | bool IsAlignStack = (Record[0] >> 1) & 1; |
| 1283 | unsigned AsmDialect = Record[0] >> 2; |
| 1284 | unsigned AsmStrSize = Record[1]; |
| 1285 | if (2+AsmStrSize >= Record.size()) |
| 1286 | return Error("Invalid INLINEASM record"); |
| 1287 | unsigned ConstStrSize = Record[2+AsmStrSize]; |
| 1288 | if (3+AsmStrSize+ConstStrSize > Record.size()) |
| 1289 | return Error("Invalid INLINEASM record"); |
| 1290 | |
| 1291 | for (unsigned i = 0; i != AsmStrSize; ++i) |
| 1292 | AsmStr += (char)Record[2+i]; |
| 1293 | for (unsigned i = 0; i != ConstStrSize; ++i) |
| 1294 | ConstrStr += (char)Record[3+AsmStrSize+i]; |
| 1295 | PointerType *PTy = cast<PointerType>(CurTy); |
| 1296 | V = InlineAsm::get(cast<FunctionType>(PTy->getElementType()), |
| 1297 | AsmStr, ConstrStr, HasSideEffects, IsAlignStack, |
Chad Rosier | 581600b | 2012-09-05 19:00:49 +0000 | [diff] [blame] | 1298 | InlineAsm::AsmDialect(AsmDialect)); |
Chad Rosier | f16ae58 | 2012-09-05 00:56:20 +0000 | [diff] [blame] | 1299 | break; |
| 1300 | } |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 1301 | case bitc::CST_CODE_BLOCKADDRESS:{ |
| 1302 | if (Record.size() < 3) return Error("Invalid CE_BLOCKADDRESS record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1303 | Type *FnTy = getTypeByID(Record[0]); |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 1304 | if (FnTy == 0) return Error("Invalid CE_BLOCKADDRESS record"); |
| 1305 | Function *Fn = |
| 1306 | dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy)); |
| 1307 | if (Fn == 0) return Error("Invalid CE_BLOCKADDRESS record"); |
Benjamin Kramer | 122f5e5 | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 1308 | |
| 1309 | // If the function is already parsed we can insert the block address right |
| 1310 | // away. |
| 1311 | if (!Fn->empty()) { |
| 1312 | Function::iterator BBI = Fn->begin(), BBE = Fn->end(); |
| 1313 | for (size_t I = 0, E = Record[2]; I != E; ++I) { |
| 1314 | if (BBI == BBE) |
| 1315 | return Error("Invalid blockaddress block #"); |
| 1316 | ++BBI; |
| 1317 | } |
| 1318 | V = BlockAddress::get(Fn, BBI); |
| 1319 | } else { |
| 1320 | // Otherwise insert a placeholder and remember it so it can be inserted |
| 1321 | // when the function is parsed. |
| 1322 | GlobalVariable *FwdRef = new GlobalVariable(*Fn->getParent(), |
| 1323 | Type::getInt8Ty(Context), |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 1324 | false, GlobalValue::InternalLinkage, |
Benjamin Kramer | 122f5e5 | 2012-09-21 14:34:31 +0000 | [diff] [blame] | 1325 | 0, ""); |
| 1326 | BlockAddrFwdRefs[Fn].push_back(std::make_pair(Record[2], FwdRef)); |
| 1327 | V = FwdRef; |
| 1328 | } |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 1329 | break; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1330 | } |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1331 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1332 | |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1333 | ValueList.AssignValue(V, NextCstNo); |
Chris Lattner | 522b7b1 | 2007-04-24 05:48:56 +0000 | [diff] [blame] | 1334 | ++NextCstNo; |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1335 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1336 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1337 | if (NextCstNo != ValueList.size()) |
| 1338 | return Error("Invalid constant reference!"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1339 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1340 | if (Stream.ReadBlockEnd()) |
| 1341 | return Error("Error at end of constants block"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1342 | |
Chris Lattner | ea693df | 2008-08-21 02:34:16 +0000 | [diff] [blame] | 1343 | // Once all the constants have been read, go through and resolve forward |
| 1344 | // references. |
| 1345 | ValueList.ResolveConstantForwardRefs(); |
| 1346 | return false; |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1347 | } |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1348 | |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 1349 | bool BitcodeReader::ParseUseLists() { |
| 1350 | if (Stream.EnterSubBlock(bitc::USELIST_BLOCK_ID)) |
| 1351 | return Error("Malformed block record"); |
| 1352 | |
| 1353 | SmallVector<uint64_t, 64> Record; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1354 | |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 1355 | // Read all the records. |
| 1356 | while (1) { |
| 1357 | unsigned Code = Stream.ReadCode(); |
| 1358 | if (Code == bitc::END_BLOCK) { |
| 1359 | if (Stream.ReadBlockEnd()) |
| 1360 | return Error("Error at end of use-list table block"); |
| 1361 | return false; |
| 1362 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1363 | |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 1364 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 1365 | // No known subblocks, always skip them. |
| 1366 | Stream.ReadSubBlockID(); |
| 1367 | if (Stream.SkipBlock()) |
| 1368 | return Error("Malformed block record"); |
| 1369 | continue; |
| 1370 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1371 | |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 1372 | if (Code == bitc::DEFINE_ABBREV) { |
| 1373 | Stream.ReadAbbrevRecord(); |
| 1374 | continue; |
| 1375 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1376 | |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 1377 | // Read a use list record. |
| 1378 | Record.clear(); |
| 1379 | switch (Stream.ReadRecord(Code, Record)) { |
| 1380 | default: // Default behavior: unknown type. |
| 1381 | break; |
| 1382 | case bitc::USELIST_CODE_ENTRY: { // USELIST_CODE_ENTRY: TBD. |
| 1383 | unsigned RecordLength = Record.size(); |
| 1384 | if (RecordLength < 1) |
| 1385 | return Error ("Invalid UseList reader!"); |
| 1386 | UseListRecords.push_back(Record); |
| 1387 | break; |
| 1388 | } |
| 1389 | } |
| 1390 | } |
| 1391 | } |
| 1392 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1393 | /// RememberAndSkipFunctionBody - When we see the block for a function body, |
| 1394 | /// remember where it is and then skip it. This lets us lazily deserialize the |
| 1395 | /// functions. |
| 1396 | bool BitcodeReader::RememberAndSkipFunctionBody() { |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1397 | // Get the function we are talking about. |
| 1398 | if (FunctionsWithBodies.empty()) |
| 1399 | return Error("Insufficient function protos"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1400 | |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1401 | Function *Fn = FunctionsWithBodies.back(); |
| 1402 | FunctionsWithBodies.pop_back(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1403 | |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1404 | // Save the current stream state. |
| 1405 | uint64_t CurBit = Stream.GetCurrentBitNo(); |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 1406 | DeferredFunctionInfo[Fn] = CurBit; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1407 | |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1408 | // Skip over the function block for now. |
| 1409 | if (Stream.SkipBlock()) |
| 1410 | return Error("Malformed block record"); |
| 1411 | return false; |
| 1412 | } |
| 1413 | |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1414 | bool BitcodeReader::GlobalCleanup() { |
| 1415 | // Patch the initializers for globals and aliases up. |
| 1416 | ResolveGlobalAndAliasInits(); |
| 1417 | if (!GlobalInits.empty() || !AliasInits.empty()) |
| 1418 | return Error("Malformed global initializer set"); |
| 1419 | |
| 1420 | // Look for intrinsic functions which need to be upgraded at some point |
| 1421 | for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); |
| 1422 | FI != FE; ++FI) { |
| 1423 | Function *NewFn; |
| 1424 | if (UpgradeIntrinsicFunction(FI, NewFn)) |
| 1425 | UpgradedIntrinsics.push_back(std::make_pair(FI, NewFn)); |
| 1426 | } |
| 1427 | |
| 1428 | // Look for global variables which need to be renamed. |
| 1429 | for (Module::global_iterator |
| 1430 | GI = TheModule->global_begin(), GE = TheModule->global_end(); |
| 1431 | GI != GE; ++GI) |
| 1432 | UpgradeGlobalVariable(GI); |
| 1433 | // Force deallocation of memory for these vectors to favor the client that |
| 1434 | // want lazy deserialization. |
| 1435 | std::vector<std::pair<GlobalVariable*, unsigned> >().swap(GlobalInits); |
| 1436 | std::vector<std::pair<GlobalAlias*, unsigned> >().swap(AliasInits); |
| 1437 | return false; |
| 1438 | } |
| 1439 | |
| 1440 | bool BitcodeReader::ParseModule(bool Resume) { |
| 1441 | if (Resume) |
| 1442 | Stream.JumpToBit(NextUnreadBit); |
| 1443 | else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1444 | return Error("Malformed block record"); |
| 1445 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1446 | SmallVector<uint64_t, 64> Record; |
| 1447 | std::vector<std::string> SectionTable; |
Gordon Henriksen | 5eca075 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 1448 | std::vector<std::string> GCTable; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1449 | |
| 1450 | // Read all the records for this module. |
| 1451 | while (!Stream.AtEndOfStream()) { |
| 1452 | unsigned Code = Stream.ReadCode(); |
Chris Lattner | e84bcb9 | 2007-04-24 00:21:45 +0000 | [diff] [blame] | 1453 | if (Code == bitc::END_BLOCK) { |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1454 | if (Stream.ReadBlockEnd()) |
| 1455 | return Error("Error at end of module block"); |
| 1456 | |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1457 | return GlobalCleanup(); |
Chris Lattner | e84bcb9 | 2007-04-24 00:21:45 +0000 | [diff] [blame] | 1458 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1459 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1460 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 1461 | switch (Stream.ReadSubBlockID()) { |
| 1462 | default: // Skip unknown content. |
| 1463 | if (Stream.SkipBlock()) |
| 1464 | return Error("Malformed block record"); |
| 1465 | break; |
Chris Lattner | 3f79980 | 2007-05-05 18:57:30 +0000 | [diff] [blame] | 1466 | case bitc::BLOCKINFO_BLOCK_ID: |
| 1467 | if (Stream.ReadBlockInfoBlock()) |
| 1468 | return Error("Malformed BlockInfoBlock"); |
| 1469 | break; |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1470 | case bitc::PARAMATTR_BLOCK_ID: |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 1471 | if (ParseAttributeBlock()) |
Chris Lattner | 48c85b8 | 2007-05-04 03:30:17 +0000 | [diff] [blame] | 1472 | return true; |
| 1473 | break; |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 1474 | case bitc::TYPE_BLOCK_ID_NEW: |
Chris Lattner | 8669714 | 2007-05-01 05:01:34 +0000 | [diff] [blame] | 1475 | if (ParseTypeTable()) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1476 | return true; |
| 1477 | break; |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1478 | case bitc::VALUE_SYMTAB_BLOCK_ID: |
Chris Lattner | 8669714 | 2007-05-01 05:01:34 +0000 | [diff] [blame] | 1479 | if (ParseValueSymbolTable()) |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1480 | return true; |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1481 | SeenValueSymbolTable = true; |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1482 | break; |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1483 | case bitc::CONSTANTS_BLOCK_ID: |
Chris Lattner | 8669714 | 2007-05-01 05:01:34 +0000 | [diff] [blame] | 1484 | if (ParseConstants() || ResolveGlobalAndAliasInits()) |
Chris Lattner | e16504e | 2007-04-24 03:30:34 +0000 | [diff] [blame] | 1485 | return true; |
| 1486 | break; |
Devang Patel | e54abc9 | 2009-07-22 17:43:22 +0000 | [diff] [blame] | 1487 | case bitc::METADATA_BLOCK_ID: |
| 1488 | if (ParseMetadata()) |
| 1489 | return true; |
| 1490 | break; |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1491 | case bitc::FUNCTION_BLOCK_ID: |
| 1492 | // If this is the first function body we've seen, reverse the |
| 1493 | // FunctionsWithBodies list. |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1494 | if (!SeenFirstFunctionBody) { |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1495 | std::reverse(FunctionsWithBodies.begin(), FunctionsWithBodies.end()); |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1496 | if (GlobalCleanup()) |
| 1497 | return true; |
| 1498 | SeenFirstFunctionBody = true; |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1499 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1500 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1501 | if (RememberAndSkipFunctionBody()) |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1502 | return true; |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1503 | // For streaming bitcode, suspend parsing when we reach the function |
| 1504 | // bodies. Subsequent materialization calls will resume it when |
| 1505 | // necessary. For streaming, the function bodies must be at the end of |
| 1506 | // the bitcode. If the bitcode file is old, the symbol table will be |
| 1507 | // at the end instead and will not have been seen yet. In this case, |
| 1508 | // just finish the parse now. |
| 1509 | if (LazyStreamer && SeenValueSymbolTable) { |
| 1510 | NextUnreadBit = Stream.GetCurrentBitNo(); |
| 1511 | return false; |
| 1512 | } |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1513 | break; |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 1514 | case bitc::USELIST_BLOCK_ID: |
| 1515 | if (ParseUseLists()) |
| 1516 | return true; |
| 1517 | break; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1518 | } |
| 1519 | continue; |
| 1520 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1521 | |
Chris Lattner | 36d5e7d | 2007-04-23 16:04:05 +0000 | [diff] [blame] | 1522 | if (Code == bitc::DEFINE_ABBREV) { |
Chris Lattner | d127c1b | 2007-04-23 18:58:34 +0000 | [diff] [blame] | 1523 | Stream.ReadAbbrevRecord(); |
| 1524 | continue; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1525 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1526 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1527 | // Read a record. |
| 1528 | switch (Stream.ReadRecord(Code, Record)) { |
| 1529 | default: break; // Default behavior, ignore unknown content. |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 1530 | case bitc::MODULE_CODE_VERSION: { // VERSION: [version#] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1531 | if (Record.size() < 1) |
| 1532 | return Error("Malformed MODULE_CODE_VERSION"); |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 1533 | // Only version #0 and #1 are supported so far. |
| 1534 | unsigned module_version = Record[0]; |
| 1535 | switch (module_version) { |
| 1536 | default: return Error("Unknown bitstream version!"); |
| 1537 | case 0: |
| 1538 | UseRelativeIDs = false; |
| 1539 | break; |
| 1540 | case 1: |
| 1541 | UseRelativeIDs = true; |
| 1542 | break; |
| 1543 | } |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1544 | break; |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 1545 | } |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1546 | case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1547 | std::string S; |
| 1548 | if (ConvertToString(Record, 0, S)) |
| 1549 | return Error("Invalid MODULE_CODE_TRIPLE record"); |
| 1550 | TheModule->setTargetTriple(S); |
| 1551 | break; |
| 1552 | } |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1553 | case bitc::MODULE_CODE_DATALAYOUT: { // DATALAYOUT: [strchr x N] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1554 | std::string S; |
| 1555 | if (ConvertToString(Record, 0, S)) |
| 1556 | return Error("Invalid MODULE_CODE_DATALAYOUT record"); |
| 1557 | TheModule->setDataLayout(S); |
| 1558 | break; |
| 1559 | } |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1560 | case bitc::MODULE_CODE_ASM: { // ASM: [strchr x N] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1561 | std::string S; |
| 1562 | if (ConvertToString(Record, 0, S)) |
| 1563 | return Error("Invalid MODULE_CODE_ASM record"); |
| 1564 | TheModule->setModuleInlineAsm(S); |
| 1565 | break; |
| 1566 | } |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1567 | case bitc::MODULE_CODE_DEPLIB: { // DEPLIB: [strchr x N] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1568 | std::string S; |
| 1569 | if (ConvertToString(Record, 0, S)) |
| 1570 | return Error("Invalid MODULE_CODE_DEPLIB record"); |
| 1571 | TheModule->addLibrary(S); |
| 1572 | break; |
| 1573 | } |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 1574 | case bitc::MODULE_CODE_SECTIONNAME: { // SECTIONNAME: [strchr x N] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1575 | std::string S; |
| 1576 | if (ConvertToString(Record, 0, S)) |
| 1577 | return Error("Invalid MODULE_CODE_SECTIONNAME record"); |
| 1578 | SectionTable.push_back(S); |
| 1579 | break; |
| 1580 | } |
Gordon Henriksen | 5eca075 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 1581 | case bitc::MODULE_CODE_GCNAME: { // SECTIONNAME: [strchr x N] |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 1582 | std::string S; |
| 1583 | if (ConvertToString(Record, 0, S)) |
Gordon Henriksen | 5eca075 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 1584 | return Error("Invalid MODULE_CODE_GCNAME record"); |
| 1585 | GCTable.push_back(S); |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 1586 | break; |
| 1587 | } |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 1588 | // GLOBALVAR: [pointer type, isconst, initid, |
Rafael Espindola | bea4626 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 1589 | // linkage, alignment, section, visibility, threadlocal, |
| 1590 | // unnamed_addr] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1591 | case bitc::MODULE_CODE_GLOBALVAR: { |
Chris Lattner | 36d5e7d | 2007-04-23 16:04:05 +0000 | [diff] [blame] | 1592 | if (Record.size() < 6) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1593 | return Error("Invalid MODULE_CODE_GLOBALVAR record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1594 | Type *Ty = getTypeByID(Record[0]); |
Duncan Sands | f22b746 | 2010-10-28 15:47:26 +0000 | [diff] [blame] | 1595 | if (!Ty) return Error("Invalid MODULE_CODE_GLOBALVAR record"); |
Duncan Sands | 1df9859 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 1596 | if (!Ty->isPointerTy()) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1597 | return Error("Global not a pointer type!"); |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 1598 | unsigned AddressSpace = cast<PointerType>(Ty)->getAddressSpace(); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1599 | Ty = cast<PointerType>(Ty)->getElementType(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1600 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1601 | bool isConstant = Record[1]; |
| 1602 | GlobalValue::LinkageTypes Linkage = GetDecodedLinkage(Record[3]); |
| 1603 | unsigned Alignment = (1 << Record[4]) >> 1; |
| 1604 | std::string Section; |
| 1605 | if (Record[5]) { |
| 1606 | if (Record[5]-1 >= SectionTable.size()) |
| 1607 | return Error("Invalid section ID"); |
| 1608 | Section = SectionTable[Record[5]-1]; |
| 1609 | } |
Chris Lattner | 36d5e7d | 2007-04-23 16:04:05 +0000 | [diff] [blame] | 1610 | GlobalValue::VisibilityTypes Visibility = GlobalValue::DefaultVisibility; |
Chris Lattner | 5f32c01 | 2007-05-06 19:27:46 +0000 | [diff] [blame] | 1611 | if (Record.size() > 6) |
| 1612 | Visibility = GetDecodedVisibility(Record[6]); |
Hans Wennborg | ce718ff | 2012-06-23 11:37:03 +0000 | [diff] [blame] | 1613 | |
| 1614 | GlobalVariable::ThreadLocalMode TLM = GlobalVariable::NotThreadLocal; |
Chris Lattner | 5f32c01 | 2007-05-06 19:27:46 +0000 | [diff] [blame] | 1615 | if (Record.size() > 7) |
Hans Wennborg | ce718ff | 2012-06-23 11:37:03 +0000 | [diff] [blame] | 1616 | TLM = GetDecodedThreadLocalMode(Record[7]); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1617 | |
Rafael Espindola | bea4626 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 1618 | bool UnnamedAddr = false; |
| 1619 | if (Record.size() > 8) |
| 1620 | UnnamedAddr = Record[8]; |
| 1621 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1622 | GlobalVariable *NewGV = |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1623 | new GlobalVariable(*TheModule, Ty, isConstant, Linkage, 0, "", 0, |
Hans Wennborg | ce718ff | 2012-06-23 11:37:03 +0000 | [diff] [blame] | 1624 | TLM, AddressSpace); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1625 | NewGV->setAlignment(Alignment); |
| 1626 | if (!Section.empty()) |
| 1627 | NewGV->setSection(Section); |
| 1628 | NewGV->setVisibility(Visibility); |
Rafael Espindola | bea4626 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 1629 | NewGV->setUnnamedAddr(UnnamedAddr); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1630 | |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1631 | ValueList.push_back(NewGV); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1632 | |
Chris Lattner | 6dbfd7b | 2007-04-24 00:18:21 +0000 | [diff] [blame] | 1633 | // Remember which value to use for the global initializer. |
| 1634 | if (unsigned InitID = Record[2]) |
| 1635 | GlobalInits.push_back(std::make_pair(NewGV, InitID-1)); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1636 | break; |
| 1637 | } |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 1638 | // FUNCTION: [type, callingconv, isproto, linkage, paramattr, |
Rafael Espindola | bea4626 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 1639 | // alignment, section, visibility, gc, unnamed_addr] |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1640 | case bitc::MODULE_CODE_FUNCTION: { |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 1641 | if (Record.size() < 8) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1642 | return Error("Invalid MODULE_CODE_FUNCTION record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1643 | Type *Ty = getTypeByID(Record[0]); |
Duncan Sands | f22b746 | 2010-10-28 15:47:26 +0000 | [diff] [blame] | 1644 | if (!Ty) return Error("Invalid MODULE_CODE_FUNCTION record"); |
Duncan Sands | 1df9859 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 1645 | if (!Ty->isPointerTy()) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1646 | return Error("Function not a pointer type!"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1647 | FunctionType *FTy = |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1648 | dyn_cast<FunctionType>(cast<PointerType>(Ty)->getElementType()); |
| 1649 | if (!FTy) |
| 1650 | return Error("Function not a pointer to function type!"); |
| 1651 | |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 1652 | Function *Func = Function::Create(FTy, GlobalValue::ExternalLinkage, |
| 1653 | "", TheModule); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1654 | |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 1655 | Func->setCallingConv(static_cast<CallingConv::ID>(Record[1])); |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1656 | bool isProto = Record[2]; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1657 | Func->setLinkage(GetDecodedLinkage(Record[3])); |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 1658 | Func->setAttributes(getAttributes(Record[4])); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1659 | |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 1660 | Func->setAlignment((1 << Record[5]) >> 1); |
| 1661 | if (Record[6]) { |
| 1662 | if (Record[6]-1 >= SectionTable.size()) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1663 | return Error("Invalid section ID"); |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 1664 | Func->setSection(SectionTable[Record[6]-1]); |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1665 | } |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 1666 | Func->setVisibility(GetDecodedVisibility(Record[7])); |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 1667 | if (Record.size() > 8 && Record[8]) { |
Gordon Henriksen | 5eca075 | 2008-08-17 18:44:35 +0000 | [diff] [blame] | 1668 | if (Record[8]-1 > GCTable.size()) |
| 1669 | return Error("Invalid GC ID"); |
| 1670 | Func->setGC(GCTable[Record[8]-1].c_str()); |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 1671 | } |
Rafael Espindola | bea4626 | 2011-01-08 16:42:36 +0000 | [diff] [blame] | 1672 | bool UnnamedAddr = false; |
| 1673 | if (Record.size() > 9) |
| 1674 | UnnamedAddr = Record[9]; |
| 1675 | Func->setUnnamedAddr(UnnamedAddr); |
Chris Lattner | 0b2482a | 2007-04-23 21:26:05 +0000 | [diff] [blame] | 1676 | ValueList.push_back(Func); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1677 | |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1678 | // If this is a function with a body, remember the prototype we are |
| 1679 | // creating now, so that we can match up the body with them later. |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1680 | if (!isProto) { |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1681 | FunctionsWithBodies.push_back(Func); |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1682 | if (LazyStreamer) DeferredFunctionInfo[Func] = 0; |
| 1683 | } |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1684 | break; |
| 1685 | } |
Anton Korobeynikov | 91342d8 | 2008-03-12 00:49:19 +0000 | [diff] [blame] | 1686 | // ALIAS: [alias type, aliasee val#, linkage] |
Anton Korobeynikov | f8342b9 | 2008-03-11 21:40:17 +0000 | [diff] [blame] | 1687 | // ALIAS: [alias type, aliasee val#, linkage, visibility] |
Chris Lattner | 198f34a | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 1688 | case bitc::MODULE_CODE_ALIAS: { |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 1689 | if (Record.size() < 3) |
| 1690 | return Error("Invalid MODULE_ALIAS record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 1691 | Type *Ty = getTypeByID(Record[0]); |
Duncan Sands | f22b746 | 2010-10-28 15:47:26 +0000 | [diff] [blame] | 1692 | if (!Ty) return Error("Invalid MODULE_ALIAS record"); |
Duncan Sands | 1df9859 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 1693 | if (!Ty->isPointerTy()) |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 1694 | return Error("Function not a pointer type!"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1695 | |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 1696 | GlobalAlias *NewGA = new GlobalAlias(Ty, GetDecodedLinkage(Record[2]), |
| 1697 | "", 0, TheModule); |
Anton Korobeynikov | 91342d8 | 2008-03-12 00:49:19 +0000 | [diff] [blame] | 1698 | // Old bitcode files didn't have visibility field. |
| 1699 | if (Record.size() > 3) |
| 1700 | NewGA->setVisibility(GetDecodedVisibility(Record[3])); |
Chris Lattner | 07d98b4 | 2007-04-26 02:46:40 +0000 | [diff] [blame] | 1701 | ValueList.push_back(NewGA); |
| 1702 | AliasInits.push_back(std::make_pair(NewGA, Record[1])); |
| 1703 | break; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1704 | } |
Chris Lattner | 198f34a | 2007-04-26 03:27:58 +0000 | [diff] [blame] | 1705 | /// MODULE_CODE_PURGEVALS: [numvals] |
| 1706 | case bitc::MODULE_CODE_PURGEVALS: |
| 1707 | // Trim down the value list to the specified size. |
| 1708 | if (Record.size() < 1 || Record[0] > ValueList.size()) |
| 1709 | return Error("Invalid MODULE_PURGEVALS record"); |
| 1710 | ValueList.shrinkTo(Record[0]); |
| 1711 | break; |
| 1712 | } |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1713 | Record.clear(); |
| 1714 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1715 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1716 | return Error("Premature end of bitstream"); |
| 1717 | } |
| 1718 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 1719 | bool BitcodeReader::ParseBitcodeInto(Module *M) { |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1720 | TheModule = 0; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1721 | |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1722 | if (InitStream()) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1723 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1724 | // Sniff for the signature. |
| 1725 | if (Stream.Read(8) != 'B' || |
| 1726 | Stream.Read(8) != 'C' || |
| 1727 | Stream.Read(4) != 0x0 || |
| 1728 | Stream.Read(4) != 0xC || |
| 1729 | Stream.Read(4) != 0xE || |
| 1730 | Stream.Read(4) != 0xD) |
| 1731 | return Error("Invalid bitcode signature"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1732 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1733 | // We expect a number of well-defined blocks, though we don't necessarily |
| 1734 | // need to understand them all. |
| 1735 | while (!Stream.AtEndOfStream()) { |
| 1736 | unsigned Code = Stream.ReadCode(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1737 | |
Rafael Espindola | c9687b3 | 2011-05-26 18:59:54 +0000 | [diff] [blame] | 1738 | if (Code != bitc::ENTER_SUBBLOCK) { |
| 1739 | |
Chad Rosier | 6ff9aa2 | 2011-08-09 22:23:40 +0000 | [diff] [blame] | 1740 | // The ranlib in xcode 4 will align archive members by appending newlines |
| 1741 | // to the end of them. If this file size is a multiple of 4 but not 8, we |
| 1742 | // have to read and ignore these final 4 bytes :-( |
Rafael Espindola | c9687b3 | 2011-05-26 18:59:54 +0000 | [diff] [blame] | 1743 | if (Stream.GetAbbrevIDWidth() == 2 && Code == 2 && |
| 1744 | Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a && |
Bill Wendling | 2127c9b | 2012-07-19 00:15:11 +0000 | [diff] [blame] | 1745 | Stream.AtEndOfStream()) |
Rafael Espindola | c9687b3 | 2011-05-26 18:59:54 +0000 | [diff] [blame] | 1746 | return false; |
| 1747 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1748 | return Error("Invalid record at top-level"); |
Rafael Espindola | c9687b3 | 2011-05-26 18:59:54 +0000 | [diff] [blame] | 1749 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1750 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1751 | unsigned BlockID = Stream.ReadSubBlockID(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1752 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1753 | // We only know the MODULE subblock ID. |
Chris Lattner | e17b658 | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 1754 | switch (BlockID) { |
| 1755 | case bitc::BLOCKINFO_BLOCK_ID: |
| 1756 | if (Stream.ReadBlockInfoBlock()) |
| 1757 | return Error("Malformed BlockInfoBlock"); |
| 1758 | break; |
| 1759 | case bitc::MODULE_BLOCK_ID: |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 1760 | // Reject multiple MODULE_BLOCK's in a single bitstream. |
| 1761 | if (TheModule) |
| 1762 | return Error("Multiple MODULE_BLOCKs in same stream"); |
| 1763 | TheModule = M; |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1764 | if (ParseModule(false)) |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1765 | return true; |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1766 | if (LazyStreamer) return false; |
Chris Lattner | e17b658 | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 1767 | break; |
| 1768 | default: |
| 1769 | if (Stream.SkipBlock()) |
| 1770 | return Error("Malformed block record"); |
| 1771 | break; |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1772 | } |
| 1773 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1774 | |
Chris Lattner | caee0dc | 2007-04-22 06:23:29 +0000 | [diff] [blame] | 1775 | return false; |
| 1776 | } |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 1777 | |
Bill Wendling | 3471174 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 1778 | bool BitcodeReader::ParseModuleTriple(std::string &Triple) { |
| 1779 | if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID)) |
| 1780 | return Error("Malformed block record"); |
| 1781 | |
| 1782 | SmallVector<uint64_t, 64> Record; |
| 1783 | |
| 1784 | // Read all the records for this module. |
| 1785 | while (!Stream.AtEndOfStream()) { |
| 1786 | unsigned Code = Stream.ReadCode(); |
| 1787 | if (Code == bitc::END_BLOCK) { |
| 1788 | if (Stream.ReadBlockEnd()) |
| 1789 | return Error("Error at end of module block"); |
| 1790 | |
| 1791 | return false; |
| 1792 | } |
| 1793 | |
| 1794 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 1795 | switch (Stream.ReadSubBlockID()) { |
| 1796 | default: // Skip unknown content. |
| 1797 | if (Stream.SkipBlock()) |
| 1798 | return Error("Malformed block record"); |
| 1799 | break; |
| 1800 | } |
| 1801 | continue; |
| 1802 | } |
| 1803 | |
| 1804 | if (Code == bitc::DEFINE_ABBREV) { |
| 1805 | Stream.ReadAbbrevRecord(); |
| 1806 | continue; |
| 1807 | } |
| 1808 | |
| 1809 | // Read a record. |
| 1810 | switch (Stream.ReadRecord(Code, Record)) { |
| 1811 | default: break; // Default behavior, ignore unknown content. |
Bill Wendling | 3471174 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 1812 | case bitc::MODULE_CODE_TRIPLE: { // TRIPLE: [strchr x N] |
| 1813 | std::string S; |
| 1814 | if (ConvertToString(Record, 0, S)) |
| 1815 | return Error("Invalid MODULE_CODE_TRIPLE record"); |
| 1816 | Triple = S; |
| 1817 | break; |
| 1818 | } |
| 1819 | } |
| 1820 | Record.clear(); |
| 1821 | } |
| 1822 | |
| 1823 | return Error("Premature end of bitstream"); |
| 1824 | } |
| 1825 | |
| 1826 | bool BitcodeReader::ParseTriple(std::string &Triple) { |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 1827 | if (InitStream()) return true; |
Bill Wendling | 3471174 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 1828 | |
| 1829 | // Sniff for the signature. |
| 1830 | if (Stream.Read(8) != 'B' || |
| 1831 | Stream.Read(8) != 'C' || |
| 1832 | Stream.Read(4) != 0x0 || |
| 1833 | Stream.Read(4) != 0xC || |
| 1834 | Stream.Read(4) != 0xE || |
| 1835 | Stream.Read(4) != 0xD) |
| 1836 | return Error("Invalid bitcode signature"); |
| 1837 | |
| 1838 | // We expect a number of well-defined blocks, though we don't necessarily |
| 1839 | // need to understand them all. |
| 1840 | while (!Stream.AtEndOfStream()) { |
| 1841 | unsigned Code = Stream.ReadCode(); |
| 1842 | |
| 1843 | if (Code != bitc::ENTER_SUBBLOCK) |
| 1844 | return Error("Invalid record at top-level"); |
| 1845 | |
| 1846 | unsigned BlockID = Stream.ReadSubBlockID(); |
| 1847 | |
| 1848 | // We only know the MODULE subblock ID. |
| 1849 | switch (BlockID) { |
| 1850 | case bitc::MODULE_BLOCK_ID: |
| 1851 | if (ParseModuleTriple(Triple)) |
| 1852 | return true; |
| 1853 | break; |
| 1854 | default: |
| 1855 | if (Stream.SkipBlock()) |
| 1856 | return Error("Malformed block record"); |
| 1857 | break; |
| 1858 | } |
| 1859 | } |
| 1860 | |
| 1861 | return false; |
| 1862 | } |
| 1863 | |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1864 | /// ParseMetadataAttachment - Parse metadata attachments. |
| 1865 | bool BitcodeReader::ParseMetadataAttachment() { |
| 1866 | if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID)) |
| 1867 | return Error("Malformed block record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1868 | |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1869 | SmallVector<uint64_t, 64> Record; |
| 1870 | while(1) { |
| 1871 | unsigned Code = Stream.ReadCode(); |
| 1872 | if (Code == bitc::END_BLOCK) { |
| 1873 | if (Stream.ReadBlockEnd()) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1874 | return Error("Error at end of PARAMATTR block"); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1875 | break; |
| 1876 | } |
| 1877 | if (Code == bitc::DEFINE_ABBREV) { |
| 1878 | Stream.ReadAbbrevRecord(); |
| 1879 | continue; |
| 1880 | } |
| 1881 | // Read a metadata attachment record. |
| 1882 | Record.clear(); |
| 1883 | switch (Stream.ReadRecord(Code, Record)) { |
| 1884 | default: // Default behavior: ignore. |
| 1885 | break; |
Chris Lattner | 9d61dd9 | 2011-06-17 17:50:30 +0000 | [diff] [blame] | 1886 | case bitc::METADATA_ATTACHMENT: { |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1887 | unsigned RecordLength = Record.size(); |
| 1888 | if (Record.empty() || (RecordLength - 1) % 2 == 1) |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1889 | return Error ("Invalid METADATA_ATTACHMENT reader!"); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1890 | Instruction *Inst = InstructionList[Record[0]]; |
| 1891 | for (unsigned i = 1; i != RecordLength; i = i+2) { |
Devang Patel | a214840 | 2009-09-28 21:14:55 +0000 | [diff] [blame] | 1892 | unsigned Kind = Record[i]; |
Dan Gohman | 19538d1 | 2010-07-20 21:42:28 +0000 | [diff] [blame] | 1893 | DenseMap<unsigned, unsigned>::iterator I = |
| 1894 | MDKindMap.find(Kind); |
| 1895 | if (I == MDKindMap.end()) |
| 1896 | return Error("Invalid metadata kind ID"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1897 | Value *Node = MDValueList.getValueFwdRef(Record[i+1]); |
Dan Gohman | 19538d1 | 2010-07-20 21:42:28 +0000 | [diff] [blame] | 1898 | Inst->setMetadata(I->second, cast<MDNode>(Node)); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1899 | } |
| 1900 | break; |
| 1901 | } |
| 1902 | } |
| 1903 | } |
| 1904 | return false; |
| 1905 | } |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 1906 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1907 | /// ParseFunctionBody - Lazily parse the specified function body block. |
| 1908 | bool BitcodeReader::ParseFunctionBody(Function *F) { |
Chris Lattner | e17b658 | 2007-05-05 00:17:00 +0000 | [diff] [blame] | 1909 | if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID)) |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1910 | return Error("Malformed block record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1911 | |
Nick Lewycky | 9a49f15 | 2010-02-25 08:30:17 +0000 | [diff] [blame] | 1912 | InstructionList.clear(); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1913 | unsigned ModuleValueListSize = ValueList.size(); |
Dan Gohman | 6981383 | 2010-08-25 20:22:53 +0000 | [diff] [blame] | 1914 | unsigned ModuleMDValueListSize = MDValueList.size(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1915 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1916 | // Add all the function arguments to the value table. |
| 1917 | for(Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) |
| 1918 | ValueList.push_back(I); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1919 | |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1920 | unsigned NextValueNo = ValueList.size(); |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 1921 | BasicBlock *CurBB = 0; |
| 1922 | unsigned CurBBNo = 0; |
| 1923 | |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 1924 | DebugLoc LastLoc; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1925 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1926 | // Read all the records. |
| 1927 | SmallVector<uint64_t, 64> Record; |
| 1928 | while (1) { |
| 1929 | unsigned Code = Stream.ReadCode(); |
| 1930 | if (Code == bitc::END_BLOCK) { |
| 1931 | if (Stream.ReadBlockEnd()) |
| 1932 | return Error("Error at end of function block"); |
| 1933 | break; |
| 1934 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1935 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1936 | if (Code == bitc::ENTER_SUBBLOCK) { |
| 1937 | switch (Stream.ReadSubBlockID()) { |
| 1938 | default: // Skip unknown content. |
| 1939 | if (Stream.SkipBlock()) |
| 1940 | return Error("Malformed block record"); |
| 1941 | break; |
| 1942 | case bitc::CONSTANTS_BLOCK_ID: |
| 1943 | if (ParseConstants()) return true; |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1944 | NextValueNo = ValueList.size(); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1945 | break; |
| 1946 | case bitc::VALUE_SYMTAB_BLOCK_ID: |
| 1947 | if (ParseValueSymbolTable()) return true; |
| 1948 | break; |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 1949 | case bitc::METADATA_ATTACHMENT_ID: |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1950 | if (ParseMetadataAttachment()) return true; |
| 1951 | break; |
Victor Hernandez | fab9e99c | 2010-01-13 19:34:08 +0000 | [diff] [blame] | 1952 | case bitc::METADATA_BLOCK_ID: |
| 1953 | if (ParseMetadata()) return true; |
| 1954 | break; |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1955 | } |
| 1956 | continue; |
| 1957 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1958 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1959 | if (Code == bitc::DEFINE_ABBREV) { |
| 1960 | Stream.ReadAbbrevRecord(); |
| 1961 | continue; |
| 1962 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 1963 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1964 | // Read a record. |
| 1965 | Record.clear(); |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1966 | Instruction *I = 0; |
Dan Gohman | 1224c38 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 1967 | unsigned BitCode = Stream.ReadRecord(Code, Record); |
| 1968 | switch (BitCode) { |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1969 | default: // Default behavior: reject |
| 1970 | return Error("Unknown instruction"); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1971 | case bitc::FUNC_CODE_DECLAREBLOCKS: // DECLAREBLOCKS: [nblocks] |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1972 | if (Record.size() < 1 || Record[0] == 0) |
| 1973 | return Error("Invalid DECLAREBLOCKS record"); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1974 | // Create all the basic blocks for the function. |
Chris Lattner | f61e645 | 2007-05-03 22:09:51 +0000 | [diff] [blame] | 1975 | FunctionBBs.resize(Record[0]); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 1976 | for (unsigned i = 0, e = FunctionBBs.size(); i != e; ++i) |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 1977 | FunctionBBs[i] = BasicBlock::Create(Context, "", F); |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 1978 | CurBB = FunctionBBs[0]; |
| 1979 | continue; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1980 | |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 1981 | case bitc::FUNC_CODE_DEBUG_LOC_AGAIN: // DEBUG_LOC_AGAIN |
| 1982 | // This record indicates that the last instruction is at the same |
| 1983 | // location as the previous instruction with a location. |
| 1984 | I = 0; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1985 | |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 1986 | // Get the last instruction emitted. |
| 1987 | if (CurBB && !CurBB->empty()) |
| 1988 | I = &CurBB->back(); |
| 1989 | else if (CurBBNo && FunctionBBs[CurBBNo-1] && |
| 1990 | !FunctionBBs[CurBBNo-1]->empty()) |
| 1991 | I = &FunctionBBs[CurBBNo-1]->back(); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1992 | |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 1993 | if (I == 0) return Error("Invalid DEBUG_LOC_AGAIN record"); |
| 1994 | I->setDebugLoc(LastLoc); |
| 1995 | I = 0; |
| 1996 | continue; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 1997 | |
Chris Lattner | 4f6bab9 | 2011-06-17 18:17:37 +0000 | [diff] [blame] | 1998 | case bitc::FUNC_CODE_DEBUG_LOC: { // DEBUG_LOC: [line, col, scope, ia] |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 1999 | I = 0; // Get the last instruction emitted. |
| 2000 | if (CurBB && !CurBB->empty()) |
| 2001 | I = &CurBB->back(); |
| 2002 | else if (CurBBNo && FunctionBBs[CurBBNo-1] && |
| 2003 | !FunctionBBs[CurBBNo-1]->empty()) |
| 2004 | I = &FunctionBBs[CurBBNo-1]->back(); |
| 2005 | if (I == 0 || Record.size() < 4) |
| 2006 | return Error("Invalid FUNC_CODE_DEBUG_LOC record"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2007 | |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 2008 | unsigned Line = Record[0], Col = Record[1]; |
| 2009 | unsigned ScopeID = Record[2], IAID = Record[3]; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2010 | |
Chris Lattner | a624524 | 2010-04-03 02:17:50 +0000 | [diff] [blame] | 2011 | MDNode *Scope = 0, *IA = 0; |
| 2012 | if (ScopeID) Scope = cast<MDNode>(MDValueList.getValueFwdRef(ScopeID-1)); |
| 2013 | if (IAID) IA = cast<MDNode>(MDValueList.getValueFwdRef(IAID-1)); |
| 2014 | LastLoc = DebugLoc::get(Line, Col, Scope, IA); |
| 2015 | I->setDebugLoc(LastLoc); |
| 2016 | I = 0; |
| 2017 | continue; |
| 2018 | } |
| 2019 | |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2020 | case bitc::FUNC_CODE_INST_BINOP: { // BINOP: [opval, ty, opval, opcode] |
| 2021 | unsigned OpNum = 0; |
| 2022 | Value *LHS, *RHS; |
| 2023 | if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2024 | popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || |
Dan Gohman | 1224c38 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 2025 | OpNum+1 > Record.size()) |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2026 | return Error("Invalid BINOP record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2027 | |
Dan Gohman | 1224c38 | 2009-07-20 21:19:07 +0000 | [diff] [blame] | 2028 | int Opc = GetDecodedBinaryOpcode(Record[OpNum++], LHS->getType()); |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2029 | if (Opc == -1) return Error("Invalid BINOP record"); |
Gabor Greif | 7cbd8a3 | 2008-05-16 19:29:10 +0000 | [diff] [blame] | 2030 | I = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2031 | InstructionList.push_back(I); |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2032 | if (OpNum < Record.size()) { |
| 2033 | if (Opc == Instruction::Add || |
| 2034 | Opc == Instruction::Sub || |
Chris Lattner | f067d58 | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 2035 | Opc == Instruction::Mul || |
| 2036 | Opc == Instruction::Shl) { |
Dan Gohman | 26793ed | 2010-01-25 21:55:39 +0000 | [diff] [blame] | 2037 | if (Record[OpNum] & (1 << bitc::OBO_NO_SIGNED_WRAP)) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2038 | cast<BinaryOperator>(I)->setHasNoSignedWrap(true); |
Dan Gohman | 26793ed | 2010-01-25 21:55:39 +0000 | [diff] [blame] | 2039 | if (Record[OpNum] & (1 << bitc::OBO_NO_UNSIGNED_WRAP)) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2040 | cast<BinaryOperator>(I)->setHasNoUnsignedWrap(true); |
Chris Lattner | 35bda89 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 2041 | } else if (Opc == Instruction::SDiv || |
Chris Lattner | f067d58 | 2011-02-07 16:40:21 +0000 | [diff] [blame] | 2042 | Opc == Instruction::UDiv || |
| 2043 | Opc == Instruction::LShr || |
| 2044 | Opc == Instruction::AShr) { |
Chris Lattner | 35bda89 | 2011-02-06 21:44:57 +0000 | [diff] [blame] | 2045 | if (Record[OpNum] & (1 << bitc::PEO_EXACT)) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2046 | cast<BinaryOperator>(I)->setIsExact(true); |
| 2047 | } |
| 2048 | } |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 2049 | break; |
| 2050 | } |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2051 | case bitc::FUNC_CODE_INST_CAST: { // CAST: [opval, opty, destty, castopc] |
| 2052 | unsigned OpNum = 0; |
| 2053 | Value *Op; |
| 2054 | if (getValueTypePair(Record, OpNum, NextValueNo, Op) || |
| 2055 | OpNum+2 != Record.size()) |
| 2056 | return Error("Invalid CAST record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2057 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2058 | Type *ResTy = getTypeByID(Record[OpNum]); |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2059 | int Opc = GetDecodedCastOpcode(Record[OpNum+1]); |
| 2060 | if (Opc == -1 || ResTy == 0) |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 2061 | return Error("Invalid CAST record"); |
Gabor Greif | 7cbd8a3 | 2008-05-16 19:29:10 +0000 | [diff] [blame] | 2062 | I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2063 | InstructionList.push_back(I); |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 2064 | break; |
| 2065 | } |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 2066 | case bitc::FUNC_CODE_INST_INBOUNDS_GEP: |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2067 | case bitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands] |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2068 | unsigned OpNum = 0; |
| 2069 | Value *BasePtr; |
| 2070 | if (getValueTypePair(Record, OpNum, NextValueNo, BasePtr)) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2071 | return Error("Invalid GEP record"); |
| 2072 | |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2073 | SmallVector<Value*, 16> GEPIdx; |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2074 | while (OpNum != Record.size()) { |
| 2075 | Value *Op; |
| 2076 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2077 | return Error("Invalid GEP record"); |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2078 | GEPIdx.push_back(Op); |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2079 | } |
| 2080 | |
Jay Foad | a920310 | 2011-07-25 09:48:08 +0000 | [diff] [blame] | 2081 | I = GetElementPtrInst::Create(BasePtr, GEPIdx); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2082 | InstructionList.push_back(I); |
Dan Gohman | dd8004d | 2009-07-27 21:53:46 +0000 | [diff] [blame] | 2083 | if (BitCode == bitc::FUNC_CODE_INST_INBOUNDS_GEP) |
Dan Gohman | f8dbee7 | 2009-09-07 23:54:19 +0000 | [diff] [blame] | 2084 | cast<GetElementPtrInst>(I)->setIsInBounds(true); |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2085 | break; |
| 2086 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2087 | |
Dan Gohman | 81a0c0b | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 2088 | case bitc::FUNC_CODE_INST_EXTRACTVAL: { |
| 2089 | // EXTRACTVAL: [opty, opval, n x indices] |
Dan Gohman | e4977cf | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 2090 | unsigned OpNum = 0; |
| 2091 | Value *Agg; |
| 2092 | if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) |
| 2093 | return Error("Invalid EXTRACTVAL record"); |
| 2094 | |
Dan Gohman | 81a0c0b | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 2095 | SmallVector<unsigned, 4> EXTRACTVALIdx; |
| 2096 | for (unsigned RecSize = Record.size(); |
| 2097 | OpNum != RecSize; ++OpNum) { |
| 2098 | uint64_t Index = Record[OpNum]; |
| 2099 | if ((unsigned)Index != Index) |
| 2100 | return Error("Invalid EXTRACTVAL index"); |
| 2101 | EXTRACTVALIdx.push_back((unsigned)Index); |
Dan Gohman | e4977cf | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 2102 | } |
| 2103 | |
Jay Foad | fc6d3a4 | 2011-07-13 10:26:04 +0000 | [diff] [blame] | 2104 | I = ExtractValueInst::Create(Agg, EXTRACTVALIdx); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2105 | InstructionList.push_back(I); |
Dan Gohman | e4977cf | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 2106 | break; |
| 2107 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2108 | |
Dan Gohman | 81a0c0b | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 2109 | case bitc::FUNC_CODE_INST_INSERTVAL: { |
| 2110 | // INSERTVAL: [opty, opval, opty, opval, n x indices] |
Dan Gohman | e4977cf | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 2111 | unsigned OpNum = 0; |
| 2112 | Value *Agg; |
| 2113 | if (getValueTypePair(Record, OpNum, NextValueNo, Agg)) |
| 2114 | return Error("Invalid INSERTVAL record"); |
| 2115 | Value *Val; |
| 2116 | if (getValueTypePair(Record, OpNum, NextValueNo, Val)) |
| 2117 | return Error("Invalid INSERTVAL record"); |
| 2118 | |
Dan Gohman | 81a0c0b | 2008-05-31 00:58:22 +0000 | [diff] [blame] | 2119 | SmallVector<unsigned, 4> INSERTVALIdx; |
| 2120 | for (unsigned RecSize = Record.size(); |
| 2121 | OpNum != RecSize; ++OpNum) { |
| 2122 | uint64_t Index = Record[OpNum]; |
| 2123 | if ((unsigned)Index != Index) |
| 2124 | return Error("Invalid INSERTVAL index"); |
| 2125 | INSERTVALIdx.push_back((unsigned)Index); |
Dan Gohman | e4977cf | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 2126 | } |
| 2127 | |
Jay Foad | fc6d3a4 | 2011-07-13 10:26:04 +0000 | [diff] [blame] | 2128 | I = InsertValueInst::Create(Agg, Val, INSERTVALIdx); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2129 | InstructionList.push_back(I); |
Dan Gohman | e4977cf | 2008-05-23 01:55:30 +0000 | [diff] [blame] | 2130 | break; |
| 2131 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2132 | |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2133 | case bitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, ty, opval, opval] |
Dan Gohman | fb2bbbe | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 2134 | // obsolete form of select |
| 2135 | // handles select i1 ... in old bitcode |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2136 | unsigned OpNum = 0; |
| 2137 | Value *TrueVal, *FalseVal, *Cond; |
| 2138 | if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2139 | popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || |
| 2140 | popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond)) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2141 | return Error("Invalid SELECT record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2142 | |
Dan Gohman | fb2bbbe | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 2143 | I = SelectInst::Create(Cond, TrueVal, FalseVal); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2144 | InstructionList.push_back(I); |
Dan Gohman | fb2bbbe | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 2145 | break; |
| 2146 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2147 | |
Dan Gohman | fb2bbbe | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 2148 | case bitc::FUNC_CODE_INST_VSELECT: {// VSELECT: [ty,opval,opval,predty,pred] |
| 2149 | // new form of select |
| 2150 | // handles select i1 or select [N x i1] |
| 2151 | unsigned OpNum = 0; |
| 2152 | Value *TrueVal, *FalseVal, *Cond; |
| 2153 | if (getValueTypePair(Record, OpNum, NextValueNo, TrueVal) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2154 | popValue(Record, OpNum, NextValueNo, TrueVal->getType(), FalseVal) || |
Dan Gohman | fb2bbbe | 2008-09-16 01:01:33 +0000 | [diff] [blame] | 2155 | getValueTypePair(Record, OpNum, NextValueNo, Cond)) |
| 2156 | return Error("Invalid SELECT record"); |
Dan Gohman | f72fb67 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 2157 | |
| 2158 | // select condition can be either i1 or [N x i1] |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2159 | if (VectorType* vector_type = |
| 2160 | dyn_cast<VectorType>(Cond->getType())) { |
Dan Gohman | f72fb67 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 2161 | // expect <n x i1> |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2162 | if (vector_type->getElementType() != Type::getInt1Ty(Context)) |
Dan Gohman | f72fb67 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 2163 | return Error("Invalid SELECT condition type"); |
| 2164 | } else { |
| 2165 | // expect i1 |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2166 | if (Cond->getType() != Type::getInt1Ty(Context)) |
Dan Gohman | f72fb67 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 2167 | return Error("Invalid SELECT condition type"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2168 | } |
| 2169 | |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 2170 | I = SelectInst::Create(Cond, TrueVal, FalseVal); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2171 | InstructionList.push_back(I); |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2172 | break; |
| 2173 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2174 | |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2175 | case bitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opty, opval, opval] |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2176 | unsigned OpNum = 0; |
| 2177 | Value *Vec, *Idx; |
| 2178 | if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2179 | popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2180 | return Error("Invalid EXTRACTELT record"); |
Eric Christopher | a3500da | 2009-07-25 02:28:41 +0000 | [diff] [blame] | 2181 | I = ExtractElementInst::Create(Vec, Idx); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2182 | InstructionList.push_back(I); |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2183 | break; |
| 2184 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2185 | |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2186 | case bitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [ty, opval,opval,opval] |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2187 | unsigned OpNum = 0; |
| 2188 | Value *Vec, *Elt, *Idx; |
| 2189 | if (getValueTypePair(Record, OpNum, NextValueNo, Vec) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2190 | popValue(Record, OpNum, NextValueNo, |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2191 | cast<VectorType>(Vec->getType())->getElementType(), Elt) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2192 | popValue(Record, OpNum, NextValueNo, Type::getInt32Ty(Context), Idx)) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2193 | return Error("Invalid INSERTELT record"); |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 2194 | I = InsertElementInst::Create(Vec, Elt, Idx); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2195 | InstructionList.push_back(I); |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2196 | break; |
| 2197 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2198 | |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2199 | case bitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval,ty,opval,opval] |
| 2200 | unsigned OpNum = 0; |
| 2201 | Value *Vec1, *Vec2, *Mask; |
| 2202 | if (getValueTypePair(Record, OpNum, NextValueNo, Vec1) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2203 | popValue(Record, OpNum, NextValueNo, Vec1->getType(), Vec2)) |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2204 | return Error("Invalid SHUFFLEVEC record"); |
| 2205 | |
Mon P Wang | aeb06d2 | 2008-11-10 04:46:22 +0000 | [diff] [blame] | 2206 | if (getValueTypePair(Record, OpNum, NextValueNo, Mask)) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2207 | return Error("Invalid SHUFFLEVEC record"); |
| 2208 | I = new ShuffleVectorInst(Vec1, Vec2, Mask); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2209 | InstructionList.push_back(I); |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2210 | break; |
| 2211 | } |
Mon P Wang | aeb06d2 | 2008-11-10 04:46:22 +0000 | [diff] [blame] | 2212 | |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2213 | case bitc::FUNC_CODE_INST_CMP: // CMP: [opty, opval, opval, pred] |
| 2214 | // Old form of ICmp/FCmp returning bool |
| 2215 | // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were |
| 2216 | // both legal on vectors but had different behaviour. |
| 2217 | case bitc::FUNC_CODE_INST_CMP2: { // CMP2: [opty, opval, opval, pred] |
| 2218 | // FCmp/ICmp returning bool or vector of bool |
| 2219 | |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2220 | unsigned OpNum = 0; |
| 2221 | Value *LHS, *RHS; |
| 2222 | if (getValueTypePair(Record, OpNum, NextValueNo, LHS) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2223 | popValue(Record, OpNum, NextValueNo, LHS->getType(), RHS) || |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2224 | OpNum+1 != Record.size()) |
Chris Lattner | 01ff65f | 2007-05-02 05:16:49 +0000 | [diff] [blame] | 2225 | return Error("Invalid CMP record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2226 | |
Duncan Sands | b0bc6c3 | 2010-02-15 16:12:20 +0000 | [diff] [blame] | 2227 | if (LHS->getType()->isFPOrFPVectorTy()) |
Dan Gohman | 1c8a23c | 2009-08-25 23:17:54 +0000 | [diff] [blame] | 2228 | I = new FCmpInst((FCmpInst::Predicate)Record[OpNum], LHS, RHS); |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2229 | else |
Dan Gohman | 1c8a23c | 2009-08-25 23:17:54 +0000 | [diff] [blame] | 2230 | I = new ICmpInst((ICmpInst::Predicate)Record[OpNum], LHS, RHS); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2231 | InstructionList.push_back(I); |
Dan Gohman | f72fb67 | 2008-09-09 01:02:47 +0000 | [diff] [blame] | 2232 | break; |
| 2233 | } |
Nick Lewycky | 7f6aa2b | 2009-07-08 03:04:38 +0000 | [diff] [blame] | 2234 | |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 2235 | case bitc::FUNC_CODE_INST_RET: // RET: [opty,opval<optional>] |
Devang Patel | d9d99ff | 2008-02-26 01:29:32 +0000 | [diff] [blame] | 2236 | { |
| 2237 | unsigned Size = Record.size(); |
| 2238 | if (Size == 0) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2239 | I = ReturnInst::Create(Context); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2240 | InstructionList.push_back(I); |
Devang Patel | d9d99ff | 2008-02-26 01:29:32 +0000 | [diff] [blame] | 2241 | break; |
Dan Gohman | fc74abf | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 2242 | } |
Devang Patel | d9d99ff | 2008-02-26 01:29:32 +0000 | [diff] [blame] | 2243 | |
Dan Gohman | fc74abf | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 2244 | unsigned OpNum = 0; |
Chris Lattner | 96a74c5 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 2245 | Value *Op = NULL; |
| 2246 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
| 2247 | return Error("Invalid RET record"); |
| 2248 | if (OpNum != Record.size()) |
| 2249 | return Error("Invalid RET record"); |
Dan Gohman | fc74abf | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 2250 | |
Chris Lattner | 96a74c5 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 2251 | I = ReturnInst::Create(Context, Op); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2252 | InstructionList.push_back(I); |
Dan Gohman | fc74abf | 2008-07-23 00:34:11 +0000 | [diff] [blame] | 2253 | break; |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 2254 | } |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2255 | case bitc::FUNC_CODE_INST_BR: { // BR: [bb#, bb#, opval] or [bb#] |
Chris Lattner | f61e645 | 2007-05-03 22:09:51 +0000 | [diff] [blame] | 2256 | if (Record.size() != 1 && Record.size() != 3) |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2257 | return Error("Invalid BR record"); |
| 2258 | BasicBlock *TrueDest = getBasicBlock(Record[0]); |
| 2259 | if (TrueDest == 0) |
| 2260 | return Error("Invalid BR record"); |
| 2261 | |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2262 | if (Record.size() == 1) { |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 2263 | I = BranchInst::Create(TrueDest); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2264 | InstructionList.push_back(I); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2265 | } |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2266 | else { |
| 2267 | BasicBlock *FalseDest = getBasicBlock(Record[1]); |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2268 | Value *Cond = getValue(Record, 2, NextValueNo, |
| 2269 | Type::getInt1Ty(Context)); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2270 | if (FalseDest == 0 || Cond == 0) |
| 2271 | return Error("Invalid BR record"); |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 2272 | I = BranchInst::Create(TrueDest, FalseDest, Cond); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2273 | InstructionList.push_back(I); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2274 | } |
| 2275 | break; |
| 2276 | } |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2277 | case bitc::FUNC_CODE_INST_SWITCH: { // SWITCH: [opty, op0, op1, ...] |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2278 | // Check magic |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2279 | if ((Record[0] >> 16) == SWITCH_INST_MAGIC) { |
| 2280 | // New SwitchInst format with case ranges. |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2281 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2282 | Type *OpTy = getTypeByID(Record[1]); |
| 2283 | unsigned ValueBitWidth = cast<IntegerType>(OpTy)->getBitWidth(); |
| 2284 | |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2285 | Value *Cond = getValue(Record, 2, NextValueNo, OpTy); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2286 | BasicBlock *Default = getBasicBlock(Record[3]); |
| 2287 | if (OpTy == 0 || Cond == 0 || Default == 0) |
| 2288 | return Error("Invalid SWITCH record"); |
| 2289 | |
| 2290 | unsigned NumCases = Record[4]; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2291 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2292 | SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); |
| 2293 | InstructionList.push_back(SI); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2294 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2295 | unsigned CurIdx = 5; |
| 2296 | for (unsigned i = 0; i != NumCases; ++i) { |
Stepan Dyatkovskiy | 0aa32d5 | 2012-05-29 12:26:47 +0000 | [diff] [blame] | 2297 | IntegersSubsetToBB CaseBuilder; |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2298 | unsigned NumItems = Record[CurIdx++]; |
| 2299 | for (unsigned ci = 0; ci != NumItems; ++ci) { |
| 2300 | bool isSingleNumber = Record[CurIdx++]; |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2301 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2302 | APInt Low; |
| 2303 | unsigned ActiveWords = 1; |
| 2304 | if (ValueBitWidth > 64) |
| 2305 | ActiveWords = Record[CurIdx++]; |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2306 | Low = ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), |
| 2307 | ValueBitWidth); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2308 | CurIdx += ActiveWords; |
Stepan Dyatkovskiy | 484fc93 | 2012-05-28 12:39:09 +0000 | [diff] [blame] | 2309 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2310 | if (!isSingleNumber) { |
| 2311 | ActiveWords = 1; |
| 2312 | if (ValueBitWidth > 64) |
| 2313 | ActiveWords = Record[CurIdx++]; |
| 2314 | APInt High = |
Benjamin Kramer | f52aea8 | 2012-05-28 14:10:31 +0000 | [diff] [blame] | 2315 | ReadWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords), |
| 2316 | ValueBitWidth); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2317 | |
Stepan Dyatkovskiy | 484fc93 | 2012-05-28 12:39:09 +0000 | [diff] [blame] | 2318 | CaseBuilder.add(IntItem::fromType(OpTy, Low), |
| 2319 | IntItem::fromType(OpTy, High)); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2320 | CurIdx += ActiveWords; |
| 2321 | } else |
Stepan Dyatkovskiy | 484fc93 | 2012-05-28 12:39:09 +0000 | [diff] [blame] | 2322 | CaseBuilder.add(IntItem::fromType(OpTy, Low)); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2323 | } |
| 2324 | BasicBlock *DestBB = getBasicBlock(Record[CurIdx++]); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2325 | IntegersSubset Case = CaseBuilder.getCase(); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2326 | SI->addCase(Case, DestBB); |
| 2327 | } |
Stepan Dyatkovskiy | 734dde8 | 2012-05-14 08:26:31 +0000 | [diff] [blame] | 2328 | uint16_t Hash = SI->hash(); |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2329 | if (Hash != (Record[0] & 0xFFFF)) |
| 2330 | return Error("Invalid SWITCH record"); |
| 2331 | I = SI; |
| 2332 | break; |
| 2333 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2334 | |
Stepan Dyatkovskiy | 1cce5bf | 2012-05-12 10:48:17 +0000 | [diff] [blame] | 2335 | // Old SwitchInst format without case ranges. |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2336 | |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2337 | if (Record.size() < 3 || (Record.size() & 1) == 0) |
| 2338 | return Error("Invalid SWITCH record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2339 | Type *OpTy = getTypeByID(Record[0]); |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2340 | Value *Cond = getValue(Record, 1, NextValueNo, OpTy); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2341 | BasicBlock *Default = getBasicBlock(Record[2]); |
| 2342 | if (OpTy == 0 || Cond == 0 || Default == 0) |
| 2343 | return Error("Invalid SWITCH record"); |
| 2344 | unsigned NumCases = (Record.size()-3)/2; |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame] | 2345 | SwitchInst *SI = SwitchInst::Create(Cond, Default, NumCases); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2346 | InstructionList.push_back(SI); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2347 | for (unsigned i = 0, e = NumCases; i != e; ++i) { |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2348 | ConstantInt *CaseVal = |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2349 | dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy)); |
| 2350 | BasicBlock *DestBB = getBasicBlock(Record[1+3+i*2]); |
| 2351 | if (CaseVal == 0 || DestBB == 0) { |
| 2352 | delete SI; |
| 2353 | return Error("Invalid SWITCH record!"); |
| 2354 | } |
| 2355 | SI->addCase(CaseVal, DestBB); |
| 2356 | } |
| 2357 | I = SI; |
| 2358 | break; |
| 2359 | } |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 2360 | case bitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...] |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2361 | if (Record.size() < 2) |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 2362 | return Error("Invalid INDIRECTBR record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2363 | Type *OpTy = getTypeByID(Record[0]); |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2364 | Value *Address = getValue(Record, 1, NextValueNo, OpTy); |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2365 | if (OpTy == 0 || Address == 0) |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 2366 | return Error("Invalid INDIRECTBR record"); |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2367 | unsigned NumDests = Record.size()-2; |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 2368 | IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests); |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2369 | InstructionList.push_back(IBI); |
| 2370 | for (unsigned i = 0, e = NumDests; i != e; ++i) { |
| 2371 | if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) { |
| 2372 | IBI->addDestination(DestBB); |
| 2373 | } else { |
| 2374 | delete IBI; |
Chris Lattner | ab21db7 | 2009-10-28 00:19:10 +0000 | [diff] [blame] | 2375 | return Error("Invalid INDIRECTBR record!"); |
Chris Lattner | f9be95f | 2009-10-27 19:13:16 +0000 | [diff] [blame] | 2376 | } |
| 2377 | } |
| 2378 | I = IBI; |
| 2379 | break; |
| 2380 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2381 | |
Duncan Sands | dc02467 | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 2382 | case bitc::FUNC_CODE_INST_INVOKE: { |
| 2383 | // INVOKE: [attrs, cc, normBB, unwindBB, fnty, op0,op1,op2, ...] |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 2384 | if (Record.size() < 4) return Error("Invalid INVOKE record"); |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 2385 | AttrListPtr PAL = getAttributes(Record[0]); |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 2386 | unsigned CCInfo = Record[1]; |
| 2387 | BasicBlock *NormalBB = getBasicBlock(Record[2]); |
| 2388 | BasicBlock *UnwindBB = getBasicBlock(Record[3]); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2389 | |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 2390 | unsigned OpNum = 4; |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2391 | Value *Callee; |
| 2392 | if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2393 | return Error("Invalid INVOKE record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2394 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2395 | PointerType *CalleeTy = dyn_cast<PointerType>(Callee->getType()); |
| 2396 | FunctionType *FTy = !CalleeTy ? 0 : |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2397 | dyn_cast<FunctionType>(CalleeTy->getElementType()); |
| 2398 | |
| 2399 | // Check that the right number of fixed parameters are here. |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2400 | if (FTy == 0 || NormalBB == 0 || UnwindBB == 0 || |
| 2401 | Record.size() < OpNum+FTy->getNumParams()) |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2402 | return Error("Invalid INVOKE record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2403 | |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2404 | SmallVector<Value*, 16> Ops; |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2405 | for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2406 | Ops.push_back(getValue(Record, OpNum, NextValueNo, |
| 2407 | FTy->getParamType(i))); |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2408 | if (Ops.back() == 0) return Error("Invalid INVOKE record"); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2409 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2410 | |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2411 | if (!FTy->isVarArg()) { |
| 2412 | if (Record.size() != OpNum) |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2413 | return Error("Invalid INVOKE record"); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2414 | } else { |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2415 | // Read type/value pairs for varargs params. |
| 2416 | while (OpNum != Record.size()) { |
| 2417 | Value *Op; |
| 2418 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
| 2419 | return Error("Invalid INVOKE record"); |
| 2420 | Ops.push_back(Op); |
| 2421 | } |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2422 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2423 | |
Jay Foad | a3efbb1 | 2011-07-15 08:37:34 +0000 | [diff] [blame] | 2424 | I = InvokeInst::Create(Callee, NormalBB, UnwindBB, Ops); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2425 | InstructionList.push_back(I); |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 2426 | cast<InvokeInst>(I)->setCallingConv( |
| 2427 | static_cast<CallingConv::ID>(CCInfo)); |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 2428 | cast<InvokeInst>(I)->setAttributes(PAL); |
Chris Lattner | f4c8e52 | 2007-05-02 05:46:45 +0000 | [diff] [blame] | 2429 | break; |
| 2430 | } |
Bill Wendling | dccc03b | 2011-07-31 06:30:59 +0000 | [diff] [blame] | 2431 | case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval] |
| 2432 | unsigned Idx = 0; |
| 2433 | Value *Val = 0; |
| 2434 | if (getValueTypePair(Record, Idx, NextValueNo, Val)) |
| 2435 | return Error("Invalid RESUME record"); |
| 2436 | I = ResumeInst::Create(Val); |
Bill Wendling | 35726bf | 2011-09-01 00:50:20 +0000 | [diff] [blame] | 2437 | InstructionList.push_back(I); |
Bill Wendling | dccc03b | 2011-07-31 06:30:59 +0000 | [diff] [blame] | 2438 | break; |
| 2439 | } |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 2440 | case bitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 2441 | I = new UnreachableInst(Context); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2442 | InstructionList.push_back(I); |
Chris Lattner | 231cbcb | 2007-05-02 04:27:25 +0000 | [diff] [blame] | 2443 | break; |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2444 | case bitc::FUNC_CODE_INST_PHI: { // PHI: [ty, val0,bb0, ...] |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2445 | if (Record.size() < 1 || ((Record.size()-1)&1)) |
Chris Lattner | 2a98cca | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 2446 | return Error("Invalid PHI record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2447 | Type *Ty = getTypeByID(Record[0]); |
Chris Lattner | 2a98cca | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 2448 | if (!Ty) return Error("Invalid PHI record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2449 | |
Jay Foad | 3ecfc86 | 2011-03-30 11:28:46 +0000 | [diff] [blame] | 2450 | PHINode *PN = PHINode::Create(Ty, (Record.size()-1)/2); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2451 | InstructionList.push_back(PN); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2452 | |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2453 | for (unsigned i = 0, e = Record.size()-1; i != e; i += 2) { |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2454 | Value *V; |
| 2455 | // With the new function encoding, it is possible that operands have |
| 2456 | // negative IDs (for forward references). Use a signed VBR |
| 2457 | // representation to keep the encoding small. |
| 2458 | if (UseRelativeIDs) |
| 2459 | V = getValueSigned(Record, 1+i, NextValueNo, Ty); |
| 2460 | else |
| 2461 | V = getValue(Record, 1+i, NextValueNo, Ty); |
Chris Lattner | 15e6d17 | 2007-05-04 19:11:41 +0000 | [diff] [blame] | 2462 | BasicBlock *BB = getBasicBlock(Record[2+i]); |
Chris Lattner | 2a98cca | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 2463 | if (!V || !BB) return Error("Invalid PHI record"); |
| 2464 | PN->addIncoming(V, BB); |
| 2465 | } |
| 2466 | I = PN; |
| 2467 | break; |
| 2468 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2469 | |
Bill Wendling | e6e8826 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 2470 | case bitc::FUNC_CODE_INST_LANDINGPAD: { |
| 2471 | // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?] |
| 2472 | unsigned Idx = 0; |
| 2473 | if (Record.size() < 4) |
| 2474 | return Error("Invalid LANDINGPAD record"); |
| 2475 | Type *Ty = getTypeByID(Record[Idx++]); |
| 2476 | if (!Ty) return Error("Invalid LANDINGPAD record"); |
| 2477 | Value *PersFn = 0; |
| 2478 | if (getValueTypePair(Record, Idx, NextValueNo, PersFn)) |
| 2479 | return Error("Invalid LANDINGPAD record"); |
| 2480 | |
| 2481 | bool IsCleanup = !!Record[Idx++]; |
| 2482 | unsigned NumClauses = Record[Idx++]; |
| 2483 | LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses); |
| 2484 | LP->setCleanup(IsCleanup); |
| 2485 | for (unsigned J = 0; J != NumClauses; ++J) { |
| 2486 | LandingPadInst::ClauseType CT = |
| 2487 | LandingPadInst::ClauseType(Record[Idx++]); (void)CT; |
| 2488 | Value *Val; |
| 2489 | |
| 2490 | if (getValueTypePair(Record, Idx, NextValueNo, Val)) { |
| 2491 | delete LP; |
| 2492 | return Error("Invalid LANDINGPAD record"); |
| 2493 | } |
| 2494 | |
| 2495 | assert((CT != LandingPadInst::Catch || |
| 2496 | !isa<ArrayType>(Val->getType())) && |
| 2497 | "Catch clause has a invalid type!"); |
| 2498 | assert((CT != LandingPadInst::Filter || |
| 2499 | isa<ArrayType>(Val->getType())) && |
| 2500 | "Filter clause has invalid type!"); |
| 2501 | LP->addClause(Val); |
| 2502 | } |
| 2503 | |
| 2504 | I = LP; |
Bill Wendling | 35726bf | 2011-09-01 00:50:20 +0000 | [diff] [blame] | 2505 | InstructionList.push_back(I); |
Bill Wendling | e6e8826 | 2011-08-12 20:24:12 +0000 | [diff] [blame] | 2506 | break; |
| 2507 | } |
| 2508 | |
Chris Lattner | 96a74c5 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 2509 | case bitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [instty, opty, op, align] |
| 2510 | if (Record.size() != 4) |
| 2511 | return Error("Invalid ALLOCA record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2512 | PointerType *Ty = |
Chris Lattner | 2a98cca | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 2513 | dyn_cast_or_null<PointerType>(getTypeByID(Record[0])); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2514 | Type *OpTy = getTypeByID(Record[1]); |
Chris Lattner | 96a74c5 | 2011-06-17 18:09:11 +0000 | [diff] [blame] | 2515 | Value *Size = getFnValueByID(Record[2], OpTy); |
| 2516 | unsigned Align = Record[3]; |
Chris Lattner | 2a98cca | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 2517 | if (!Ty || !Size) return Error("Invalid ALLOCA record"); |
Owen Anderson | 50dead0 | 2009-07-15 23:53:25 +0000 | [diff] [blame] | 2518 | I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2519 | InstructionList.push_back(I); |
Chris Lattner | 2a98cca | 2007-05-03 18:58:09 +0000 | [diff] [blame] | 2520 | break; |
| 2521 | } |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2522 | case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol] |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2523 | unsigned OpNum = 0; |
| 2524 | Value *Op; |
| 2525 | if (getValueTypePair(Record, OpNum, NextValueNo, Op) || |
| 2526 | OpNum+2 != Record.size()) |
Chris Lattner | abfbf85 | 2007-05-06 00:21:25 +0000 | [diff] [blame] | 2527 | return Error("Invalid LOAD record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2528 | |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2529 | I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2530 | InstructionList.push_back(I); |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2531 | break; |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2532 | } |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2533 | case bitc::FUNC_CODE_INST_LOADATOMIC: { |
| 2534 | // LOADATOMIC: [opty, op, align, vol, ordering, synchscope] |
| 2535 | unsigned OpNum = 0; |
| 2536 | Value *Op; |
| 2537 | if (getValueTypePair(Record, OpNum, NextValueNo, Op) || |
| 2538 | OpNum+4 != Record.size()) |
| 2539 | return Error("Invalid LOADATOMIC record"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2540 | |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2541 | |
| 2542 | AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); |
| 2543 | if (Ordering == NotAtomic || Ordering == Release || |
| 2544 | Ordering == AcquireRelease) |
| 2545 | return Error("Invalid LOADATOMIC record"); |
| 2546 | if (Ordering != NotAtomic && Record[OpNum] == 0) |
| 2547 | return Error("Invalid LOADATOMIC record"); |
| 2548 | SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); |
| 2549 | |
| 2550 | I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1, |
| 2551 | Ordering, SynchScope); |
| 2552 | InstructionList.push_back(I); |
| 2553 | break; |
| 2554 | } |
Chris Lattner | 4f6bab9 | 2011-06-17 18:17:37 +0000 | [diff] [blame] | 2555 | case bitc::FUNC_CODE_INST_STORE: { // STORE2:[ptrty, ptr, val, align, vol] |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 2556 | unsigned OpNum = 0; |
| 2557 | Value *Val, *Ptr; |
| 2558 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2559 | popValue(Record, OpNum, NextValueNo, |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 2560 | cast<PointerType>(Ptr->getType())->getElementType(), Val) || |
| 2561 | OpNum+2 != Record.size()) |
| 2562 | return Error("Invalid STORE record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2563 | |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 2564 | I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2565 | InstructionList.push_back(I); |
Christopher Lamb | fe63fb9 | 2007-12-11 08:59:05 +0000 | [diff] [blame] | 2566 | break; |
| 2567 | } |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2568 | case bitc::FUNC_CODE_INST_STOREATOMIC: { |
| 2569 | // STOREATOMIC: [ptrty, ptr, val, align, vol, ordering, synchscope] |
| 2570 | unsigned OpNum = 0; |
| 2571 | Value *Val, *Ptr; |
| 2572 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2573 | popValue(Record, OpNum, NextValueNo, |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2574 | cast<PointerType>(Ptr->getType())->getElementType(), Val) || |
| 2575 | OpNum+4 != Record.size()) |
| 2576 | return Error("Invalid STOREATOMIC record"); |
| 2577 | |
| 2578 | AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); |
Eli Friedman | c3d3598 | 2011-09-19 19:41:28 +0000 | [diff] [blame] | 2579 | if (Ordering == NotAtomic || Ordering == Acquire || |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2580 | Ordering == AcquireRelease) |
| 2581 | return Error("Invalid STOREATOMIC record"); |
| 2582 | SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); |
| 2583 | if (Ordering != NotAtomic && Record[OpNum] == 0) |
| 2584 | return Error("Invalid STOREATOMIC record"); |
| 2585 | |
| 2586 | I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1, |
| 2587 | Ordering, SynchScope); |
| 2588 | InstructionList.push_back(I); |
| 2589 | break; |
| 2590 | } |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 2591 | case bitc::FUNC_CODE_INST_CMPXCHG: { |
| 2592 | // CMPXCHG:[ptrty, ptr, cmp, new, vol, ordering, synchscope] |
| 2593 | unsigned OpNum = 0; |
| 2594 | Value *Ptr, *Cmp, *New; |
| 2595 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2596 | popValue(Record, OpNum, NextValueNo, |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 2597 | cast<PointerType>(Ptr->getType())->getElementType(), Cmp) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2598 | popValue(Record, OpNum, NextValueNo, |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 2599 | cast<PointerType>(Ptr->getType())->getElementType(), New) || |
| 2600 | OpNum+3 != Record.size()) |
| 2601 | return Error("Invalid CMPXCHG record"); |
| 2602 | AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]); |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2603 | if (Ordering == NotAtomic || Ordering == Unordered) |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 2604 | return Error("Invalid CMPXCHG record"); |
| 2605 | SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]); |
| 2606 | I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope); |
| 2607 | cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]); |
| 2608 | InstructionList.push_back(I); |
| 2609 | break; |
| 2610 | } |
| 2611 | case bitc::FUNC_CODE_INST_ATOMICRMW: { |
| 2612 | // ATOMICRMW:[ptrty, ptr, val, op, vol, ordering, synchscope] |
| 2613 | unsigned OpNum = 0; |
| 2614 | Value *Ptr, *Val; |
| 2615 | if (getValueTypePair(Record, OpNum, NextValueNo, Ptr) || |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2616 | popValue(Record, OpNum, NextValueNo, |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 2617 | cast<PointerType>(Ptr->getType())->getElementType(), Val) || |
| 2618 | OpNum+4 != Record.size()) |
| 2619 | return Error("Invalid ATOMICRMW record"); |
| 2620 | AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]); |
| 2621 | if (Operation < AtomicRMWInst::FIRST_BINOP || |
| 2622 | Operation > AtomicRMWInst::LAST_BINOP) |
| 2623 | return Error("Invalid ATOMICRMW record"); |
| 2624 | AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]); |
Eli Friedman | 21006d4 | 2011-08-09 23:02:53 +0000 | [diff] [blame] | 2625 | if (Ordering == NotAtomic || Ordering == Unordered) |
Eli Friedman | ff03048 | 2011-07-28 21:48:00 +0000 | [diff] [blame] | 2626 | return Error("Invalid ATOMICRMW record"); |
| 2627 | SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]); |
| 2628 | I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope); |
| 2629 | cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]); |
| 2630 | InstructionList.push_back(I); |
| 2631 | break; |
| 2632 | } |
Eli Friedman | 47f3513 | 2011-07-25 23:16:38 +0000 | [diff] [blame] | 2633 | case bitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope] |
| 2634 | if (2 != Record.size()) |
| 2635 | return Error("Invalid FENCE record"); |
| 2636 | AtomicOrdering Ordering = GetDecodedOrdering(Record[0]); |
| 2637 | if (Ordering == NotAtomic || Ordering == Unordered || |
| 2638 | Ordering == Monotonic) |
| 2639 | return Error("Invalid FENCE record"); |
| 2640 | SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]); |
| 2641 | I = new FenceInst(Context, Ordering, SynchScope); |
| 2642 | InstructionList.push_back(I); |
| 2643 | break; |
| 2644 | } |
Chris Lattner | 4f6bab9 | 2011-06-17 18:17:37 +0000 | [diff] [blame] | 2645 | case bitc::FUNC_CODE_INST_CALL: { |
Duncan Sands | dc02467 | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 2646 | // CALL: [paramattrs, cc, fnty, fnid, arg0, arg1...] |
| 2647 | if (Record.size() < 3) |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2648 | return Error("Invalid CALL record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2649 | |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 2650 | AttrListPtr PAL = getAttributes(Record[0]); |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 2651 | unsigned CCInfo = Record[1]; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2652 | |
Chris Lattner | a9bb713 | 2007-05-08 05:38:01 +0000 | [diff] [blame] | 2653 | unsigned OpNum = 2; |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2654 | Value *Callee; |
| 2655 | if (getValueTypePair(Record, OpNum, NextValueNo, Callee)) |
| 2656 | return Error("Invalid CALL record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2657 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2658 | PointerType *OpTy = dyn_cast<PointerType>(Callee->getType()); |
| 2659 | FunctionType *FTy = 0; |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2660 | if (OpTy) FTy = dyn_cast<FunctionType>(OpTy->getElementType()); |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2661 | if (!FTy || Record.size() < FTy->getNumParams()+OpNum) |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2662 | return Error("Invalid CALL record"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2663 | |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2664 | SmallVector<Value*, 16> Args; |
| 2665 | // Read the fixed params. |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2666 | for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i, ++OpNum) { |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 2667 | if (FTy->getParamType(i)->isLabelTy()) |
Dale Johannesen | eb57ea7 | 2007-11-05 21:20:28 +0000 | [diff] [blame] | 2668 | Args.push_back(getBasicBlock(Record[OpNum])); |
Dan Gohman | 9b10dfb | 2010-09-13 18:00:48 +0000 | [diff] [blame] | 2669 | else |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2670 | Args.push_back(getValue(Record, OpNum, NextValueNo, |
| 2671 | FTy->getParamType(i))); |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2672 | if (Args.back() == 0) return Error("Invalid CALL record"); |
| 2673 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2674 | |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2675 | // Read type/value pairs for varargs params. |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2676 | if (!FTy->isVarArg()) { |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2677 | if (OpNum != Record.size()) |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2678 | return Error("Invalid CALL record"); |
| 2679 | } else { |
Chris Lattner | 7337ab9 | 2007-05-06 00:00:00 +0000 | [diff] [blame] | 2680 | while (OpNum != Record.size()) { |
| 2681 | Value *Op; |
| 2682 | if (getValueTypePair(Record, OpNum, NextValueNo, Op)) |
| 2683 | return Error("Invalid CALL record"); |
| 2684 | Args.push_back(Op); |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2685 | } |
| 2686 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2687 | |
Jay Foad | a3efbb1 | 2011-07-15 08:37:34 +0000 | [diff] [blame] | 2688 | I = CallInst::Create(Callee, Args); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2689 | InstructionList.push_back(I); |
Sandeep Patel | 65c3c8f | 2009-09-02 08:44:58 +0000 | [diff] [blame] | 2690 | cast<CallInst>(I)->setCallingConv( |
| 2691 | static_cast<CallingConv::ID>(CCInfo>>1)); |
Chris Lattner | 7652019 | 2007-05-03 22:34:03 +0000 | [diff] [blame] | 2692 | cast<CallInst>(I)->setTailCall(CCInfo & 1); |
Devang Patel | 0598866 | 2008-09-25 21:00:45 +0000 | [diff] [blame] | 2693 | cast<CallInst>(I)->setAttributes(PAL); |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2694 | break; |
| 2695 | } |
| 2696 | case bitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty] |
| 2697 | if (Record.size() < 3) |
| 2698 | return Error("Invalid VAARG record"); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2699 | Type *OpTy = getTypeByID(Record[0]); |
Jan Wen Voung | d9a3bad | 2012-10-11 20:20:40 +0000 | [diff] [blame] | 2700 | Value *Op = getValue(Record, 1, NextValueNo, OpTy); |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 2701 | Type *ResTy = getTypeByID(Record[2]); |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2702 | if (!OpTy || !Op || !ResTy) |
| 2703 | return Error("Invalid VAARG record"); |
| 2704 | I = new VAArgInst(Op, ResTy); |
Devang Patel | e8e0213 | 2009-09-18 19:26:43 +0000 | [diff] [blame] | 2705 | InstructionList.push_back(I); |
Chris Lattner | 0579f7f | 2007-05-03 22:04:19 +0000 | [diff] [blame] | 2706 | break; |
| 2707 | } |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2708 | } |
| 2709 | |
| 2710 | // Add instruction to end of current BB. If there is no current BB, reject |
| 2711 | // this file. |
| 2712 | if (CurBB == 0) { |
| 2713 | delete I; |
| 2714 | return Error("Invalid instruction with no BB"); |
| 2715 | } |
| 2716 | CurBB->getInstList().push_back(I); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2717 | |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2718 | // If this was a terminator instruction, move to the next block. |
| 2719 | if (isa<TerminatorInst>(I)) { |
| 2720 | ++CurBBNo; |
| 2721 | CurBB = CurBBNo < FunctionBBs.size() ? FunctionBBs[CurBBNo] : 0; |
| 2722 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2723 | |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2724 | // Non-void values get registered in the value table for future use. |
Benjamin Kramer | f012705 | 2010-01-05 13:12:22 +0000 | [diff] [blame] | 2725 | if (I && !I->getType()->isVoidTy()) |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2726 | ValueList.AssignValue(I, NextValueNo++); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 2727 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2728 | |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2729 | // Check the function list for unresolved values. |
| 2730 | if (Argument *A = dyn_cast<Argument>(ValueList.back())) { |
| 2731 | if (A->getParent() == 0) { |
| 2732 | // We found at least one unresolved value. Nuke them all to avoid leaks. |
| 2733 | for (unsigned i = ModuleValueListSize, e = ValueList.size(); i != e; ++i){ |
Dan Gohman | 56e2a57 | 2010-08-25 20:20:21 +0000 | [diff] [blame] | 2734 | if ((A = dyn_cast<Argument>(ValueList[i])) && A->getParent() == 0) { |
Owen Anderson | 9e9a0d5 | 2009-07-30 23:03:37 +0000 | [diff] [blame] | 2735 | A->replaceAllUsesWith(UndefValue::get(A->getType())); |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2736 | delete A; |
| 2737 | } |
| 2738 | } |
Chris Lattner | 35a0470 | 2007-05-04 03:50:29 +0000 | [diff] [blame] | 2739 | return Error("Never resolved value found in function!"); |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2740 | } |
Chris Lattner | a7c49aa | 2007-05-01 07:01:57 +0000 | [diff] [blame] | 2741 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2742 | |
Dan Gohman | 064ff3e | 2010-08-25 20:23:38 +0000 | [diff] [blame] | 2743 | // FIXME: Check for unresolved forward-declared metadata references |
| 2744 | // and clean up leaks. |
| 2745 | |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2746 | // See if anything took the address of blocks in this function. If so, |
| 2747 | // resolve them now. |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2748 | DenseMap<Function*, std::vector<BlockAddrRefTy> >::iterator BAFRI = |
| 2749 | BlockAddrFwdRefs.find(F); |
| 2750 | if (BAFRI != BlockAddrFwdRefs.end()) { |
| 2751 | std::vector<BlockAddrRefTy> &RefList = BAFRI->second; |
| 2752 | for (unsigned i = 0, e = RefList.size(); i != e; ++i) { |
| 2753 | unsigned BlockIdx = RefList[i].first; |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 2754 | if (BlockIdx >= FunctionBBs.size()) |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2755 | return Error("Invalid blockaddress block #"); |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2756 | |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2757 | GlobalVariable *FwdRef = RefList[i].second; |
Chris Lattner | cdfc940 | 2009-11-01 01:27:45 +0000 | [diff] [blame] | 2758 | FwdRef->replaceAllUsesWith(BlockAddress::get(F, FunctionBBs[BlockIdx])); |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2759 | FwdRef->eraseFromParent(); |
| 2760 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2761 | |
Chris Lattner | 50b136d | 2009-10-28 05:53:48 +0000 | [diff] [blame] | 2762 | BlockAddrFwdRefs.erase(BAFRI); |
| 2763 | } |
Michael Ilseman | 407a616 | 2012-11-15 22:34:00 +0000 | [diff] [blame] | 2764 | |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 2765 | // Trim the value list down to the size it was before we parsed this function. |
| 2766 | ValueList.shrinkTo(ModuleValueListSize); |
Dan Gohman | 6981383 | 2010-08-25 20:22:53 +0000 | [diff] [blame] | 2767 | MDValueList.shrinkTo(ModuleMDValueListSize); |
Chris Lattner | 980e5aa | 2007-05-01 05:52:21 +0000 | [diff] [blame] | 2768 | std::vector<BasicBlock*>().swap(FunctionBBs); |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 2769 | return false; |
| 2770 | } |
| 2771 | |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 2772 | /// FindFunctionInStream - Find the function body in the bitcode stream |
| 2773 | bool BitcodeReader::FindFunctionInStream(Function *F, |
| 2774 | DenseMap<Function*, uint64_t>::iterator DeferredFunctionInfoIterator) { |
| 2775 | while (DeferredFunctionInfoIterator->second == 0) { |
| 2776 | if (Stream.AtEndOfStream()) |
| 2777 | return Error("Could not find Function in stream"); |
| 2778 | // ParseModule will parse the next body in the stream and set its |
| 2779 | // position in the DeferredFunctionInfo map. |
| 2780 | if (ParseModule(true)) return true; |
| 2781 | } |
| 2782 | return false; |
| 2783 | } |
| 2784 | |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2785 | //===----------------------------------------------------------------------===// |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2786 | // GVMaterializer implementation |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2787 | //===----------------------------------------------------------------------===// |
| 2788 | |
| 2789 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2790 | bool BitcodeReader::isMaterializable(const GlobalValue *GV) const { |
| 2791 | if (const Function *F = dyn_cast<Function>(GV)) { |
| 2792 | return F->isDeclaration() && |
| 2793 | DeferredFunctionInfo.count(const_cast<Function*>(F)); |
| 2794 | } |
| 2795 | return false; |
| 2796 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2797 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2798 | bool BitcodeReader::Materialize(GlobalValue *GV, std::string *ErrInfo) { |
| 2799 | Function *F = dyn_cast<Function>(GV); |
| 2800 | // If it's not a function or is already material, ignore the request. |
| 2801 | if (!F || !F->isMaterializable()) return false; |
| 2802 | |
| 2803 | DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F); |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2804 | assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!"); |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 2805 | // If its position is recorded as 0, its body is somewhere in the stream |
| 2806 | // but we haven't seen it yet. |
| 2807 | if (DFII->second == 0) |
| 2808 | if (LazyStreamer && FindFunctionInStream(F, DFII)) return true; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2809 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2810 | // Move the bit stream to the saved position of the deferred function body. |
| 2811 | Stream.JumpToBit(DFII->second); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2812 | |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2813 | if (ParseFunctionBody(F)) { |
| 2814 | if (ErrInfo) *ErrInfo = ErrorString; |
| 2815 | return true; |
| 2816 | } |
Chandler Carruth | 6994040 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 2817 | |
| 2818 | // Upgrade any old intrinsic calls in the function. |
| 2819 | for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(), |
| 2820 | E = UpgradedIntrinsics.end(); I != E; ++I) { |
| 2821 | if (I->first != I->second) { |
| 2822 | for (Value::use_iterator UI = I->first->use_begin(), |
| 2823 | UE = I->first->use_end(); UI != UE; ) { |
| 2824 | if (CallInst* CI = dyn_cast<CallInst>(*UI++)) |
| 2825 | UpgradeIntrinsicCall(CI, I->second); |
| 2826 | } |
| 2827 | } |
| 2828 | } |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2829 | |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2830 | return false; |
| 2831 | } |
| 2832 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2833 | bool BitcodeReader::isDematerializable(const GlobalValue *GV) const { |
| 2834 | const Function *F = dyn_cast<Function>(GV); |
| 2835 | if (!F || F->isDeclaration()) |
| 2836 | return false; |
| 2837 | return DeferredFunctionInfo.count(const_cast<Function*>(F)); |
| 2838 | } |
| 2839 | |
| 2840 | void BitcodeReader::Dematerialize(GlobalValue *GV) { |
| 2841 | Function *F = dyn_cast<Function>(GV); |
| 2842 | // If this function isn't dematerializable, this is a noop. |
| 2843 | if (!F || !isDematerializable(F)) |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2844 | return; |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2845 | |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2846 | assert(DeferredFunctionInfo.count(F) && "No info to read function later?"); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2847 | |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2848 | // Just forget the function body, we can remat it later. |
| 2849 | F->deleteBody(); |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2850 | } |
| 2851 | |
| 2852 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2853 | bool BitcodeReader::MaterializeModule(Module *M, std::string *ErrInfo) { |
| 2854 | assert(M == TheModule && |
| 2855 | "Can only Materialize the Module this BitcodeReader is attached to."); |
Chris Lattner | 714fa95 | 2009-06-16 05:15:21 +0000 | [diff] [blame] | 2856 | // Iterate over the module, deserializing any functions that are still on |
| 2857 | // disk. |
| 2858 | for (Module::iterator F = TheModule->begin(), E = TheModule->end(); |
| 2859 | F != E; ++F) |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2860 | if (F->isMaterializable() && |
| 2861 | Materialize(F, ErrInfo)) |
| 2862 | return true; |
Chandler Carruth | 6994040 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 2863 | |
Derek Schuff | 0ffe698 | 2012-02-29 00:07:09 +0000 | [diff] [blame] | 2864 | // At this point, if there are any function bodies, the current bit is |
| 2865 | // pointing to the END_BLOCK record after them. Now make sure the rest |
| 2866 | // of the bits in the module have been read. |
| 2867 | if (NextUnreadBit) |
| 2868 | ParseModule(true); |
| 2869 | |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2870 | // Upgrade any intrinsic calls that slipped through (should not happen!) and |
| 2871 | // delete the old functions to clean up. We can't do this unless the entire |
| 2872 | // module is materialized because there could always be another function body |
Chandler Carruth | 6994040 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 2873 | // with calls to the old function. |
| 2874 | for (std::vector<std::pair<Function*, Function*> >::iterator I = |
| 2875 | UpgradedIntrinsics.begin(), E = UpgradedIntrinsics.end(); I != E; ++I) { |
| 2876 | if (I->first != I->second) { |
| 2877 | for (Value::use_iterator UI = I->first->use_begin(), |
| 2878 | UE = I->first->use_end(); UI != UE; ) { |
| 2879 | if (CallInst* CI = dyn_cast<CallInst>(*UI++)) |
| 2880 | UpgradeIntrinsicCall(CI, I->second); |
| 2881 | } |
Chris Lattner | 7d9eb58 | 2009-04-01 01:43:03 +0000 | [diff] [blame] | 2882 | if (!I->first->use_empty()) |
| 2883 | I->first->replaceAllUsesWith(I->second); |
Chandler Carruth | 6994040 | 2007-08-04 01:51:18 +0000 | [diff] [blame] | 2884 | I->first->eraseFromParent(); |
| 2885 | } |
| 2886 | } |
| 2887 | std::vector<std::pair<Function*, Function*> >().swap(UpgradedIntrinsics); |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 2888 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2889 | return false; |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2890 | } |
| 2891 | |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 2892 | bool BitcodeReader::InitStream() { |
| 2893 | if (LazyStreamer) return InitLazyStream(); |
| 2894 | return InitStreamFromBuffer(); |
| 2895 | } |
| 2896 | |
| 2897 | bool BitcodeReader::InitStreamFromBuffer() { |
Roman Divacky | 5177b3a | 2012-09-06 15:42:13 +0000 | [diff] [blame] | 2898 | const unsigned char *BufPtr = (const unsigned char*)Buffer->getBufferStart(); |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 2899 | const unsigned char *BufEnd = BufPtr+Buffer->getBufferSize(); |
| 2900 | |
| 2901 | if (Buffer->getBufferSize() & 3) { |
| 2902 | if (!isRawBitcode(BufPtr, BufEnd) && !isBitcodeWrapper(BufPtr, BufEnd)) |
| 2903 | return Error("Invalid bitcode signature"); |
| 2904 | else |
| 2905 | return Error("Bitcode stream should be a multiple of 4 bytes in length"); |
| 2906 | } |
| 2907 | |
| 2908 | // If we have a wrapper header, parse it and ignore the non-bc file contents. |
| 2909 | // The magic number is 0x0B17C0DE stored in little endian. |
| 2910 | if (isBitcodeWrapper(BufPtr, BufEnd)) |
| 2911 | if (SkipBitcodeWrapperHeader(BufPtr, BufEnd, true)) |
| 2912 | return Error("Invalid bitcode wrapper header"); |
| 2913 | |
| 2914 | StreamFile.reset(new BitstreamReader(BufPtr, BufEnd)); |
| 2915 | Stream.init(*StreamFile); |
| 2916 | |
| 2917 | return false; |
| 2918 | } |
| 2919 | |
| 2920 | bool BitcodeReader::InitLazyStream() { |
| 2921 | // Check and strip off the bitcode wrapper; BitstreamReader expects never to |
| 2922 | // see it. |
| 2923 | StreamingMemoryObject *Bytes = new StreamingMemoryObject(LazyStreamer); |
| 2924 | StreamFile.reset(new BitstreamReader(Bytes)); |
| 2925 | Stream.init(*StreamFile); |
| 2926 | |
| 2927 | unsigned char buf[16]; |
| 2928 | if (Bytes->readBytes(0, 16, buf, NULL) == -1) |
| 2929 | return Error("Bitcode stream must be at least 16 bytes in length"); |
| 2930 | |
| 2931 | if (!isBitcode(buf, buf + 16)) |
| 2932 | return Error("Invalid bitcode signature"); |
| 2933 | |
| 2934 | if (isBitcodeWrapper(buf, buf + 4)) { |
| 2935 | const unsigned char *bitcodeStart = buf; |
| 2936 | const unsigned char *bitcodeEnd = buf + 16; |
| 2937 | SkipBitcodeWrapperHeader(bitcodeStart, bitcodeEnd, false); |
| 2938 | Bytes->dropLeadingBytes(bitcodeStart - buf); |
| 2939 | Bytes->setKnownObjectSize(bitcodeEnd - bitcodeStart); |
| 2940 | } |
| 2941 | return false; |
| 2942 | } |
Chris Lattner | 48f8487 | 2007-05-01 04:59:48 +0000 | [diff] [blame] | 2943 | |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 2944 | //===----------------------------------------------------------------------===// |
| 2945 | // External interface |
| 2946 | //===----------------------------------------------------------------------===// |
| 2947 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2948 | /// getLazyBitcodeModule - lazy function-at-a-time loading from a file. |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 2949 | /// |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2950 | Module *llvm::getLazyBitcodeModule(MemoryBuffer *Buffer, |
| 2951 | LLVMContext& Context, |
| 2952 | std::string *ErrMsg) { |
| 2953 | Module *M = new Module(Buffer->getBufferIdentifier(), Context); |
Owen Anderson | 8b477ed | 2009-07-01 16:58:40 +0000 | [diff] [blame] | 2954 | BitcodeReader *R = new BitcodeReader(Buffer, Context); |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2955 | M->setMaterializer(R); |
| 2956 | if (R->ParseBitcodeInto(M)) { |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 2957 | if (ErrMsg) |
| 2958 | *ErrMsg = R->getErrorString(); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2959 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2960 | delete M; // Also deletes R. |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 2961 | return 0; |
| 2962 | } |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2963 | // Have the BitcodeReader dtor delete 'Buffer'. |
| 2964 | R->setBufferOwned(true); |
Rafael Espindola | 47f79bb | 2012-01-02 07:49:53 +0000 | [diff] [blame] | 2965 | |
| 2966 | R->materializeForwardReferencedFunctions(); |
| 2967 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2968 | return M; |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 2969 | } |
| 2970 | |
Derek Schuff | 2ea9387 | 2012-02-06 22:30:29 +0000 | [diff] [blame] | 2971 | |
| 2972 | Module *llvm::getStreamedBitcodeModule(const std::string &name, |
| 2973 | DataStreamer *streamer, |
| 2974 | LLVMContext &Context, |
| 2975 | std::string *ErrMsg) { |
| 2976 | Module *M = new Module(name, Context); |
| 2977 | BitcodeReader *R = new BitcodeReader(streamer, Context); |
| 2978 | M->setMaterializer(R); |
| 2979 | if (R->ParseBitcodeInto(M)) { |
| 2980 | if (ErrMsg) |
| 2981 | *ErrMsg = R->getErrorString(); |
| 2982 | delete M; // Also deletes R. |
| 2983 | return 0; |
| 2984 | } |
| 2985 | R->setBufferOwned(false); // no buffer to delete |
| 2986 | return M; |
| 2987 | } |
| 2988 | |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 2989 | /// ParseBitcodeFile - Read the specified bitcode file, returning the module. |
| 2990 | /// If an error occurs, return null and fill in *ErrMsg if non-null. |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2991 | Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, LLVMContext& Context, |
Owen Anderson | 8b477ed | 2009-07-01 16:58:40 +0000 | [diff] [blame] | 2992 | std::string *ErrMsg){ |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2993 | Module *M = getLazyBitcodeModule(Buffer, Context, ErrMsg); |
| 2994 | if (!M) return 0; |
Chris Lattner | b348bb8 | 2007-05-18 04:02:46 +0000 | [diff] [blame] | 2995 | |
| 2996 | // Don't let the BitcodeReader dtor delete 'Buffer', regardless of whether |
| 2997 | // there was an error. |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 2998 | static_cast<BitcodeReader*>(M->getMaterializer())->setBufferOwned(false); |
Daniel Dunbar | a279bc3 | 2009-09-20 02:20:51 +0000 | [diff] [blame] | 2999 | |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 3000 | // Read in the entire module, and destroy the BitcodeReader. |
| 3001 | if (M->MaterializeAllPermanently(ErrMsg)) { |
| 3002 | delete M; |
Bill Wendling | 3471174 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3003 | return 0; |
Jeffrey Yasskin | f0356fe | 2010-01-27 20:34:15 +0000 | [diff] [blame] | 3004 | } |
Bill Wendling | 3471174 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3005 | |
Chad Rosier | cbbb096 | 2011-12-07 21:44:12 +0000 | [diff] [blame] | 3006 | // TODO: Restore the use-lists to the in-memory state when the bitcode was |
| 3007 | // written. We must defer until the Module has been fully materialized. |
| 3008 | |
Chris Lattner | c453f76 | 2007-04-29 07:54:31 +0000 | [diff] [blame] | 3009 | return M; |
| 3010 | } |
Bill Wendling | 3471174 | 2010-10-06 01:22:42 +0000 | [diff] [blame] | 3011 | |
| 3012 | std::string llvm::getBitcodeTargetTriple(MemoryBuffer *Buffer, |
| 3013 | LLVMContext& Context, |
| 3014 | std::string *ErrMsg) { |
| 3015 | BitcodeReader *R = new BitcodeReader(Buffer, Context); |
| 3016 | // Don't let the BitcodeReader dtor delete 'Buffer'. |
| 3017 | R->setBufferOwned(false); |
| 3018 | |
| 3019 | std::string Triple(""); |
| 3020 | if (R->ParseTriple(Triple)) |
| 3021 | if (ErrMsg) |
| 3022 | *ErrMsg = R->getErrorString(); |
| 3023 | |
| 3024 | delete R; |
| 3025 | return Triple; |
| 3026 | } |