llvm.org GIT mirror llvm / 1b27914 include / llvm / IR / Intrinsics.h
1b27914

Tree @1b27914 (Download .tar.gz)

Intrinsics.h @1b27914

eea3543
9769ab2
6fbcc26
 
7ed47a1
 
9769ab2
6fbcc26
eea3543
 
 
 
 
 
 
674be02
 
eea3543
eb9a85f
deae48e
 
d0fde30
 
d4d68ba
95af592
 
12ddd40
95af592
99faa3b
95af592
be5d8bf
 
 
d0fde30
eea3543
 
c436b37
68b67ff
 
351ba14
68b67ff
e42dbed
eea3543
e42dbed
be5d8bf
5c332db
 
be5d8bf
db125cf
5c332db
95af592
be5d8bf
0d52ff1
 
be5d8bf
99faa3b
a3355ff
be5d8bf
 
9d4879f
8c3a549
 
 
 
5c332db
8c3a549
49de982
 
bb5f622
 
 
95af592
be5d8bf
 
908a831
 
2e50b8a
908a831
73ae1df
b313223
908a831
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
b7de428
73ae1df
b313223
908a831
 
 
b7de428
73ae1df
b313223
73ae1df
908a831
 
 
 
 
 
 
 
be5d8bf
 
908a831
 
d0fde30
 
 
eea3543
 
//===-- 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.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_IR_INTRINSICS_H
#define LLVM_IR_INTRINSICS_H

#include "llvm/ADT/ArrayRef.h"
#include <string>

namespace llvm {

class Type;
class FunctionType;
class Function;
class LLVMContext;
class Module;
class AttributeSet;

/// This namespace contains an enum with a value for every intrinsic/builtin
/// function known by LLVM. The enum values are returned by
/// Function::getIntrinsicID().
namespace Intrinsic {
  enum ID {
    not_intrinsic = 0,   // Must be zero

    // Get the intrinsic enums generated from Intrinsics.td
#define GET_INTRINSIC_ENUM_VALUES
#include "llvm/IR/Intrinsics.gen"
#undef GET_INTRINSIC_ENUM_VALUES
    , num_intrinsics
  };
  
  /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
  std::string getName(ID id, ArrayRef<Type*> Tys = None);

  /// Return the function type for an intrinsic.
  FunctionType *getType(LLVMContext &Context, ID id,
                        ArrayRef<Type*> Tys = None);

  /// Returns true if the intrinsic can be overloaded.
  bool isOverloaded(ID id);

  /// Return the attributes for an intrinsic.
  AttributeSet getAttributes(LLVMContext &C, ID id);

  /// Create or insert an LLVM Function declaration for an intrinsic, and return
  /// it.
  ///
  /// The Tys parameter is for intrinsics with overloaded types (e.g., those
  /// using iAny, fAny, vAny, or iPTRAny).  For a declaration of an overloaded
  /// intrinsic, Tys must provide exactly one type for each overloaded type in
  /// the intrinsic.
  Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);

  /// Map a GCC builtin name to an intrinsic ID.
  ID getIntrinsicForGCCBuiltin(const char *Prefix, const char *BuiltinName);

  /// Map a MS builtin name to an intrinsic ID.
  ID getIntrinsicForMSBuiltin(const char *Prefix, const char *BuiltinName);
  
  /// This is a type descriptor which explains the type requirements of an
  /// intrinsic. This is returned by getIntrinsicInfoTableEntries.
  struct IITDescriptor {
    enum IITDescriptorKind {
      Void, VarArg, MMX, Metadata, Half, Float, Double,
      Integer, Vector, Pointer, Struct,
      Argument, ExtendArgument, TruncArgument, HalfVecArgument,
      SameVecWidthArgument, PtrToArgument
    } Kind;
    
    union {
      unsigned Integer_Width;
      unsigned Float_Width;
      unsigned Vector_Width;
      unsigned Pointer_AddressSpace;
      unsigned Struct_NumElements;
      unsigned Argument_Info;
    };
    
    enum ArgKind {
      AK_AnyInteger,
      AK_AnyFloat,
      AK_AnyVector,
      AK_AnyPointer
    };
    unsigned getArgumentNumber() const {
      assert(Kind == Argument || Kind == ExtendArgument ||
             Kind == TruncArgument || Kind == HalfVecArgument ||
             Kind == SameVecWidthArgument || Kind == PtrToArgument);
      return Argument_Info >> 2;
    }
    ArgKind getArgumentKind() const {
      assert(Kind == Argument || Kind == ExtendArgument ||
             Kind == TruncArgument || Kind == HalfVecArgument ||
             Kind == SameVecWidthArgument || Kind == PtrToArgument);
      return (ArgKind)(Argument_Info & 3);
    }
    
    static IITDescriptor get(IITDescriptorKind K, unsigned Field) {
      IITDescriptor Result = { K, { Field } };
      return Result;
    }
  };
  
  /// Return the IIT table descriptor for the specified intrinsic into an array
  /// of IITDescriptors.
  void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
  
} // End Intrinsic namespace

} // End llvm namespace

#endif