Lower insertelement and extractelement.

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        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 LLVM to ICE converter.
@@ skipping 319 matching lines @@
     case Instruction::FDiv:
       return convertArithInstruction(Inst, Ice::InstArithmetic::Fdiv);
     case Instruction::FRem:
       return convertArithInstruction(Inst, Ice::InstArithmetic::Frem);
     case Instruction::And:
       return convertArithInstruction(Inst, Ice::InstArithmetic::And);
     case Instruction::Or:
       return convertArithInstruction(Inst, Ice::InstArithmetic::Or);
     case Instruction::Xor:
       return convertArithInstruction(Inst, Ice::InstArithmetic::Xor);
+    case Instruction::ExtractElement:
+      return convertExtractElementInstruction(cast<ExtractElementInst>(Inst));
+    case Instruction::InsertElement:
+      return convertInsertElementInstruction(cast<InsertElementInst>(Inst));
     case Instruction::Call:
       return convertCallInstruction(cast<CallInst>(Inst));
     case Instruction::Alloca:
       return convertAllocaInstruction(cast<AllocaInst>(Inst));
     case Instruction::Unreachable:
       return convertUnreachableInstruction(cast<UnreachableInst>(Inst));
     default:
       report_fatal_error(std::string("Invalid PNaCl instruction: ") +
                          LLVMObjectAsString(Inst));
     }
@@ skipping 177 matching lines @@
       Cond = Ice::InstFcmp::Uno;
       break;
     case CmpInst::FCMP_TRUE:
       Cond = Ice::InstFcmp::True;
       break;
     }
 
     return Ice::InstFcmp::create(Func, Cond, Dest, Src0, Src1);
   }
 
+  Ice::Inst *convertExtractElementInstruction(const ExtractElementInst *Inst) {
+    Ice::Variable *Dest = mapValueToIceVar(Inst);
+    Ice::Operand *Source1 = convertValue(Inst->getOperand(0));
+    Ice::Operand *Source2 = convertValue(Inst->getOperand(1));
+    return Ice::InstExtractElement::create(Func, Dest, Source1, Source2);
+  }
+
+  Ice::Inst *convertInsertElementInstruction(const InsertElementInst *Inst) {
+    Ice::Variable *Dest = mapValueToIceVar(Inst);
+    Ice::Operand *Source1 = convertValue(Inst->getOperand(0));
+    Ice::Operand *Source2 = convertValue(Inst->getOperand(1));
+    Ice::Operand *Source3 = convertValue(Inst->getOperand(2));
+    return Ice::InstInsertElement::create(Func, Dest, Source1, Source2,
+                                          Source3);
+  }
+
   Ice::Inst *convertSelectInstruction(const SelectInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *Cond = convertValue(Inst->getCondition());
     Ice::Operand *Source1 = convertValue(Inst->getTrueValue());
     Ice::Operand *Source2 = convertValue(Inst->getFalseValue());
     return Ice::InstSelect::create(Func, Dest, Cond, Source1, Source2);
   }
 
   Ice::Inst *convertSwitchInstruction(const SwitchInst *Inst) {
     Ice::Operand *Source = convertValue(Inst->getCondition());
@@ skipping 173 matching lines @@
                 << Fcn->getFunctionName() << ": " << TConvert.getElapsedSec()
                 << " sec\n";
     }
     translateFcn(Fcn);
   }
 
   emitConstants();
 }
 
 } // end of Ice namespace.