diff options
| -rw-r--r-- | include/llvm/Intrinsics.h | 76 | ||||
| -rw-r--r-- | lib/VMCore/Function.cpp | 32 | ||||
| -rw-r--r-- | lib/VMCore/Verifier.cpp | 19 |
3 files changed, 119 insertions, 8 deletions
diff --git a/include/llvm/Intrinsics.h b/include/llvm/Intrinsics.h index 26b9c35..72e85e7 100644 --- 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 6d78711..c7eb2ca 100644 --- 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 84556cd..a15733a 100644 --- 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; |