Subzero: Run sandboxed cross tests, and do some cleanup.

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 1555 matching lines @@
     const auto *C = dyn_cast<Ice::ConstantInteger32>(Index);
     if (C == nullptr)
       return VectorIndexNotConstant;
     if (static_cast<size_t>(C->getValue()) >= typeNumElements(VecType))
       return VectorIndexNotInRange;
     if (Index->getType() != Ice::IceType_i32)
       return VectorIndexNotI32;
     return VectorIndexValid;
   }
 
-  // Returns true if the Str begins with Prefix.
-  bool isStringPrefix(const Ice::IceString &Str, const Ice::IceString &Prefix) {
-    const size_t PrefixSize = Prefix.size();
-    if (Str.size() < PrefixSize)
-      return false;
-    for (size_t i = 0; i < PrefixSize; ++i) {
-      if (Str[i] != Prefix[i])
-        return false;
-    }
-    return true;
-  }
-
   // Takes the PNaCl bitcode binary operator Opcode, and the opcode
   // type Ty, and sets Op to the corresponding ICE binary
   // opcode. Returns true if able to convert, false otherwise.
   bool convertBinopOpcode(unsigned Opcode, Ice::Type Ty,
                           Ice::InstArithmetic::OpKind &Op) {
     switch (Opcode) {
     default: {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Binary opcode " << Opcode << "not understood for type " << Ty;
@@ skipping 906 matching lines @@
     uint32_t CalleeIndex = convertRelativeToAbsIndex(Values[1], BaseIndex);
     Ice::Operand *Callee = getOperand(CalleeIndex);
     Ice::Type ReturnType = Ice::IceType_void;
     const Ice::Intrinsics::FullIntrinsicInfo *IntrinsicInfo = nullptr;
     if (Record.GetCode() == naclbitc::FUNC_CODE_INST_CALL) {
       Ice::FunctionDeclaration *Fcn = Context->getFunctionByID(CalleeIndex);
       const Ice::FuncSigType &Signature = Fcn->getSignature();
       ReturnType = Signature.getReturnType();
 
       // Check if this direct call is to an Intrinsic (starts with "llvm.")
-      static Ice::IceString LLVMPrefix("llvm.");
+      bool BadIntrinsic;
       const Ice::IceString &Name = Fcn->getName();
-      if (isStringPrefix(Name, LLVMPrefix)) {
-        Ice::IceString Suffix = Name.substr(LLVMPrefix.size());
-        IntrinsicInfo =
-            getTranslator().getContext()->getIntrinsicsInfo().find(Suffix);
-        if (!IntrinsicInfo) {
-          std::string Buffer;
-          raw_string_ostream StrBuf(Buffer);
-          StrBuf << "Invalid PNaCl intrinsic call to " << Name;
-          Error(StrBuf.str());
-          appendErrorInstruction(ReturnType);
-          return;
-        }
+      IntrinsicInfo = getTranslator().getContext()->getIntrinsicsInfo().find(
+          Name, BadIntrinsic);
+      if (BadIntrinsic) {
+        std::string Buffer;
+        raw_string_ostream StrBuf(Buffer);
+        StrBuf << "Invalid PNaCl intrinsic call to " << Name;
+        Error(StrBuf.str());
+        appendErrorInstruction(ReturnType);
+        return;
       }
     } else {
       if (getFlags().getStubConstantCalls() &&
           llvm::isa<Ice::ConstantInteger32>(Callee)) {
         Callee = Context->getStubbedConstCallValue(Callee);
       }
       ReturnType = Context->getSimpleTypeByID(Values[2]);
     }
 
     // Extract call information.
@@ skipping 528 matching lines @@
 
   if (TopLevelBlocks != 1) {
     errs() << IRFilename
            << ": Contains more than one module. Found: " << TopLevelBlocks
            << "\n";
     ErrorStatus.assign(EC_Bitcode);
   }
 }
 
 } // end of namespace Ice