2 files changed, 15 insertions, 474 deletions

diff --git a/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp b/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
index 91c3658db3..f36fc4b17c 100644
--- a/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
+++ b/lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp
@@ -134,44 +134,6 @@ static int GetDecodedBinaryOpcode(unsigned Val, Type *Ty) {
   }
 }
 
-static AtomicRMWInst::BinOp GetDecodedRMWOperation(unsigned Val) {
-  switch (Val) {
-  default: return AtomicRMWInst::BAD_BINOP;
-  case naclbitc::RMW_XCHG: return AtomicRMWInst::Xchg;
-  case naclbitc::RMW_ADD: return AtomicRMWInst::Add;
-  case naclbitc::RMW_SUB: return AtomicRMWInst::Sub;
-  case naclbitc::RMW_AND: return AtomicRMWInst::And;
-  case naclbitc::RMW_NAND: return AtomicRMWInst::Nand;
-  case naclbitc::RMW_OR: return AtomicRMWInst::Or;
-  case naclbitc::RMW_XOR: return AtomicRMWInst::Xor;
-  case naclbitc::RMW_MAX: return AtomicRMWInst::Max;
-  case naclbitc::RMW_MIN: return AtomicRMWInst::Min;
-  case naclbitc::RMW_UMAX: return AtomicRMWInst::UMax;
-  case naclbitc::RMW_UMIN: return AtomicRMWInst::UMin;
-  }
-}
-
-static AtomicOrdering GetDecodedOrdering(unsigned Val) {
-  switch (Val) {
-  case naclbitc::ORDERING_NOTATOMIC: return NotAtomic;
-  case naclbitc::ORDERING_UNORDERED: return Unordered;
-  case naclbitc::ORDERING_MONOTONIC: return Monotonic;
-  case naclbitc::ORDERING_ACQUIRE: return Acquire;
-  case naclbitc::ORDERING_RELEASE: return Release;
-  case naclbitc::ORDERING_ACQREL: return AcquireRelease;
-  default: // Map unknown orderings to sequentially-consistent.
-  case naclbitc::ORDERING_SEQCST: return SequentiallyConsistent;
-  }
-}
-
-static SynchronizationScope GetDecodedSynchScope(unsigned Val) {
-  switch (Val) {
-  case naclbitc::SYNCHSCOPE_SINGLETHREAD: return SingleThread;
-  default: // Map unknown scopes to cross-thread.
-  case naclbitc::SYNCHSCOPE_CROSSTHREAD: return CrossThread;
-  }
-}
-
 static CallingConv::ID GetDecodedCallingConv(unsigned Val) {
   switch (Val) {
   default:
@@ -1439,8 +1401,17 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
     Instruction *I = 0;
     unsigned BitCode = Stream.readRecord(Entry.ID, Record);
     switch (BitCode) {
-    default: // Default behavior: reject
-      return Error("Unknown instruction");
+    default: {// Default behavior: reject
+      std::string Message;
+      raw_string_ostream StrM(Message);
+      StrM << "Unknown instruction record: <" << BitCode;
+      for (unsigned I = 0, E = Record.size(); I != E; ++I) {
+        StrM << " " << Record[I];
+      }
+      StrM << ">";
+      return Error(StrM.str());
+    }
+
     case naclbitc::FUNC_CODE_DECLAREBLOCKS:     // DECLAREBLOCKS: [nblocks]
       if (Record.size() < 1 || Record[0] == 0)
         return Error("Invalid DECLAREBLOCKS record");
@@ -1511,69 +1482,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       I = CastInst::Create((Instruction::CastOps)Opc, Op, ResTy);
       break;
     }
-    case naclbitc::FUNC_CODE_INST_INBOUNDS_GEP:
-    case naclbitc::FUNC_CODE_INST_GEP: { // GEP: [n x operands]
-      unsigned OpNum = 0;
-      Value *BasePtr;
-      if (popValue(Record, &OpNum, NextValueNo, &BasePtr))
-        return Error("Invalid GEP record");
-
-      SmallVector<Value*, 16> GEPIdx;
-      while (OpNum != Record.size()) {
-        Value *Op;
-        if (popValue(Record, &OpNum, NextValueNo, &Op))
-          return Error("Invalid GEP record");
-        GEPIdx.push_back(Op);
-      }
-
-      I = GetElementPtrInst::Create(BasePtr, GEPIdx);
-      if (BitCode == naclbitc::FUNC_CODE_INST_INBOUNDS_GEP)
-        cast<GetElementPtrInst>(I)->setIsInBounds(true);
-      break;
-    }
-
-    case naclbitc::FUNC_CODE_INST_EXTRACTVAL: {
-                                       // EXTRACTVAL: [opval, n x indices]
-      unsigned OpNum = 0;
-      Value *Agg;
-      if (popValue(Record, &OpNum, NextValueNo, &Agg))
-        return Error("Invalid EXTRACTVAL record");
-
-      SmallVector<unsigned, 4> EXTRACTVALIdx;
-      for (unsigned RecSize = Record.size();
-           OpNum != RecSize; ++OpNum) {
-        uint64_t Index = Record[OpNum];
-        if ((unsigned)Index != Index)
-          return Error("Invalid EXTRACTVAL index");
-        EXTRACTVALIdx.push_back((unsigned)Index);
-      }
-
-      I = ExtractValueInst::Create(Agg, EXTRACTVALIdx);
-      break;
-    }
-
-    case naclbitc::FUNC_CODE_INST_INSERTVAL: {
-                           // INSERTVAL: [opval, opval, n x indices]
-      unsigned OpNum = 0;
-      Value *Agg;
-      if (popValue(Record, &OpNum, NextValueNo, &Agg))
-        return Error("Invalid INSERTVAL record");
-      Value *Val;
-      if (popValue(Record, &OpNum, NextValueNo, &Val))
-        return Error("Invalid INSERTVAL record");
-
-      SmallVector<unsigned, 4> INSERTVALIdx;
-      for (unsigned RecSize = Record.size();
-           OpNum != RecSize; ++OpNum) {
-        uint64_t Index = Record[OpNum];
-        if ((unsigned)Index != Index)
-          return Error("Invalid INSERTVAL index");
-        INSERTVALIdx.push_back((unsigned)Index);
-      }
-
-      I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);
-      break;
-    }
 
     case naclbitc::FUNC_CODE_INST_SELECT: { // SELECT: [opval, opval, opval]
       // obsolete form of select
@@ -1615,40 +1523,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
 
-    case naclbitc::FUNC_CODE_INST_EXTRACTELT: { // EXTRACTELT: [opval, opval]
-      unsigned OpNum = 0;
-      Value *Vec, *Idx;
-      if (popValue(Record, &OpNum, NextValueNo, &Vec) ||
-          popValue(Record, &OpNum, NextValueNo, &Idx))
-        return Error("Invalid EXTRACTELT record");
-      I = ExtractElementInst::Create(Vec, Idx);
-      break;
-    }
-
-    case naclbitc::FUNC_CODE_INST_INSERTELT: { // INSERTELT: [opval, opval, opval]
-      unsigned OpNum = 0;
-      Value *Vec, *Elt, *Idx;
-      if (popValue(Record, &OpNum, NextValueNo, &Vec) ||
-          popValue(Record, &OpNum, NextValueNo, &Elt) ||
-          popValue(Record, &OpNum, NextValueNo, &Idx))
-        return Error("Invalid INSERTELT record");
-      I = InsertElementInst::Create(Vec, Elt, Idx);
-      break;
-    }
-
-    case naclbitc::FUNC_CODE_INST_SHUFFLEVEC: {// SHUFFLEVEC: [opval, opval, opval]
-      unsigned OpNum = 0;
-      Value *Vec1, *Vec2, *Mask;
-      if (popValue(Record, &OpNum, NextValueNo, &Vec1) ||
-          popValue(Record, &OpNum, NextValueNo, &Vec2))
-        return Error("Invalid SHUFFLEVEC record");
-
-      if (popValue(Record, &OpNum, NextValueNo, &Mask))
-        return Error("Invalid SHUFFLEVEC record");
-      I = new ShuffleVectorInst(Vec1, Vec2, Mask);
-      break;
-    }
-
     case naclbitc::FUNC_CODE_INST_CMP:   // CMP: [opval, opval, pred]
       // Old form of ICmp/FCmp returning bool
       // Existed to differentiate between icmp/fcmp and vicmp/vfcmp which were
@@ -1759,38 +1633,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       I = SI;
       break;
     }
-    case naclbitc::FUNC_CODE_INST_INDIRECTBR: { // INDIRECTBR: [opty, op0, op1, ...]
-      if (Record.size() < 2)
-        return Error("Invalid INDIRECTBR record");
-      Type *OpTy = getTypeByID(Record[0]);
-      Value *Address = getValue(Record, 1, NextValueNo);
-      if (OpTy == 0 || Address == 0)
-        return Error("Invalid INDIRECTBR record");
-      unsigned NumDests = Record.size()-2;
-      IndirectBrInst *IBI = IndirectBrInst::Create(Address, NumDests);
-      for (unsigned i = 0, e = NumDests; i != e; ++i) {
-        if (BasicBlock *DestBB = getBasicBlock(Record[2+i])) {
-          IBI->addDestination(DestBB);
-        } else {
-          delete IBI;
-          return Error("Invalid INDIRECTBR record!");
-        }
-      }
-      I = IBI;
-      break;
-    }
-
-    case naclbitc::FUNC_CODE_INST_INVOKE:
-      return Error("Invoke is not allowed");
-      break;
-    case naclbitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
-      unsigned Idx = 0;
-      Value *Val = 0;
-      if (popValue(Record, &Idx, NextValueNo, &Val))
-        return Error("Invalid RESUME record");
-      I = ResumeInst::Create(Val);
-      break;
-    }
     case naclbitc::FUNC_CODE_INST_UNREACHABLE: // UNREACHABLE
       I = new UnreachableInst(Context);
       break;
@@ -1819,44 +1661,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       break;
     }
 
-    case naclbitc::FUNC_CODE_INST_LANDINGPAD: {
-      // LANDINGPAD: [ty, val, val, num, (id0,val0 ...)?]
-      unsigned Idx = 0;
-      if (Record.size() < 4)
-        return Error("Invalid LANDINGPAD record");
-      Type *Ty = getTypeByID(Record[Idx++]);
-      if (!Ty) return Error("Invalid LANDINGPAD record");
-      Value *PersFn = 0;
-      if (popValue(Record, &Idx, NextValueNo, &PersFn))
-        return Error("Invalid LANDINGPAD record");
-
-      bool IsCleanup = !!Record[Idx++];
-      unsigned NumClauses = Record[Idx++];
-      LandingPadInst *LP = LandingPadInst::Create(Ty, PersFn, NumClauses);
-      LP->setCleanup(IsCleanup);
-      for (unsigned J = 0; J != NumClauses; ++J) {
-        LandingPadInst::ClauseType CT =
-          LandingPadInst::ClauseType(Record[Idx++]); (void)CT;
-        Value *Val;
-
-        if (popValue(Record, &Idx, NextValueNo, &Val)) {
-          delete LP;
-          return Error("Invalid LANDINGPAD record");
-        }
-
-        assert((CT != LandingPadInst::Catch ||
-                !isa<ArrayType>(Val->getType())) &&
-               "Catch clause has a invalid type!");
-        assert((CT != LandingPadInst::Filter ||
-                isa<ArrayType>(Val->getType())) &&
-               "Filter clause has invalid type!");
-        LP->addClause(Val);
-      }
-
-      I = LP;
-      break;
-    }
-
     case naclbitc::FUNC_CODE_INST_ALLOCA: { // ALLOCA: [op, align]
       if (Record.size() != 2)
         return Error("Invalid ALLOCA record");
@@ -1878,27 +1682,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1);
       break;
     }
-    case naclbitc::FUNC_CODE_INST_LOADATOMIC: {
-       // LOADATOMIC: [op, align, vol, ordering, synchscope]
-      unsigned OpNum = 0;
-      Value *Op;
-      if (popValue(Record, &OpNum, NextValueNo, &Op) ||
-          OpNum+4 != Record.size())
-        return Error("Invalid LOADATOMIC record");
-
-
-      AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
-      if (Ordering == NotAtomic || Ordering == Release ||
-          Ordering == AcquireRelease)
-        return Error("Invalid LOADATOMIC record");
-      if (Ordering != NotAtomic && Record[OpNum] == 0)
-        return Error("Invalid LOADATOMIC record");
-      SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
-
-      I = new LoadInst(Op, "", Record[OpNum+1], (1 << Record[OpNum]) >> 1,
-                       Ordering, SynchScope);
-      break;
-    }
     case naclbitc::FUNC_CODE_INST_STORE: { // STORE2:[ptr, val, align, vol]
       unsigned OpNum = 0;
       Value *Val, *Ptr;
@@ -1910,75 +1693,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1);
       break;
     }
-    case naclbitc::FUNC_CODE_INST_STOREATOMIC: {
-      // STOREATOMIC: [ptr, val, align, vol, ordering, synchscope]
-      unsigned OpNum = 0;
-      Value *Val, *Ptr;
-      if (popValue(Record, &OpNum, NextValueNo, &Ptr) ||
-          popValue(Record, &OpNum, NextValueNo, &Val) ||
-          OpNum+4 != Record.size())
-        return Error("Invalid STOREATOMIC record");
-
-      AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
-      if (Ordering == NotAtomic || Ordering == Acquire ||
-          Ordering == AcquireRelease)
-        return Error("Invalid STOREATOMIC record");
-      SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
-      if (Ordering != NotAtomic && Record[OpNum] == 0)
-        return Error("Invalid STOREATOMIC record");
-
-      I = new StoreInst(Val, Ptr, Record[OpNum+1], (1 << Record[OpNum]) >> 1,
-                        Ordering, SynchScope);
-      break;
-    }
-    case naclbitc::FUNC_CODE_INST_CMPXCHG: {
-      // CMPXCHG:[ptr, cmp, new, vol, ordering, synchscope]
-      unsigned OpNum = 0;
-      Value *Ptr, *Cmp, *New;
-      if (popValue(Record, &OpNum, NextValueNo, &Ptr) ||
-          popValue(Record, &OpNum, NextValueNo, &Cmp) ||
-          popValue(Record, &OpNum, NextValueNo, &New) ||
-          OpNum+3 != Record.size())
-        return Error("Invalid CMPXCHG record");
-      AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+1]);
-      if (Ordering == NotAtomic || Ordering == Unordered)
-        return Error("Invalid CMPXCHG record");
-      SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+2]);
-      I = new AtomicCmpXchgInst(Ptr, Cmp, New, Ordering, SynchScope);
-      cast<AtomicCmpXchgInst>(I)->setVolatile(Record[OpNum]);
-      break;
-    }
-    case naclbitc::FUNC_CODE_INST_ATOMICRMW: {
-      // ATOMICRMW:[ptr, val, op, vol, ordering, synchscope]
-      unsigned OpNum = 0;
-      Value *Ptr, *Val;
-      if (popValue(Record, &OpNum, NextValueNo, &Ptr) ||
-          popValue(Record, &OpNum, NextValueNo, &Val) ||
-          OpNum+4 != Record.size())
-        return Error("Invalid ATOMICRMW record");
-      AtomicRMWInst::BinOp Operation = GetDecodedRMWOperation(Record[OpNum]);
-      if (Operation < AtomicRMWInst::FIRST_BINOP ||
-          Operation > AtomicRMWInst::LAST_BINOP)
-        return Error("Invalid ATOMICRMW record");
-      AtomicOrdering Ordering = GetDecodedOrdering(Record[OpNum+2]);
-      if (Ordering == NotAtomic || Ordering == Unordered)
-        return Error("Invalid ATOMICRMW record");
-      SynchronizationScope SynchScope = GetDecodedSynchScope(Record[OpNum+3]);
-      I = new AtomicRMWInst(Operation, Ptr, Val, Ordering, SynchScope);
-      cast<AtomicRMWInst>(I)->setVolatile(Record[OpNum+1]);
-      break;
-    }
-    case naclbitc::FUNC_CODE_INST_FENCE: { // FENCE:[ordering, synchscope]
-      if (2 != Record.size())
-        return Error("Invalid FENCE record");
-      AtomicOrdering Ordering = GetDecodedOrdering(Record[0]);
-      if (Ordering == NotAtomic || Ordering == Unordered ||
-          Ordering == Monotonic)
-        return Error("Invalid FENCE record");
-      SynchronizationScope SynchScope = GetDecodedSynchScope(Record[1]);
-      I = new FenceInst(Context, Ordering, SynchScope);
-      break;
-    }
     case naclbitc::FUNC_CODE_INST_CALL: {
       // CALL: [cc, fnid, arg0, arg1...]
       if (Record.size() < 2)
@@ -2025,17 +1739,6 @@ bool NaClBitcodeReader::ParseFunctionBody(Function *F) {
       cast<CallInst>(I)->setTailCall(CCInfo & 1);
       break;
     }
-    case naclbitc::FUNC_CODE_INST_VAARG: { // VAARG: [valistty, valist, instty]
-      if (Record.size() < 3)
-        return Error("Invalid VAARG record");
-      Type *OpTy = getTypeByID(Record[0]);
-      Value *Op = getValue(Record, 1, NextValueNo);
-      Type *ResTy = getTypeByID(Record[2]);
-      if (!OpTy || !Op || !ResTy)
-        return Error("Invalid VAARG record");
-      I = new VAArgInst(Op, ResTy);
-      break;
-    }
     case naclbitc::FUNC_CODE_INST_FORWARDTYPEREF:
       // Build corresponding forward reference.
       if (Record.size() != 2 ||
diff --git a/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp b/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp
index 1c2fb2986e..afc8d83451 100644
--- a/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp
+++ b/lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp
@@ -160,44 +160,6 @@ static unsigned GetEncodedBinaryOpcode(unsigned Opcode, const Value &V) {
   }
 }
 
-static unsigned GetEncodedRMWOperation(AtomicRMWInst::BinOp Op) {
-  switch (Op) {
-  default: report_fatal_error("Unknown RMW operation!");
-  case AtomicRMWInst::Xchg: return naclbitc::RMW_XCHG;
-  case AtomicRMWInst::Add: return naclbitc::RMW_ADD;
-  case AtomicRMWInst::Sub: return naclbitc::RMW_SUB;
-  case AtomicRMWInst::And: return naclbitc::RMW_AND;
-  case AtomicRMWInst::Nand: return naclbitc::RMW_NAND;
-  case AtomicRMWInst::Or: return naclbitc::RMW_OR;
-  case AtomicRMWInst::Xor: return naclbitc::RMW_XOR;
-  case AtomicRMWInst::Max: return naclbitc::RMW_MAX;
-  case AtomicRMWInst::Min: return naclbitc::RMW_MIN;
-  case AtomicRMWInst::UMax: return naclbitc::RMW_UMAX;
-  case AtomicRMWInst::UMin: return naclbitc::RMW_UMIN;
-  }
-}
-
-static unsigned GetEncodedOrdering(AtomicOrdering Ordering) {
-  switch (Ordering) {
-  default: report_fatal_error("Invalid ordering");
-  case NotAtomic: return naclbitc::ORDERING_NOTATOMIC;
-  case Unordered: return naclbitc::ORDERING_UNORDERED;
-  case Monotonic: return naclbitc::ORDERING_MONOTONIC;
-  case Acquire: return naclbitc::ORDERING_ACQUIRE;
-  case Release: return naclbitc::ORDERING_RELEASE;
-  case AcquireRelease: return naclbitc::ORDERING_ACQREL;
-  case SequentiallyConsistent: return naclbitc::ORDERING_SEQCST;
-  }
-}
-
-static unsigned GetEncodedSynchScope(SynchronizationScope SynchScope) {
-  switch (SynchScope) {
-  default: report_fatal_error("Invalid synch scope");
-  case SingleThread: return naclbitc::SYNCHSCOPE_SINGLETHREAD;
-  case CrossThread: return naclbitc::SYNCHSCOPE_CROSSTHREAD;
-  }
-}
-
 static unsigned GetEncodedCallingConv(CallingConv::ID conv) {
   switch (conv) {
   default: report_fatal_error(
@@ -912,54 +874,12 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
       ReportIllegalValue("instruction", I);
     }
     break;
-
-  case Instruction::GetElementPtr:
-    Code = naclbitc::FUNC_CODE_INST_GEP;
-    if (cast<GEPOperator>(&I)->isInBounds())
-      Code = naclbitc::FUNC_CODE_INST_INBOUNDS_GEP;
-    for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
-      pushValue(I.getOperand(i), InstID, Vals, VE, Stream);
-    break;
-  case Instruction::ExtractValue: {
-    Code = naclbitc::FUNC_CODE_INST_EXTRACTVAL;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    const ExtractValueInst *EVI = cast<ExtractValueInst>(&I);
-    for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
-      Vals.push_back(*i);
-    break;
-  }
-  case Instruction::InsertValue: {
-    Code = naclbitc::FUNC_CODE_INST_INSERTVAL;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    pushValue(I.getOperand(1), InstID, Vals, VE, Stream);
-    const InsertValueInst *IVI = cast<InsertValueInst>(&I);
-    for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
-      Vals.push_back(*i);
-    break;
-  }
   case Instruction::Select:
     Code = naclbitc::FUNC_CODE_INST_VSELECT;
     pushValue(I.getOperand(1), InstID, Vals, VE, Stream);
     pushValue(I.getOperand(2), InstID, Vals, VE, Stream);
     pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
     break;
-  case Instruction::ExtractElement:
-    Code = naclbitc::FUNC_CODE_INST_EXTRACTELT;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    pushValue(I.getOperand(1), InstID, Vals, VE, Stream);
-    break;
-  case Instruction::InsertElement:
-    Code = naclbitc::FUNC_CODE_INST_INSERTELT;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    pushValue(I.getOperand(1), InstID, Vals, VE, Stream);
-    pushValue(I.getOperand(2), InstID, Vals, VE, Stream);
-    break;
-  case Instruction::ShuffleVector:
-    Code = naclbitc::FUNC_CODE_INST_SHUFFLEVEC;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    pushValue(I.getOperand(1), InstID, Vals, VE, Stream);
-    pushValue(I.getOperand(2), InstID, Vals, VE, Stream);
-    break;
   case Instruction::ICmp:
   case Instruction::FCmp:
     // compare returning Int1Ty or vector of Int1Ty
@@ -1053,22 +973,6 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
       return;
     }
     break;
-  case Instruction::IndirectBr:
-    Code = naclbitc::FUNC_CODE_INST_INDIRECTBR;
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));
-    // Encode the address operand as relative, but not the basic blocks.
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    for (unsigned i = 1, e = I.getNumOperands(); i != e; ++i)
-      Vals.push_back(VE.getValueID(I.getOperand(i)));
-    break;
-
-  case Instruction::Invoke:
-    report_fatal_error("Invoke is not allowed in PNaCl bitcode");
-    break;
-  case Instruction::Resume:
-    Code = naclbitc::FUNC_CODE_INST_RESUME;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    break;
   case Instruction::Unreachable:
     Code = naclbitc::FUNC_CODE_INST_UNREACHABLE;
     AbbrevToUse = FUNCTION_INST_UNREACHABLE_ABBREV;
@@ -1092,23 +996,6 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     return;
   }
 
-  case Instruction::LandingPad: {
-    const LandingPadInst &LP = cast<LandingPadInst>(I);
-    Code = naclbitc::FUNC_CODE_INST_LANDINGPAD;
-    Vals.push_back(VE.getTypeID(LP.getType()));
-    pushValue(LP.getPersonalityFn(), InstID, Vals, VE, Stream);
-    Vals.push_back(LP.isCleanup());
-    Vals.push_back(LP.getNumClauses());
-    for (unsigned I = 0, E = LP.getNumClauses(); I != E; ++I) {
-      if (LP.isCatch(I))
-        Vals.push_back(LandingPadInst::Catch);
-      else
-        Vals.push_back(LandingPadInst::Filter);
-      pushValue(LP.getClause(I), InstID, Vals, VE, Stream);
-    }
-    break;
-  }
-
   case Instruction::Alloca:
     if (!cast<AllocaInst>(&I)->getAllocatedType()->isIntegerTy(8))
       report_fatal_error("Type of alloca instruction is not i8");
@@ -1118,61 +1005,18 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     break;
 
   case Instruction::Load:
-    if (cast<LoadInst>(I).isAtomic()) {
-      Code = naclbitc::FUNC_CODE_INST_LOADATOMIC;
-      pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
-    } else {
-      Code = naclbitc::FUNC_CODE_INST_LOAD;
-      pushValue(I.getOperand(0), InstID, Vals, VE, Stream);  // ptr
-      AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
-    }
+    Code = naclbitc::FUNC_CODE_INST_LOAD;
+    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);  // ptr
+    AbbrevToUse = FUNCTION_INST_LOAD_ABBREV;
     Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);
     Vals.push_back(cast<LoadInst>(I).isVolatile());
-    if (cast<LoadInst>(I).isAtomic()) {
-      Vals.push_back(GetEncodedOrdering(cast<LoadInst>(I).getOrdering()));
-      Vals.push_back(GetEncodedSynchScope(cast<LoadInst>(I).getSynchScope()));
-    }
     break;
   case Instruction::Store:
-    if (cast<StoreInst>(I).isAtomic())
-      Code = naclbitc::FUNC_CODE_INST_STOREATOMIC;
-    else
-      Code = naclbitc::FUNC_CODE_INST_STORE;
+    Code = naclbitc::FUNC_CODE_INST_STORE;
     pushValue(I.getOperand(1), InstID, Vals, VE, Stream);  // ptrty + ptr
     pushValue(I.getOperand(0), InstID, Vals, VE, Stream);  // val.
     Vals.push_back(Log2_32(cast<StoreInst>(I).getAlignment())+1);
     Vals.push_back(cast<StoreInst>(I).isVolatile());
-    if (cast<StoreInst>(I).isAtomic()) {
-      Vals.push_back(GetEncodedOrdering(cast<StoreInst>(I).getOrdering()));
-      Vals.push_back(GetEncodedSynchScope(cast<StoreInst>(I).getSynchScope()));
-    }
-    break;
-  case Instruction::AtomicCmpXchg:
-    Code = naclbitc::FUNC_CODE_INST_CMPXCHG;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);  // ptrty + ptr
-    pushValue(I.getOperand(1), InstID, Vals, VE, Stream);  // cmp.
-    pushValue(I.getOperand(2), InstID, Vals, VE, Stream);  // newval.
-    Vals.push_back(cast<AtomicCmpXchgInst>(I).isVolatile());
-    Vals.push_back(GetEncodedOrdering(
-                     cast<AtomicCmpXchgInst>(I).getOrdering()));
-    Vals.push_back(GetEncodedSynchScope(
-                     cast<AtomicCmpXchgInst>(I).getSynchScope()));
-    break;
-  case Instruction::AtomicRMW:
-    Code = naclbitc::FUNC_CODE_INST_ATOMICRMW;
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream);  // ptrty + ptr
-    pushValue(I.getOperand(1), InstID, Vals, VE, Stream);  // val.
-    Vals.push_back(GetEncodedRMWOperation(
-                     cast<AtomicRMWInst>(I).getOperation()));
-    Vals.push_back(cast<AtomicRMWInst>(I).isVolatile());
-    Vals.push_back(GetEncodedOrdering(cast<AtomicRMWInst>(I).getOrdering()));
-    Vals.push_back(GetEncodedSynchScope(
-                     cast<AtomicRMWInst>(I).getSynchScope()));
-    break;
-  case Instruction::Fence:
-    Code = naclbitc::FUNC_CODE_INST_FENCE;
-    Vals.push_back(GetEncodedOrdering(cast<FenceInst>(I).getOrdering()));
-    Vals.push_back(GetEncodedSynchScope(cast<FenceInst>(I).getSynchScope()));
     break;
   case Instruction::Call: {
     const CallInst &CI = cast<CallInst>(I);
@@ -1204,12 +1048,6 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
     }
     break;
   }
-  case Instruction::VAArg:
-    Code = naclbitc::FUNC_CODE_INST_VAARG;
-    Vals.push_back(VE.getTypeID(I.getOperand(0)->getType()));   // valistty
-    pushValue(I.getOperand(0), InstID, Vals, VE, Stream); // valist.
-    Vals.push_back(VE.getTypeID(I.getType())); // restype.
-    break;
   }
 
   Stream.EmitRecord(Code, Vals, AbbrevToUse);