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