X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FIntrinsics.h;h=243359953bcbe18f2876123aa32578017392e15b;hb=d24479730a8790d82c4859dc477bc2416d7a6bda;hp=12cf378f651c12684588ba187dcd4f8e3d83fdc6;hpb=8d8d361e207dda8421a0cd975a549d08dd4403a2;p=oota-llvm.git diff --git a/include/llvm/Intrinsics.h b/include/llvm/Intrinsics.h index 12cf378f651..243359953bc 100644 --- a/include/llvm/Intrinsics.h +++ b/include/llvm/Intrinsics.h @@ -1,5 +1,12 @@ //===-- llvm/Instrinsics.h - LLVM Intrinsic Function Handling ---*- C++ -*-===// // +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// // This file defines a set of enums which allow processing of intrinsic // functions. Values of these enum types are returned by // Function::getIntrinsicID. @@ -9,115 +16,59 @@ #ifndef LLVM_INTRINSICS_H #define LLVM_INTRINSICS_H -/// LLVMIntrinsic Namespace - This namespace contains an enum with a value for +#include + +namespace llvm { + +class Type; +class FunctionType; +class Function; +class Module; +class AttrListPtr; + +/// Intrinsic Namespace - This namespace contains an enum with a value for /// every intrinsic/builtin function known by LLVM. These enum values are /// returned by Function::getIntrinsicID(). /// -namespace LLVMIntrinsic { +namespace Intrinsic { enum ID { not_intrinsic = 0, // Must be zero - // Varargs handling intrinsics... - va_start, // Used to represent a va_start call in C - va_end, // Used to represent a va_end call in C - va_copy, // Used to represent a va_copy call in C - - // Setjmp/Longjmp intrinsics... - setjmp, // Used to represent a setjmp call in C - longjmp, // Used to represent a longjmp call in C - sigsetjmp, // Used to represent a sigsetjmp call in C - siglongjmp, // Used to represent a siglongjmp call in C - - //===------------------------------------------------------------------===// - // This section defines intrinsic functions used to represent Alpha - // instructions... - // - 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 + // Get the intrinsic enums generated from Intrinsics.td +#define GET_INTRINSIC_ENUM_VALUES +#include "llvm/Intrinsics.gen" +#undef GET_INTRINSIC_ENUM_VALUES + , num_intrinsics }; -} + + /// Intrinsic::getName(ID) - Return the LLVM name for an intrinsic, such as + /// "llvm.ppc.altivec.lvx". + std::string getName(ID id, const Type **Tys = 0, unsigned numTys = 0); + + /// Intrinsic::getType(ID) - Return the function type for an intrinsic. + /// + const FunctionType *getType(ID id, const Type **Tys = 0, unsigned numTys = 0); + + /// Intrinsic::getAttributes(ID) - Return the attributes for an intrinsic. + /// + AttrListPtr getAttributes(ID id); + + /// Intrinsic::getDeclaration(M, ID) - Create or insert an LLVM Function + /// declaration for an intrinsic, and return it. + /// + /// The Tys and numTys parameters are for intrinsics with overloaded types + /// (i.e., those using iAny or fAny). For a declaration for an overloaded + /// intrinsic, Tys should point to an array of numTys pointers to Type, + /// and must provide exactly one type for each overloaded type in the + /// intrinsic. + Function *getDeclaration(Module *M, ID id, const Type **Tys = 0, + unsigned numTys = 0); + + /// Map a GCC builtin name to an intrinsic ID. + ID getIntrinsicForGCCBuiltin(const char *Prefix, const char *BuiltinName); + +} // End Intrinsic namespace + +} // End llvm namespace #endif