PNaCl: Add support for GCC/LLVM vector extensions

lib/Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp

 //===--- Bitcode/NaCl/Writer/NaClBitcodeWriter.cpp - Bitcode Writer -------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer implementation.
@@ skipping 267 matching lines @@
     switch (T->getTypeID()) {
     default: llvm_unreachable("Unknown type!");
     case Type::VoidTyID:      Code = naclbitc::TYPE_CODE_VOID;      break;
     case Type::FloatTyID:     Code = naclbitc::TYPE_CODE_FLOAT;     break;
     case Type::DoubleTyID:    Code = naclbitc::TYPE_CODE_DOUBLE;    break;
     case Type::IntegerTyID:
       // INTEGER: [width]
       Code = naclbitc::TYPE_CODE_INTEGER;
       TypeVals.push_back(cast<IntegerType>(T)->getBitWidth());
       break;
+    case Type::VectorTyID: {

[Mark Seaborn, 2014/04/09 15:03:03]

Can you add a reader/writer vector test to test/NaCl/Bitcode/, please?

[JF, 2014/04/15 20:22:36]

Done, see test/NaCl/Bitcode/vector.ll

+      VectorType *VT = cast<VectorType>(T);
+      // VECTOR [numelts, eltty]
+      Code = naclbitc::TYPE_CODE_VECTOR;
+      TypeVals.push_back(VT->getNumElements());
+      TypeVals.push_back(VE.getTypeID(VT->getElementType()));
+      break;
+    }
     case Type::FunctionTyID: {
       FunctionType *FT = cast<FunctionType>(T);
       // FUNCTION: [isvararg, retty, paramty x N]
       Code = naclbitc::TYPE_CODE_FUNCTION;
       TypeVals.push_back(FT->isVarArg());
       TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
       for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
         TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
       AbbrevToUse = TYPE_FUNCTION_ABBREV;
       break;
     }
     case Type::StructTyID:
       report_fatal_error("Struct types are not supported in PNaCl bitcode");
     case Type::ArrayTyID:
       report_fatal_error("Array types are not supported in PNaCl bitcode");
-    case Type::VectorTyID:
-      report_fatal_error("Vector types are not supported in PNaCl bitcode");
     }
 
     // Emit the finished record.
     Stream.EmitRecord(Code, TypeVals, AbbrevToUse);
     TypeVals.clear();
   }
 
   Stream.ExitBlock();
   DEBUG(dbgs() << "<- WriteTypeTable\n");
 }
@@ skipping 323 matching lines @@
     } else {
       ReportIllegalValue("instruction", 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::ICmp:
   case Instruction::FCmp:
     // compare returning Int1Ty or vector of Int1Ty
     Code = naclbitc::FUNC_CODE_INST_CMP2;
     pushValue(I.getOperand(0), InstID, Vals, VE, Stream);
     pushValue(I.getOperand(1), InstID, Vals, VE, Stream);
     Vals.push_back(GetEncodedCmpPredicate(cast<CmpInst>(I)));
     break;
 
   case Instruction::Ret:
@@ skipping 568 matching lines @@
       NaClWriteHeader(Header, Stream);
     }
 
     // Emit the module.
     WriteModule(M, Stream);
   }
 
   // Write the generated bitstream to "Out".
   Out.write((char*)&Buffer.front(), Buffer.size());
 }