Add a bunch of new Alpha Intrinsics for Rahul Joshi

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7646 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Intrinsics.h b/include/llvm/Intrinsics.h
index 26b9c355d4fe9060590bcdc46541d4d996c3b0d8..72e85e721d20e0ec163ae208f19b75403d9a8aa6 100644 (file)
--- a/include/llvm/Intrinsics.h
+++ b/include/llvm/Intrinsics.h
@@ -30,13 +30,89 @@ namespace LLVMIntrinsic {
     //
     alpha_ctlz,     // CTLZ (count leading zero): counts the number of leading
                     // zeros in the given ulong value
+
     alpha_cttz,     // CTTZ (count trailing zero): counts the number of trailing
                     // zeros in the given ulong value 
+
     alpha_ctpop,    // CTPOP (count population): counts the number of ones in
                     // the given ulong value 
+
     alpha_umulh,    // UMULH (unsigned multiply quadword high): Takes two 64-bit
                     // (ulong) values, and returns the upper 64 bits of their
                     // 128 bit product as a ulong
+
+    alpha_vecop,    // A generic vector operation. This function is used to
+                    // represent various Alpha vector/multimedia instructions.
+                    // It takes 4 parameters:
+                    //  - the first two are 2 ulong vectors
+                    //  - the third (uint) is the size (in bytes) of each 
+                    //    vector element. Thus a value of 1 means that the two
+                    //    input vectors consist of 8 bytes
+                    //  - the fourth (uint) is the operation to be performed on
+                    //    the vectors. Its possible values are defined in the
+                    //    enumeration AlphaVecOps.
+
+    alpha_pup,      // A pack/unpack operation. This function is used to
+                    // represent Alpha pack/unpack operations. 
+                    // It takes 3 parameters:
+                    //  - the first is an ulong to pack/unpack
+                    //  - the second (uint) is the size of each component
+                    //    Valid values are 2 (word) or 4 (longword)
+                    //  - the third (uint) is the operation to be performed.
+                    //    Possible values defined in the enumeration 
+                    //    AlphaPupOps
+
+    alpha_bytezap,  // This intrinsic function takes two parameters: a ulong 
+                    // (64-bit) value and a ubyte value, and returns a ulong.
+                    // Each bit in the ubyte corresponds to a byte in the 
+                    // ulong. If the bit is 0, the byte in the output equals
+                    // the corresponding byte in the input, else the byte in
+                    // the output is zero.
+
+    alpha_bytemanip,// This intrinsic function represents all Alpha byte
+                    // manipulation instructions. It takes 3 parameters:
+                    //  - The first two are ulong inputs to operate on
+                    //  - The third (uint) is the operation to perform. 
+                    //    Possible values defined in the enumeration
+                    //    AlphaByteManipOps
+
+    alpha_dfpbop,   // This intrinsic function represents Alpha instructions
+                    // that operate on two doubles and return a double. The
+                    // first two parameters are the two double values to
+                    // operate on, and the third is a uint that specifies the
+                    // operation to perform. Its possible values are defined in
+                    // the enumeration AlphaFloatingBinaryOps
+
+    alpha_dfpuop,   // This intrinsic function represents operation on a single
+                    // double precision floating point value. The first 
+                    // paramters is the value and the second is the operation.
+                    // The possible values for the operations are defined in the
+                    // enumeration AlphaFloatingUnaryOps
+
+    alpha_unordered,// This intrinsic function tests if two double precision
+                    // floating point values are unordered. It has two
+                    // parameters: the two values to be tested. It return a
+                    // boolean true if the two are unordered, else false.
+
+    alpha_uqtodfp,  // A generic function that converts a ulong to a double.
+                    // How the conversion is performed is specified by the
+                    // second parameter, the possible values for which are
+                    // defined in the AlphaUqToDfpOps enumeration
+
+    alpha_uqtosfp,  // A generic function that converts a ulong to a float.
+                    // How the conversion is performed is specified by the
+                    // second parameter, the possible values for which are
+                    // defined in the AlphaUqToSfpOps enumeration
+
+    alpha_dfptosq,  // A generic function that converts double to a long.
+                    // How the conversion is performed is specified by the
+                    // second parameter, the possible values for which are
+                    // defined in the AlphaDfpToSqOps enumeration
+
+    alpha_sfptosq,  // A generic function that converts a float to a long.
+                    // How the conversion is performed is specified by the
+                    // second parameter, the possible values for which are
+                    // defined in the AlphaSfpToSq enumeration
   };
 }
 

diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index 6d78711411bef9a83623b3df3ad46b15e251281c..c7eb2ca5b7bb84f15de3eede7ac64f4355264f89 100644 (file)
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -163,12 +163,36 @@ unsigned Function::getIntrinsicID() const {
       getName()[1] != 'l' || getName()[2] != 'v' || getName()[3] != 'm')
     return 0;  // All intrinsics start with 'llvm.'
   
+  // a table of all Alpha intrinsic functions
+  struct {
+   std::string name;  // The name of the intrinsic 
+   unsigned id;       // Its ID number
+  } alpha_intrinsics[] = {
+     { "llvm.alpha.ctlz",      LLVMIntrinsic::alpha_ctlz },
+     { "llvm.alpha.cttz",      LLVMIntrinsic::alpha_cttz },
+     { "llvm.alpha.ctpop",     LLVMIntrinsic::alpha_ctpop },
+     { "llvm.alpha.umulh",     LLVMIntrinsic::alpha_umulh },
+     { "llvm.alpha.vecop",     LLVMIntrinsic::alpha_vecop },
+     { "llvm.alpha.pup",       LLVMIntrinsic::alpha_pup },
+     { "llvm.alpha.bytezap",   LLVMIntrinsic::alpha_bytezap },
+     { "llvm.alpha.bytemanip", LLVMIntrinsic::alpha_bytemanip },
+     { "llvm.alpha.dfp_bop",   LLVMIntrinsic::alpha_dfpbop }, 
+     { "llvm.alpha.dfp_uop",   LLVMIntrinsic::alpha_dfpuop },
+     { "llvm.alpha.unordered", LLVMIntrinsic::alpha_unordered },
+     { "llvm.alpha.uqtodfp",   LLVMIntrinsic::alpha_uqtodfp },
+     { "llvm.alpha.uqtosfp",   LLVMIntrinsic::alpha_uqtosfp },
+     { "llvm.alpha.dfptosq",   LLVMIntrinsic::alpha_dfptosq },
+     { "llvm.alpha.sfptosq",   LLVMIntrinsic::alpha_sfptosq },
+  };
+  const unsigned num_alpha_intrinsics = 
+                 sizeof(alpha_intrinsics) / sizeof(*alpha_intrinsics);
+
   switch (getName()[5]) {
   case 'a':
-    if (getName() == "llvm.alpha.ctlz")  return LLVMIntrinsic::alpha_ctlz;
-    if (getName() == "llvm.alpha.cttz")  return LLVMIntrinsic::alpha_cttz;
-    if (getName() == "llvm.alpha.ctpop") return LLVMIntrinsic::alpha_ctpop;
-    if (getName() == "llvm.alpha.umulh") return LLVMIntrinsic::alpha_umulh;
+    for (unsigned i = 0; i < num_alpha_intrinsics; ++i) {
+       if (getName() == alpha_intrinsics[i].name)
+         return alpha_intrinsics[i].id;
+    }
     break;
   case 'l':
     if (getName() == "llvm.longjmp")  return LLVMIntrinsic::longjmp;

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index 84556cddc1b453353ebd436d929cdf9a49314ca5..a15733af12fac9d2249d7d3dec37dfe0eb58c6d6 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -522,10 +522,21 @@ void Verifier::visitIntrinsicFunctionCall(LLVMIntrinsic::ID ID, CallInst &CI) {
   case LLVMIntrinsic::setjmp:  NumArgs = 1; break;
   case LLVMIntrinsic::longjmp: NumArgs = 2; break;
  
-  case LLVMIntrinsic::alpha_ctlz:  NumArgs = 1; break;
-  case LLVMIntrinsic::alpha_cttz:  NumArgs = 1; break;
-  case LLVMIntrinsic::alpha_ctpop: NumArgs = 1; break;
-  case LLVMIntrinsic::alpha_umulh: NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_ctlz:      NumArgs = 1; break;
+  case LLVMIntrinsic::alpha_cttz:      NumArgs = 1; break;
+  case LLVMIntrinsic::alpha_ctpop:     NumArgs = 1; break;
+  case LLVMIntrinsic::alpha_umulh:     NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_vecop:     NumArgs = 4; break;
+  case LLVMIntrinsic::alpha_pup:       NumArgs = 3; break;
+  case LLVMIntrinsic::alpha_bytezap:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_bytemanip: NumArgs = 3; break;
+  case LLVMIntrinsic::alpha_dfpbop:    NumArgs = 3; break;
+  case LLVMIntrinsic::alpha_dfpuop:    NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_unordered: NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_uqtodfp:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_uqtosfp:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_dfptosq:   NumArgs = 2; break;
+  case LLVMIntrinsic::alpha_sfptosq:   NumArgs = 2; break;
 
   case LLVMIntrinsic::not_intrinsic: 
     assert(0 && "Invalid intrinsic!"); NumArgs = 0; break;