Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- BuildLibCalls.h - Utility builder for libcalls -----------*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file exposes an interface to build some C language libcalls for
  10. // optimization passes that need to call the various functions.
  11. //
  12. //===----------------------------------------------------------------------===//
  13.  
  14. #ifndef LLVM_TRANSFORMS_UTILS_BUILDLIBCALLS_H
  15. #define LLVM_TRANSFORMS_UTILS_BUILDLIBCALLS_H
  16.  
  17. #include "llvm/Analysis/TargetLibraryInfo.h"
  18.  
  19. namespace llvm {
  20.   class Value;
  21.   class DataLayout;
  22.   class IRBuilderBase;
  23.  
  24.   /// Analyze the name and prototype of the given function and set any
  25.   /// applicable attributes. Note that this merely helps optimizations on an
  26.   /// already existing function but does not consider mandatory attributes.
  27.   ///
  28.   /// If the library function is unavailable, this doesn't modify it.
  29.   ///
  30.   /// Returns true if any attributes were set and false otherwise.
  31.   bool inferNonMandatoryLibFuncAttrs(Module *M, StringRef Name,
  32.                                      const TargetLibraryInfo &TLI);
  33.   bool inferNonMandatoryLibFuncAttrs(Function &F, const TargetLibraryInfo &TLI);
  34.  
  35.   /// Calls getOrInsertFunction() and then makes sure to add mandatory
  36.   /// argument attributes.
  37.   FunctionCallee getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
  38.                                     LibFunc TheLibFunc, FunctionType *T,
  39.                                     AttributeList AttributeList);
  40.   FunctionCallee getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
  41.                                     LibFunc TheLibFunc, FunctionType *T);
  42.   template <typename... ArgsTy>
  43.   FunctionCallee getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
  44.                                LibFunc TheLibFunc, AttributeList AttributeList,
  45.                                Type *RetTy, ArgsTy... Args) {
  46.     SmallVector<Type*, sizeof...(ArgsTy)> ArgTys{Args...};
  47.     return getOrInsertLibFunc(M, TLI, TheLibFunc,
  48.                               FunctionType::get(RetTy, ArgTys, false),
  49.                               AttributeList);
  50.   }
  51.   /// Same as above, but without the attributes.
  52.   template <typename... ArgsTy>
  53.   FunctionCallee getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
  54.                              LibFunc TheLibFunc, Type *RetTy, ArgsTy... Args) {
  55.     return getOrInsertLibFunc(M, TLI, TheLibFunc, AttributeList{}, RetTy,
  56.                               Args...);
  57.   }
  58.   // Avoid an incorrect ordering that'd otherwise compile incorrectly.
  59.   template <typename... ArgsTy>
  60.   FunctionCallee
  61.   getOrInsertLibFunc(Module *M, const TargetLibraryInfo &TLI,
  62.                      LibFunc TheLibFunc, AttributeList AttributeList,
  63.                      FunctionType *Invalid, ArgsTy... Args) = delete;
  64.  
  65.   /// Check whether the library function is available on target and also that
  66.   /// it in the current Module is a Function with the right type.
  67.   bool isLibFuncEmittable(const Module *M, const TargetLibraryInfo *TLI,
  68.                           LibFunc TheLibFunc);
  69.   bool isLibFuncEmittable(const Module *M, const TargetLibraryInfo *TLI,
  70.                           StringRef Name);
  71.  
  72.   /// Check whether the overloaded floating point function
  73.   /// corresponding to \a Ty is available.
  74.   bool hasFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty,
  75.                   LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn);
  76.  
  77.   /// Get the name of the overloaded floating point function
  78.   /// corresponding to \a Ty. Return the LibFunc in \a TheLibFunc.
  79.   StringRef getFloatFn(const Module *M, const TargetLibraryInfo *TLI, Type *Ty,
  80.                        LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn,
  81.                        LibFunc &TheLibFunc);
  82.  
  83.   /// Return V if it is an i8*, otherwise cast it to i8*.
  84.   Value *castToCStr(Value *V, IRBuilderBase &B);
  85.  
  86.   /// Emit a call to the strlen function to the builder, for the specified
  87.   /// pointer. Ptr is required to be some pointer type, and the return value has
  88.   /// 'size_t' type.
  89.   Value *emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
  90.                     const TargetLibraryInfo *TLI);
  91.  
  92.   /// Emit a call to the strdup function to the builder, for the specified
  93.   /// pointer. Ptr is required to be some pointer type, and the return value has
  94.   /// 'i8*' type.
  95.   Value *emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI);
  96.  
  97.   /// Emit a call to the strchr function to the builder, for the specified
  98.   /// pointer and character. Ptr is required to be some pointer type, and the
  99.   /// return value has 'i8*' type.
  100.   Value *emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
  101.                     const TargetLibraryInfo *TLI);
  102.  
  103.   /// Emit a call to the strncmp function to the builder.
  104.   Value *emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
  105.                      const DataLayout &DL, const TargetLibraryInfo *TLI);
  106.  
  107.   /// Emit a call to the strcpy function to the builder, for the specified
  108.   /// pointer arguments.
  109.   Value *emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
  110.                     const TargetLibraryInfo *TLI);
  111.  
  112.   /// Emit a call to the stpcpy function to the builder, for the specified
  113.   /// pointer arguments.
  114.   Value *emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
  115.                     const TargetLibraryInfo *TLI);
  116.  
  117.   /// Emit a call to the strncpy function to the builder, for the specified
  118.   /// pointer arguments and length.
  119.   Value *emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
  120.                      const TargetLibraryInfo *TLI);
  121.  
  122.   /// Emit a call to the stpncpy function to the builder, for the specified
  123.   /// pointer arguments and length.
  124.   Value *emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
  125.                      const TargetLibraryInfo *TLI);
  126.  
  127.   /// Emit a call to the __memcpy_chk function to the builder. This expects that
  128.   /// the Len and ObjSize have type 'size_t' and Dst/Src are pointers.
  129.   Value *emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
  130.                        IRBuilderBase &B, const DataLayout &DL,
  131.                        const TargetLibraryInfo *TLI);
  132.  
  133.   /// Emit a call to the mempcpy function.
  134.   Value *emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
  135.                      const DataLayout &DL, const TargetLibraryInfo *TLI);
  136.  
  137.   /// Emit a call to the memchr function. This assumes that Ptr is a pointer,
  138.   /// Val is an 'int' value, and Len is an 'size_t' value.
  139.   Value *emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
  140.                     const DataLayout &DL, const TargetLibraryInfo *TLI);
  141.  
  142.   /// Emit a call to the memrchr function, analogously to emitMemChr.
  143.   Value *emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
  144.                     const DataLayout &DL, const TargetLibraryInfo *TLI);
  145.  
  146.   /// Emit a call to the memcmp function.
  147.   Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
  148.                     const DataLayout &DL, const TargetLibraryInfo *TLI);
  149.  
  150.   /// Emit a call to the bcmp function.
  151.   Value *emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
  152.                   const DataLayout &DL, const TargetLibraryInfo *TLI);
  153.  
  154.   /// Emit a call to the memccpy function.
  155.   Value *emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
  156.                      IRBuilderBase &B, const TargetLibraryInfo *TLI);
  157.  
  158.   /// Emit a call to the snprintf function.
  159.   Value *emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
  160.                       ArrayRef<Value *> Args, IRBuilderBase &B,
  161.                       const TargetLibraryInfo *TLI);
  162.  
  163.   /// Emit a call to the sprintf function.
  164.   Value *emitSPrintf(Value *Dest, Value *Fmt, ArrayRef<Value *> VariadicArgs,
  165.                      IRBuilderBase &B, const TargetLibraryInfo *TLI);
  166.  
  167.   /// Emit a call to the strcat function.
  168.   Value *emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
  169.                     const TargetLibraryInfo *TLI);
  170.  
  171.   /// Emit a call to the strlcpy function.
  172.   Value *emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
  173.                      const TargetLibraryInfo *TLI);
  174.  
  175.   /// Emit a call to the strlcat function.
  176.   Value *emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
  177.                      const TargetLibraryInfo *TLI);
  178.  
  179.   /// Emit a call to the strncat function.
  180.   Value *emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
  181.                      const TargetLibraryInfo *TLI);
  182.  
  183.   /// Emit a call to the vsnprintf function.
  184.   Value *emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
  185.                        IRBuilderBase &B, const TargetLibraryInfo *TLI);
  186.  
  187.   /// Emit a call to the vsprintf function.
  188.   Value *emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilderBase &B,
  189.                       const TargetLibraryInfo *TLI);
  190.  
  191.   /// Emit a call to the unary function named 'Name' (e.g.  'floor'). This
  192.   /// function is known to take a single of type matching 'Op' and returns one
  193.   /// value with the same type. If 'Op' is a long double, 'l' is added as the
  194.   /// suffix of name, if 'Op' is a float, we add a 'f' suffix.
  195.   Value *emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
  196.                               StringRef Name, IRBuilderBase &B,
  197.                               const AttributeList &Attrs);
  198.  
  199.   /// Emit a call to the unary function DoubleFn, FloatFn or LongDoubleFn,
  200.   /// depending of the type of Op.
  201.   Value *emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
  202.                               LibFunc DoubleFn, LibFunc FloatFn,
  203.                               LibFunc LongDoubleFn, IRBuilderBase &B,
  204.                               const AttributeList &Attrs);
  205.  
  206.   /// Emit a call to the binary function named 'Name' (e.g. 'fmin'). This
  207.   /// function is known to take type matching 'Op1' and 'Op2' and return one
  208.   /// value with the same type. If 'Op1/Op2' are long double, 'l' is added as
  209.   /// the suffix of name, if 'Op1/Op2' are float, we add a 'f' suffix.
  210.   Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2,
  211.                                const TargetLibraryInfo *TLI,
  212.                                StringRef Name, IRBuilderBase &B,
  213.                                const AttributeList &Attrs);
  214.  
  215.   /// Emit a call to the binary function DoubleFn, FloatFn or LongDoubleFn,
  216.   /// depending of the type of Op1.
  217.   Value *emitBinaryFloatFnCall(Value *Op1, Value *Op2,
  218.                                const TargetLibraryInfo *TLI, LibFunc DoubleFn,
  219.                                LibFunc FloatFn, LibFunc LongDoubleFn,
  220.                                IRBuilderBase &B, const AttributeList &Attrs);
  221.  
  222.   /// Emit a call to the putchar function. This assumes that Char is an 'int'.
  223.   Value *emitPutChar(Value *Char, IRBuilderBase &B,
  224.                      const TargetLibraryInfo *TLI);
  225.  
  226.   /// Emit a call to the puts function. This assumes that Str is some pointer.
  227.   Value *emitPutS(Value *Str, IRBuilderBase &B, const TargetLibraryInfo *TLI);
  228.  
  229.   /// Emit a call to the fputc function. This assumes that Char is an 'int', and
  230.   /// File is a pointer to FILE.
  231.   Value *emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
  232.                    const TargetLibraryInfo *TLI);
  233.  
  234.   /// Emit a call to the fputs function. Str is required to be a pointer and
  235.   /// File is a pointer to FILE.
  236.   Value *emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
  237.                    const TargetLibraryInfo *TLI);
  238.  
  239.   /// Emit a call to the fwrite function. This assumes that Ptr is a pointer,
  240.   /// Size is an 'size_t', and File is a pointer to FILE.
  241.   Value *emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
  242.                     const DataLayout &DL, const TargetLibraryInfo *TLI);
  243.  
  244.   /// Emit a call to the malloc function.
  245.   Value *emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
  246.                     const TargetLibraryInfo *TLI);
  247.  
  248.   /// Emit a call to the calloc function.
  249.   Value *emitCalloc(Value *Num, Value *Size, IRBuilderBase &B,
  250.                     const TargetLibraryInfo &TLI);
  251. }
  252.  
  253. #endif
  254.