Add vector insert/extract instructions to Subzero bitcode reader.

src/PNaClTranslator.cpp

 //===- subzero/src/PNaClTranslator.cpp - ICE from bitcode -----------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the PNaCl bitcode file to Ice, to machine code
@@ skipping 891 matching lines @@
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Value index " << Index << " out of range. Must be less than "
              << (LocalOperands.size() + CachedNumGlobalValueIDs);
       Error(StrBuf.str());
       report_fatal_error("Unable to continue");
     }
     return LocalOperands[LocalIndex];
   }
 
+  // Returns the relative operand (wrt to next instruction) referenced by
+  // the given value index.
+  Ice::Operand *getRelativeOperand(uint32_t Index) {
+    return getOperand(convertRelativeToAbsIndex(Index));
+  }
+
   // Generates type error message for binary operator Op
   // operating on Type OpTy.
   void ReportInvalidBinaryOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy);
 
   // Validates if integer logical Op, for type OpTy, is valid.
   // Returns true if valid. Otherwise generates error message and
   // returns false.
   bool isValidIntegerLogicalOp(Ice::InstArithmetic::OpKind Op, Ice::Type OpTy) {
     if (Ice::isIntegerType(OpTy))
       return true;
@@ skipping 214 matching lines @@
     // Install the basic blocks, skipping bb0 which was created in the
     // constructor.
     for (size_t i = 1; i < NumBbs; ++i)
       InstallNextBasicBlock();
     break;
   }
   case naclbitc::FUNC_CODE_INST_BINOP: {
     // BINOP: [opval, opval, opcode]
     if (!isValidRecordSize(3, "function block binop"))
       return;
-    Ice::Operand *Op1 = getOperand(convertRelativeToAbsIndex(Values[0]));
-    Ice::Operand *Op2 = getOperand(convertRelativeToAbsIndex(Values[1]));
+    Ice::Operand *Op1 = getRelativeOperand(Values[0]);
+    Ice::Operand *Op2 = getRelativeOperand(Values[1]);
     Ice::Type Type1 = Op1->getType();
     Ice::Type Type2 = Op2->getType();
     if (Type1 != Type2) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binop argument types differ: " << Type1 << " and " << Type2;
       Error(StrBuf.str());
       // TODO(kschimpf) Remove error recovery once implementation complete.
       Op2 = Op1;
     }
 
     Ice::InstArithmetic::OpKind Opcode;
     if (!convertBinopOpcode(Values[2], Type1, Opcode))
       return;
     Ice::Variable *Dest = NextInstVar(Type1);
     Inst = Ice::InstArithmetic::create(Func, Opcode, Dest, Op1, Op2);
     break;
   }
   case naclbitc::FUNC_CODE_INST_CAST: {
     // CAST: [opval, destty, castopc]
     if (!isValidRecordSize(3, "function block cast"))
       return;
-    Ice::Operand *Src = getOperand(convertRelativeToAbsIndex(Values[0]));
+    Ice::Operand *Src = getRelativeOperand(Values[0]);
     Type *CastType = Context->getTypeByID(Values[1]);
     Instruction::CastOps LLVMCastOp;
     Ice::InstCast::OpKind CastKind;
     if (!naclbitc::DecodeCastOpcode(Values[2], LLVMCastOp) ||
         !convertLLVMCastOpToIceOp(LLVMCastOp, CastKind)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Cast opcode not understood: " << Values[2];
       Error(StrBuf.str());
       return;
     }
     Type *SrcType = Context->convertToLLVMType(Src->getType());
     if (!CastInst::castIsValid(LLVMCastOp, SrcType, CastType)) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Illegal cast: " << Instruction::getOpcodeName(LLVMCastOp)
              << " " << *SrcType << " to " << *CastType;
       Error(StrBuf.str());
       return;
     }
     Ice::Variable *Dest = NextInstVar(Context->convertToIceType(CastType));
     Inst = Ice::InstCast::create(Func, CastKind, Dest, Src);
     break;
   }
+  case naclbitc::FUNC_CODE_INST_EXTRACTELT: {
+    // EXTRACTELT: [opval, opval]
+    Ice::Operand *Vec = getRelativeOperand(Values[0]);
+    Ice::Type VecType = Vec->getType();
+    if (!Ice::isVectorType(VecType)) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Extractelement not on vector. Found: " << Vec;
+      Error(StrBuf.str());
+    }
+    Ice::Operand *Index = getRelativeOperand(Values[1]);
+    if (Index->getType() != Ice::IceType_i32) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Extractelement index not i32. Found: " << Index;
+      Error(StrBuf.str());
+    }
+    // TODO(kschimpf): Restrict index to a legal constant index (once
+    // constants can be defined).
+    Ice::Variable *Dest = NextInstVar(typeElementType(VecType));
+    Inst = Ice::InstExtractElement::create(Func, Dest, Vec, Index);
+    break;
+  }
+  case naclbitc::FUNC_CODE_INST_INSERTELT: {
+    // INSERTELT: [opval, opval, opval]
+    Ice::Operand *Vec = getRelativeOperand(Values[0]);
+    Ice::Type VecType = Vec->getType();
+    if (!Ice::isVectorType(VecType)) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Insertelement not on vector. Found: " << Vec;
+      Error(StrBuf.str());
+    }
+    Ice::Operand *Elt = getRelativeOperand(Values[1]);
+    Ice::Type EltType = Elt->getType();
+    if (EltType != typeElementType(VecType)) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Insertelement element not " << typeElementType(VecType)
+             << ". Found: " << Elt;
+      Error(StrBuf.str());
+    }
+    Ice::Operand *Index = getRelativeOperand(Values[2]);
+    if (Index->getType() != Ice::IceType_i32) {
+      std::string Buffer;
+      raw_string_ostream StrBuf(Buffer);
+      StrBuf << "Insertelement index not i32. Found: " << Index;
+      Error(StrBuf.str());
+    }
+    // TODO(kschimpf): Restrict index to a legal constant index (once
+    // constants can be defined).
+    Ice::Variable *Dest = NextInstVar(EltType);
+    Inst = Ice::InstInsertElement::create(Func, Dest, Vec, Elt, Index);
+    break;
+  }
   case naclbitc::FUNC_CODE_INST_RET: {
     // RET: [opval?]
     InstIsTerminating = true;
     if (!isValidRecordSizeInRange(0, 1, "function block ret"))
       return;
     if (Values.size() == 0) {
       Inst = Ice::InstRet::create(Func);
     } else {
-      Inst = Ice::InstRet::create(
-          Func, getOperand(convertRelativeToAbsIndex(Values[0])));
+      Inst = Ice::InstRet::create(Func, getRelativeOperand(Values[0]));
     }
     break;
   }
   default:
     // Generate error message!
     BlockParserBaseClass::ProcessRecord();
     break;
   }
   if (Inst)
     CurrentNode->appendInst(Inst);
@@ skipping 157 matching lines @@
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus = true;
   }
   return;
 }
 
 } // end of namespace Ice