Add a few Subzero intrinsics (not the atomic ones yet).

src/llvm2ice.cpp

 //===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a driver that uses LLVM capabilities to parse a
@@ skipping 508 matching lines @@
     }
     return Switch;
   }
 
   Ice::Inst *convertCallInstruction(const CallInst *Inst) {
     Ice::Variable *Dest = mapValueToIceVar(Inst);
     Ice::Operand *CallTarget = convertValue(Inst->getCalledValue());
     unsigned NumArgs = Inst->getNumArgOperands();
     // Note: Subzero doesn't (yet) do anything special with the Tail
     // flag in the bitcode, i.e. CallInst::isTailCall().
-    Ice::InstCall *NewInst =
-        Ice::InstCall::create(Func, NumArgs, Dest, CallTarget);
+    Ice::InstCall *NewInst = NULL;
+
+    if (Ice::ConstantRelocatable *Target =
+        llvm::dyn_cast<Ice::ConstantRelocatable>(CallTarget)) {
+      // Check if this direct call is to an Intrinsic (starts with "llvm.")

[Jim Stichnoth, 2014/06/10 22:58:28]

I hate that std::string doesn't have a simple startsWith() method.  Can this be
an easier-to-read test like Name.substr(0,5)=="llvm." ?

[jvoung (off chromium), 2014/06/12 05:48:30]

Done -- at some point we might want to just some string utilities -- E.g.,
LLVM's StringRef has startswith(), but what you suggest works =)

[Jim Stichnoth, 2014/06/12 20:52:06]

Sorry, I used the constant 5 in my suggestion just to be concise, but it would
be a lot better to be more symbolic, e.g.

static const char *LlvmPrefix = "llvm.";
const size_t LlvmPrefixLen = strlen(LlvmPrefix);
... Name.substr(0, LlvmPrefixLen) == LlvmPrefix ...


The strlen() call ought to get computed at compile time, but not a big deal if
it doesn't.

[jvoung (off chromium), 2014/06/16 20:51:58]

Done.

+      Ice::IceString Name = Target->getName();
+      size_t Dot = Name.find('.');
+      if (Dot != Ice::IceString::npos &&
+          Name.substr(0, Dot) == Ice::IceString("llvm")) {
+        Ice::IceString NameSuffix = Name.substr(Dot + 1);
+        Ice::IntrinsicInfo Info = Ctx->getIntrinsicInfo(NameSuffix);
+        if (Info == Ice::UnknownIntrinsicInfo) {
+          report_fatal_error(std::string("Invalid PNaCl intrinsic call: ") +
+                             LLVMObjectAsString(Inst));
+        }
+        NewInst = Ice::InstIntrinsicCall::create(Func, NumArgs, Dest,
+                                                 CallTarget, Info);
+      }
+    }
+
+    // Not an intrinsic call.
+    if (NewInst == NULL) {
+      NewInst = Ice::InstCall::create(Func, NumArgs, Dest, CallTarget);
+    }
     for (unsigned i = 0; i < NumArgs; ++i) {
       NewInst->addArg(convertOperand(Inst, i));
     }
     return NewInst;
   }
 
   Ice::Inst *convertAllocaInstruction(const AllocaInst *Inst) {
     // PNaCl bitcode only contains allocas of byte-granular objects.
     Ice::Operand *ByteCount = convertValue(Inst->getArraySize());
     uint32_t Align = Inst->getAlignment();
@@ skipping 184 matching lines @@
                   << " sec\n";
       }
     }
   }
 
   if (!DisableTranslation && Func)
     Func->getTarget()->emitConstants();
 
   return ExitStatus;
 }