remove the read/write port/io intrinsics.
authorChris Lattner <sabre@nondot.org>
Fri, 3 Mar 2006 00:19:58 +0000 (00:19 +0000)
committerChris Lattner <sabre@nondot.org>
Fri, 3 Mar 2006 00:19:58 +0000 (00:19 +0000)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26479 91177308-0d34-0410-b5e6-96231b3b80d8

docs/LangRef.html
include/llvm/CodeGen/SelectionDAGNodes.h
include/llvm/Intrinsics.h
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
lib/Target/TargetSelectionDAG.td
lib/Target/X86/X86ISelLowering.cpp
lib/Target/X86/X86InstrInfo.td
lib/VMCore/Function.cpp
lib/VMCore/Verifier.cpp

index 20ad79799d38a5ae1efe0de9c34b49585ddbbf78..d4b83285d15baa24c1ce6c206a6af15297edd7fa 100644 (file)
           <li><a href="#i_readcyclecounter"><tt>llvm.readcyclecounter</tt>' Intrinsic</a></li>
         </ol>
       </li>
-      <li><a href="#int_os">Operating System Intrinsics</a>
-        <ol>
-          <li><a href="#i_readport">'<tt>llvm.readport</tt>' Intrinsic</a></li>
-          <li><a href="#i_writeport">'<tt>llvm.writeport</tt>' Intrinsic</a></li>
-          <li><a href="#i_readio">'<tt>llvm.readio</tt>'   Intrinsic</a></li>
-          <li><a href="#i_writeio">'<tt>llvm.writeio</tt>'   Intrinsic</a></li>
-        </ol>
       <li><a href="#int_libc">Standard C Library Intrinsics</a>
         <ol>
           <li><a href="#i_memcpy">'<tt>llvm.memcpy.*</tt>' Intrinsic</a></li>
@@ -3266,199 +3259,6 @@ system wide value.  On backends without support, this is lowered to a constant 0
 
 </div>
 
-
-<!-- ======================================================================= -->
-<div class="doc_subsection">
-  <a name="int_os">Operating System Intrinsics</a>
-</div>
-
-<div class="doc_text">
-<p>
-These intrinsics are provided by LLVM to support the implementation of
-operating system level code.
-</p>
-
-</div>
-
-<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection">
-  <a name="i_readport">'<tt>llvm.readport</tt>' Intrinsic</a>
-</div>
-
-<div class="doc_text">
-
-<h5>Syntax:</h5>
-<pre>
-  declare &lt;integer type&gt; %llvm.readport (&lt;integer type&gt; &lt;address&gt;)
-</pre>
-
-<h5>Overview:</h5>
-
-<p>
-The '<tt>llvm.readport</tt>' intrinsic reads data from the specified hardware
-I/O port.
-</p>
-
-<h5>Arguments:</h5>
-
-<p>
-The argument to this intrinsic indicates the hardware I/O address from which
-to read the data.  The address is in the hardware I/O address namespace (as
-opposed to being a memory location for memory mapped I/O).
-</p>
-
-<h5>Semantics:</h5>
-
-<p>
-The '<tt>llvm.readport</tt>' intrinsic reads data from the hardware I/O port
-specified by <i>address</i> and returns the value.  The address and return
-value must be integers, but the size is dependent upon the platform upon which
-the program is code generated.  For example, on x86, the address must be an
-unsigned 16-bit value, and the return value must be 8, 16, or 32 bits.
-</p>
-
-</div>
-
-<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection">
-  <a name="i_writeport">'<tt>llvm.writeport</tt>' Intrinsic</a>
-</div>
-
-<div class="doc_text">
-
-<h5>Syntax:</h5>
-<pre>
-  call void (&lt;integer type&gt;, &lt;integer type&gt;)*
-            %llvm.writeport (&lt;integer type&gt; &lt;value&gt;,
-                             &lt;integer type&gt; &lt;address&gt;)
-</pre>
-
-<h5>Overview:</h5>
-
-<p>
-The '<tt>llvm.writeport</tt>' intrinsic writes data to the specified hardware
-I/O port.
-</p>
-
-<h5>Arguments:</h5>
-
-<p>
-The first argument is the value to write to the I/O port.
-</p>
-
-<p>
-The second argument indicates the hardware I/O address to which data should be
-written.  The address is in the hardware I/O address namespace (as opposed to
-being a memory location for memory mapped I/O).
-</p>
-
-<h5>Semantics:</h5>
-
-<p>
-The '<tt>llvm.writeport</tt>' intrinsic writes <i>value</i> to the I/O port
-specified by <i>address</i>.  The address and value must be integers, but the
-size is dependent upon the platform upon which the program is code generated.
-For example, on x86, the address must be an unsigned 16-bit value, and the
-value written must be 8, 16, or 32 bits in length.
-</p>
-
-</div>
-
-<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection">
-  <a name="i_readio">'<tt>llvm.readio</tt>' Intrinsic</a>
-</div>
-
-<div class="doc_text">
-
-<h5>Syntax:</h5>
-<pre>
-  declare &lt;result&gt; %llvm.readio (&lt;ty&gt; * &lt;pointer&gt;)
-</pre>
-
-<h5>Overview:</h5>
-
-<p>
-The '<tt>llvm.readio</tt>' intrinsic reads data from a memory mapped I/O
-address.
-</p>
-
-<h5>Arguments:</h5>
-
-<p>
-The argument to this intrinsic is a pointer indicating the memory address from
-which to read the data.  The data must be a
-<a href="#t_firstclass">first class</a> type.
-</p>
-
-<h5>Semantics:</h5>
-
-<p>
-The '<tt>llvm.readio</tt>' intrinsic reads data from a memory mapped I/O
-location specified by <i>pointer</i> and returns the value.  The argument must
-be a pointer, and the return value must be a
-<a href="#t_firstclass">first class</a> type.  However, certain architectures
-may not support I/O on all first class types.  For example, 32-bit processors
-may only support I/O on data types that are 32 bits or less.
-</p>
-
-<p>
-This intrinsic enforces an in-order memory model for llvm.readio and
-llvm.writeio calls on machines that use dynamic scheduling.  Dynamically
-scheduled processors may execute loads and stores out of order, re-ordering at
-run time accesses to memory mapped I/O registers.  Using these intrinsics
-ensures that accesses to memory mapped I/O registers occur in program order.
-</p>
-
-</div>
-
-<!-- _______________________________________________________________________ -->
-<div class="doc_subsubsection">
-  <a name="i_writeio">'<tt>llvm.writeio</tt>' Intrinsic</a>
-</div>
-
-<div class="doc_text">
-
-<h5>Syntax:</h5>
-<pre>
-  declare void %llvm.writeio (&lt;ty1&gt; &lt;value&gt;, &lt;ty2&gt; * &lt;pointer&gt;)
-</pre>
-
-<h5>Overview:</h5>
-
-<p>
-The '<tt>llvm.writeio</tt>' intrinsic writes data to the specified memory
-mapped I/O address.
-</p>
-
-<h5>Arguments:</h5>
-
-<p>
-The first argument is the value to write to the memory mapped I/O location.
-The second argument is a pointer indicating the memory address to which the
-data should be written.
-</p>
-
-<h5>Semantics:</h5>
-
-<p>
-The '<tt>llvm.writeio</tt>' intrinsic writes <i>value</i> to the memory mapped
-I/O address specified by <i>pointer</i>.  The value must be a
-<a href="#t_firstclass">first class</a> type.  However, certain architectures
-may not support I/O on all first class types.  For example, 32-bit processors
-may only support I/O on data types that are 32 bits or less.
-</p>
-
-<p>
-This intrinsic enforces an in-order memory model for llvm.readio and
-llvm.writeio calls on machines that use dynamic scheduling.  Dynamically
-scheduled processors may execute loads and stores out of order, re-ordering at
-run time accesses to memory mapped I/O registers.  Using these intrinsics
-ensures that accesses to memory mapped I/O registers occur in program order.
-</p>
-
-</div>
-
 <!-- ======================================================================= -->
 <div class="doc_subsection">
   <a name="int_libc">Standard C Library Intrinsics</a>
index 7e3b1688ac46ce4c51ebea44a210122d8638634b..02feba71064e7111d32dbdbac19d838caca487a7 100644 (file)
@@ -379,12 +379,6 @@ namespace ISD {
     // register (or other high accuracy low latency clock source)
     READCYCLECOUNTER,
 
-    // READPORT, WRITEPORT, READIO, WRITEIO - These correspond to the LLVM
-    // intrinsics of the same name.  The first operand is a token chain, the
-    // other operands match the intrinsic.  These produce a token chain in
-    // addition to a value (if any).
-    READPORT, WRITEPORT, READIO, WRITEIO,
-    
     // HANDLENODE node - Used as a handle for various purposes.
     HANDLENODE,
 
index 62c58f0ba753e33d4fa38a3a2d82c9a083b536c6..80e3c6f61a7d192a62f1a2ae0fa73d3d2e727fe9 100644 (file)
@@ -86,13 +86,6 @@ namespace Intrinsic {
     cttz_i16,       // Count trailing zeros of short
     cttz_i32,       // Count trailing zeros of int
     cttz_i64,       // Count trailing zeros of long
-    
-    // Input/Output intrinsics.
-    readport,
-    writeport,
-    readio,
-    writeio
-
   };
 
 } // End Intrinsic namespace
index 2a9b80afa045778d37c9ec95becd93f66fba0430..2da993559f563befee18bef4de6de075f97304e4 100644 (file)
@@ -1691,68 +1691,6 @@ SDOperand SelectionDAGLegalize::LegalizeOp(SDOperand Op) {
     break;
   }
 
-  case ISD::READPORT:
-    Tmp1 = LegalizeOp(Node->getOperand(0));
-    Tmp2 = LegalizeOp(Node->getOperand(1));
-    Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2);
-
-    // Since these produce two values, make sure to remember that we legalized
-    // both of them.
-    AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0));
-    AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1));
-    return Result;
-  case ISD::WRITEPORT:
-    Tmp1 = LegalizeOp(Node->getOperand(0));
-    Tmp2 = LegalizeOp(Node->getOperand(1));
-    Tmp3 = LegalizeOp(Node->getOperand(2));
-    Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3);
-    break;
-
-  case ISD::READIO:
-    Tmp1 = LegalizeOp(Node->getOperand(0));
-    Tmp2 = LegalizeOp(Node->getOperand(1));
-
-    switch (TLI.getOperationAction(Node->getOpcode(), Node->getValueType(0))) {
-    case TargetLowering::Custom:
-    default: assert(0 && "This action not implemented for this operation!");
-    case TargetLowering::Legal:
-      Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2);
-      break;
-    case TargetLowering::Expand:
-      // Replace this with a load from memory.
-      Result = DAG.getLoad(Node->getValueType(0), Node->getOperand(0),
-                           Node->getOperand(1), DAG.getSrcValue(NULL));
-      Result = LegalizeOp(Result);
-      break;
-    }
-
-    // Since these produce two values, make sure to remember that we legalized
-    // both of them.
-    AddLegalizedOperand(SDOperand(Node, 0), Result.getValue(0));
-    AddLegalizedOperand(SDOperand(Node, 1), Result.getValue(1));
-    return Result.getValue(Op.ResNo);
-
-  case ISD::WRITEIO:
-    Tmp1 = LegalizeOp(Node->getOperand(0));
-    Tmp2 = LegalizeOp(Node->getOperand(1));
-    Tmp3 = LegalizeOp(Node->getOperand(2));
-
-    switch (TLI.getOperationAction(Node->getOpcode(),
-                                   Node->getOperand(1).getValueType())) {
-    case TargetLowering::Custom:
-    default: assert(0 && "This action not implemented for this operation!");
-    case TargetLowering::Legal:
-      Result = DAG.UpdateNodeOperands(Result, Tmp1, Tmp2, Tmp3);
-      break;
-    case TargetLowering::Expand:
-      // Replace this with a store to memory.
-      Result = DAG.getNode(ISD::STORE, MVT::Other, Node->getOperand(0),
-                           Node->getOperand(1), Node->getOperand(2),
-                           DAG.getSrcValue(NULL));
-      break;
-    }
-    break;
-
   case ISD::SHL_PARTS:
   case ISD::SRA_PARTS:
   case ISD::SRL_PARTS: {
index 1800a596580f720f807d780b674b5f949518d306..24497af2348e09bb2c1bc7d36cae9957af7cd2a3 100644 (file)
@@ -2691,12 +2691,6 @@ const char *SDNode::getOperationName(const SelectionDAG *G) const {
   case ISD::CTTZ:    return "cttz";
   case ISD::CTLZ:    return "ctlz";
 
-  // IO Intrinsics
-  case ISD::READPORT: return "readport";
-  case ISD::WRITEPORT: return "writeport";
-  case ISD::READIO: return "readio";
-  case ISD::WRITEIO: return "writeio";
-
   // Debug info
   case ISD::LOCATION: return "location";
   case ISD::DEBUG_LOC: return "debug_loc";
index 10ee2d50915e3f49f34c9e32f64d346fc0080c61..fea9b6e6dcf70a60ea18550920e7cc0333217d16 100644 (file)
@@ -968,29 +968,6 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
     visitMemIntrinsic(I, ISD::MEMMOVE);
     return 0;
     
-  case Intrinsic::readport:
-  case Intrinsic::readio: {
-    std::vector<MVT::ValueType> VTs;
-    VTs.push_back(TLI.getValueType(I.getType()));
-    VTs.push_back(MVT::Other);
-    std::vector<SDOperand> Ops;
-    Ops.push_back(getRoot());
-    Ops.push_back(getValue(I.getOperand(1)));
-    SDOperand Tmp = DAG.getNode(Intrinsic == Intrinsic::readport ?
-                                ISD::READPORT : ISD::READIO, VTs, Ops);
-    
-    setValue(&I, Tmp);
-    DAG.setRoot(Tmp.getValue(1));
-    return 0;
-  }
-  case Intrinsic::writeport:
-  case Intrinsic::writeio:
-    DAG.setRoot(DAG.getNode(Intrinsic == Intrinsic::writeport ?
-                            ISD::WRITEPORT : ISD::WRITEIO, MVT::Other,
-                            getRoot(), getValue(I.getOperand(1)),
-                            getValue(I.getOperand(2))));
-    return 0;
-    
   case Intrinsic::dbg_stoppoint: {
     if (TLI.getTargetMachine().getIntrinsicLowering().EmitDebugFunctions())
       return "llvm_debugger_stop";
index ab9430e7a3bc58f695c6247c63e976c72a6046e8..e754d2f0ea2806c02e392d0a6d6f137abc1ea95c 100644 (file)
@@ -138,14 +138,6 @@ def SDTBrcond : SDTypeProfile<0, 2, [ // brcond
 
 def SDTRet : SDTypeProfile<0, 0, []>; // ret
 
-def SDTReadPort : SDTypeProfile<1, 1, [ // readport
-  SDTCisInt<0>, SDTCisInt<1>
-]>;
-
-def SDTWritePort : SDTypeProfile<0, 2, [ // writeport
-  SDTCisInt<0>, SDTCisInt<1>
-]>;
-
 def SDTLoad : SDTypeProfile<1, 1, [ // load
   SDTCisPtrTy<1>  
 ]>;
@@ -284,9 +276,6 @@ def brcond     : SDNode<"ISD::BRCOND"     , SDTBrcond, [SDNPHasChain]>;
 def br         : SDNode<"ISD::BR"         , SDTBr,     [SDNPHasChain]>;
 def ret        : SDNode<"ISD::RET"        , SDTRet,    [SDNPHasChain]>;
 
-def readport   : SDNode<"ISD::READPORT"   , SDTReadPort,  [SDNPHasChain]>;
-def writeport  : SDNode<"ISD::WRITEPORT"  , SDTWritePort, [SDNPHasChain]>;
-
 def load       : SDNode<"ISD::LOAD"       , SDTLoad,  [SDNPHasChain]>;
 def store      : SDNode<"ISD::STORE"      , SDTStore, [SDNPHasChain]>;
 
index 2fd848d0306d2ef82927a10475081935bf882160..c99b06636a49bc641f59467a6f2e086ca469c13e 100644 (file)
@@ -137,15 +137,6 @@ X86TargetLowering::X86TargetLowering(TargetMachine &TM)
   setOperationAction(ISD::READCYCLECOUNTER , MVT::i64  , Custom);
   setOperationAction(ISD::BSWAP            , MVT::i16  , Expand);
 
-  setOperationAction(ISD::READIO           , MVT::i1   , Expand);
-  setOperationAction(ISD::READIO           , MVT::i8   , Expand);
-  setOperationAction(ISD::READIO           , MVT::i16  , Expand);
-  setOperationAction(ISD::READIO           , MVT::i32  , Expand);
-  setOperationAction(ISD::WRITEIO          , MVT::i1   , Expand);
-  setOperationAction(ISD::WRITEIO          , MVT::i8   , Expand);
-  setOperationAction(ISD::WRITEIO          , MVT::i16  , Expand);
-  setOperationAction(ISD::WRITEIO          , MVT::i32  , Expand);
-
   // These should be promoted to a larger select which is supported.
   setOperationAction(ISD::SELECT           , MVT::i1   , Promote);
   setOperationAction(ISD::SELECT           , MVT::i8   , Promote);
index 8b7b513d3cec23ea2a79f4f9440c6af9b24a5155..6831428c6ea775f6f33061c713233ac57b94f75e 100644 (file)
@@ -581,48 +581,48 @@ def REP_STOSD : I<0xAB, RawFrm, (ops), "{rep;stosl|rep stosd}",
 //
 def IN8rr  : I<0xEC, RawFrm, (ops),
                "in{b} {%dx, %al|%AL, %DX}",
-               [(set AL, (readport DX))]>,  Imp<[DX], [AL]>;
+               []>,  Imp<[DX], [AL]>;
 def IN16rr : I<0xED, RawFrm, (ops),
                "in{w} {%dx, %ax|%AX, %DX}",
-               [(set AX, (readport DX))]>,  Imp<[DX], [AX]>, OpSize;
+               []>,  Imp<[DX], [AX]>, OpSize;
 def IN32rr : I<0xED, RawFrm, (ops),
                "in{l} {%dx, %eax|%EAX, %DX}",
-               [(set EAX, (readport DX))]>, Imp<[DX],[EAX]>;
+               []>, Imp<[DX],[EAX]>;
 
 def IN8ri  : Ii8<0xE4, RawFrm, (ops i16i8imm:$port),
                   "in{b} {$port, %al|%AL, $port}",
-                 [(set AL, (readport i16immZExt8:$port))]>,
+                 []>,
              Imp<[], [AL]>;
 def IN16ri : Ii8<0xE5, RawFrm, (ops i16i8imm:$port),
                   "in{w} {$port, %ax|%AX, $port}",
-                 [(set AX, (readport i16immZExt8:$port))]>,
+                 []>,
              Imp<[], [AX]>, OpSize;
 def IN32ri : Ii8<0xE5, RawFrm, (ops i16i8imm:$port),
                   "in{l} {$port, %eax|%EAX, $port}",
-                 [(set EAX, (readport i16immZExt8:$port))]>,
+                 []>,
              Imp<[],[EAX]>;
 
 def OUT8rr  : I<0xEE, RawFrm, (ops),
                 "out{b} {%al, %dx|%DX, %AL}",
-                [(writeport AL, DX)]>,  Imp<[DX,  AL], []>;
+                []>,  Imp<[DX,  AL], []>;
 def OUT16rr : I<0xEF, RawFrm, (ops),
                 "out{w} {%ax, %dx|%DX, %AX}",
-                [(writeport AX, DX)]>,  Imp<[DX,  AX], []>, OpSize;
+                []>,  Imp<[DX,  AX], []>, OpSize;
 def OUT32rr : I<0xEF, RawFrm, (ops),
                 "out{l} {%eax, %dx|%DX, %EAX}",
-                [(writeport EAX, DX)]>, Imp<[DX, EAX], []>;
+                []>, Imp<[DX, EAX], []>;
 
 def OUT8ir  : Ii8<0xE6, RawFrm, (ops i16i8imm:$port),
                    "out{b} {%al, $port|$port, %AL}",
-                   [(writeport AL, i16immZExt8:$port)]>,
+                   []>,
               Imp<[AL], []>;
 def OUT16ir : Ii8<0xE7, RawFrm, (ops i16i8imm:$port),
                    "out{w} {%ax, $port|$port, %AX}",
-                   [(writeport AX, i16immZExt8:$port)]>,
+                   []>,
               Imp<[AX], []>, OpSize;
 def OUT32ir : Ii8<0xE7, RawFrm, (ops i16i8imm:$port),
                    "out{l} {%eax, $port|$port, %EAX}",
-                   [(writeport EAX, i16immZExt8:$port)]>,
+                   []>,
               Imp<[EAX], []>;
 
 //===----------------------------------------------------------------------===//
index 2412e09aedfd9fdf98ab74f306202655e1d08e14..15fd436c45a99677c94d84cc9d84b5946c9940b2 100644 (file)
@@ -265,8 +265,6 @@ unsigned Function::getIntrinsicID() const {
     break;
   case 'r':
     if (Name == "llvm.returnaddress")    return Intrinsic::returnaddress;
-    if (Name == "llvm.readport")         return Intrinsic::readport;
-    if (Name == "llvm.readio")           return Intrinsic::readio;
     if (Name == "llvm.readcyclecounter") return Intrinsic::readcyclecounter;
     break;
   case 's':
@@ -283,10 +281,6 @@ unsigned Function::getIntrinsicID() const {
     if (Name == "llvm.va_end")   return Intrinsic::vaend;
     if (Name == "llvm.va_start") return Intrinsic::vastart;
     break;
-  case 'w':
-    if (Name == "llvm.writeport") return Intrinsic::writeport;
-    if (Name == "llvm.writeio")   return Intrinsic::writeio;
-    break;
   }
   // The "llvm." namespace is reserved!
   assert(!"Unknown LLVM intrinsic function!");
index be08a11824d58fa46b349e319aabd14710c74dcd..ef88f0d87a1bc12196c6707f1e92627d28a909dc 100644 (file)
@@ -702,51 +702,6 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
     NumArgs = 1;
     break;
 
-  // Verify that read and write port have integral parameters of the correct
-  // signed-ness.
-  case Intrinsic::writeport:
-    Assert1(FT->getNumParams() == 2,
-            "Illegal # arguments for intrinsic function!", IF);
-    Assert1(FT->getParamType(0)->isIntegral(),
-            "First argument not unsigned int!", IF);
-    Assert1(FT->getParamType(1)->isUnsigned(),
-            "First argument not unsigned int!", IF);
-    NumArgs = 2;
-    break;
-
-  case Intrinsic::writeio:
-    Assert1(FT->getNumParams() == 2,
-            "Illegal # arguments for intrinsic function!", IF);
-    Assert1(FT->getParamType(0)->isFirstClassType(),
-            "First argument not a first class type!", IF);
-    Assert1(isa<PointerType>(FT->getParamType(1)),
-            "Second argument not a pointer!", IF);
-    NumArgs = 2;
-    break;
-
-  case Intrinsic::readport:
-    Assert1(FT->getNumParams() == 1,
-            "Illegal # arguments for intrinsic function!", IF);
-    Assert1(FT->getReturnType()->isFirstClassType(),
-            "Return type is not a first class type!", IF);
-    Assert1(FT->getParamType(0)->isUnsigned(),
-            "First argument not unsigned int!", IF);
-    NumArgs = 1;
-    break;
-
-  case Intrinsic::readio: {
-    const PointerType *ParamType = dyn_cast<PointerType>(FT->getParamType(0));
-    const Type *ReturnType = FT->getReturnType();
-
-    Assert1(FT->getNumParams() == 1,
-            "Illegal # arguments for intrinsic function!", IF);
-    Assert1(ParamType, "First argument not a pointer!", IF);
-    Assert1(ParamType->getElementType() == ReturnType,
-            "Pointer type doesn't match return type!", IF);
-    NumArgs = 1;
-    break;
-  }
-
   case Intrinsic::isunordered_f32:
     Assert1(FT->getNumParams() == 2,
             "Illegal # arguments for intrinsic function!", IF);