PNaCl: Add support for GCC/LLVM vector extensions

lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp

 //===- NaClBitcodeReader.cpp ----------------------------------------------===//
 //     Internal NaClBitcodeReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 351 matching lines @@
           break;
       }
 
       ResultTy = getTypeByID(Record[1]);
       if (ResultTy == 0 || ArgTys.size() < Record.size()-2)
         return Error("invalid type in function type");
 
       ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
       break;
     }
+    case naclbitc::TYPE_CODE_VECTOR: { // VECTOR: [numelts, eltty]
+      if (Record.size() != 2)
+        return Error("Invalid VECTOR type record");
+      if ((ResultTy = getTypeByID(Record[1])))
+        ResultTy = VectorType::get(ResultTy, Record[0]);
+      else
+        return Error("invalid type in vector type");
+      break;
+    }
     }
 
     if (NumRecords >= TypeList.size())
       return Error("invalid TYPE table");
     assert(ResultTy && "Didn't read a type?");
     assert(TypeList[NumRecords] == 0 && "Already read type?");
     TypeList[NumRecords++] = ResultTy;
   }
 }
 
@@ skipping 769 matching lines @@
       FalseVal = ConvertOpToScalar(FalseVal, CurBBNo);
 
       // expect i1
       if (Cond->getType() != Type::getInt1Ty(Context))
         return Error("Invalid SELECT condition type");
 
       I = SelectInst::Create(Cond, TrueVal, FalseVal);
       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) || OpNum != Record.size())
+        return Error("Invalid EXTRACTELEMENT record");
+
+      // expect i32
+      if (Idx->getType() != Type::getInt32Ty(Context))
+        return Error("Invalid EXTRACTELEMENT index type");
+
+      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) || OpNum != Record.size())
+        return Error("Invalid INSERTELEMENT record");
+
+      // expect vector type
+      if (!isa<VectorType>(Vec->getType()))
+        return Error("Invalid INSERTELEMENT vector type");
+      // match vector and element types
+      if (cast<VectorType>(Vec->getType())->getElementType() != Elt->getType())
+        return Error("Mismatched INSERTELEMENT vector and element type");
+      // expect i32
+      if (Idx->getType() != Type::getInt32Ty(Context))
+        return Error("Invalid INSERTELEMENT index type");
+
+      I = InsertElementInst::Create(Vec, Elt, Idx);
+      break;
+    }
+
     case naclbitc::FUNC_CODE_INST_CMP2: { // CMP2: [opval, opval, pred]
       // FCmp/ICmp returning bool or vector of bool
 
       unsigned OpNum = 0;
       Value *LHS, *RHS;
       if (popValue(Record, &OpNum, NextValueNo, &LHS) ||
           popValue(Record, &OpNum, NextValueNo, &RHS) ||
           OpNum+1 != Record.size())
         return Error("Invalid CMP record");
 
@@ skipping 525 matching lines @@
   if (M->MaterializeAllPermanently(ErrMsg)) {
     delete M;
     return 0;
   }
 
   // TODO: Restore the use-lists to the in-memory state when the bitcode was
   // written.  We must defer until the Module has been fully materialized.
 
   return M;
 }