lib/CodeGen/ABIInfo.h

   1 //===----- ABIInfo.h - ABI information access & encapsulation ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef CLANG_CODEGEN_ABIINFO_H
  11 #define CLANG_CODEGEN_ABIINFO_H
  12
  13 #include "clang/AST/Type.h"
  14
  15 #include <cassert>
  16
  17 namespace llvm {
  18   class Type;
  19   class Value;
  20   class LLVMContext;
  21 }
  22
  23 namespace clang {
  24   class ASTContext;
  25
  26   // FIXME: This is a layering issue if we want to move ABIInfo
  27   // down. Fortunately CGFunctionInfo has no real tie to CodeGen.
  28   namespace CodeGen {
  29     class CGFunctionInfo;
  30     class CodeGenFunction;
  31   }
  32
  33   /* FIXME: All of this stuff should be part of the target interface
  34      somehow. It is currently here because it is not clear how to factor
  35      the targets to support this, since the Targets currently live in a
  36      layer below types n'stuff.
  37   */
  38
  39   /// ABIArgInfo - Helper class to encapsulate information about how a
  40   /// specific C type should be passed to or returned from a function.
  41   class ABIArgInfo {
  42   public:
  43     enum Kind {
  44       Direct,    /// Pass the argument directly using the normal
  45                  /// converted LLVM type. Complex and structure types
  46                  /// are passed using first class aggregates.
  47
  48       Extend,    /// Valid only for integer argument types. Same as 'direct'
  49                  /// but also emit a zero/sign extension attribute.
  50
  51       Indirect,  /// Pass the argument indirectly via a hidden pointer
  52                  /// with the specified alignment (0 indicates default
  53                  /// alignment).
  54
  55       Ignore,    /// Ignore the argument (treat as void). Useful for
  56                  /// void and empty structs.
  57
  58       Coerce,    /// Only valid for aggregate return types, the argument
  59                  /// should be accessed by coercion to a provided type.
  60
  61       Expand,    /// Only valid for aggregate argument types. The
  62                  /// structure should be expanded into consecutive
  63                  /// arguments for its constituent fields. Currently
  64                  /// expand is only allowed on structures whose fields
  65                  /// are all scalar types or are themselves expandable
  66                  /// types.
  67
  68       KindFirst=Direct, KindLast=Expand
  69     };
  70
  71   private:
  72     Kind TheKind;
  73     const llvm::Type *TypeData;
  74     unsigned UIntData;
  75
  76     ABIArgInfo(Kind K, const llvm::Type *TD=0,
  77                unsigned UI=0) : TheKind(K),
  78                                 TypeData(TD),
  79                                 UIntData(UI) {}
  80   public:
  81     ABIArgInfo() : TheKind(Direct), TypeData(0), UIntData(0) {}
  82
  83     static ABIArgInfo getDirect() {
  84       return ABIArgInfo(Direct);
  85     }
  86     static ABIArgInfo getExtend() {
  87       return ABIArgInfo(Extend);
  88     }
  89     static ABIArgInfo getIgnore() {
  90       return ABIArgInfo(Ignore);
  91     }
  92     static ABIArgInfo getCoerce(const llvm::Type *T) {
  93       return ABIArgInfo(Coerce, T);
  94     }
  95     static ABIArgInfo getIndirect(unsigned Alignment) {
  96       return ABIArgInfo(Indirect, 0, Alignment);
  97     }
  98     static ABIArgInfo getExpand() {
  99       return ABIArgInfo(Expand);
 100     }
 101
 102     Kind getKind() const { return TheKind; }
 103     bool isDirect() const { return TheKind == Direct; }
 104     bool isExtend() const { return TheKind == Extend; }
 105     bool isIgnore() const { return TheKind == Ignore; }
 106     bool isCoerce() const { return TheKind == Coerce; }
 107     bool isIndirect() const { return TheKind == Indirect; }
 108     bool isExpand() const { return TheKind == Expand; }
 109
 110     // Coerce accessors
 111     const llvm::Type *getCoerceToType() const {
 112       assert(TheKind == Coerce && "Invalid kind!");
 113       return TypeData;
 114     }
 115
 116     // ByVal accessors
 117     unsigned getIndirectAlign() const {
 118       assert(TheKind == Indirect && "Invalid kind!");
 119       return UIntData;
 120     }
 121
 122     void dump() const;
 123   };
 124
 125   /// ABIInfo - Target specific hooks for defining how a type should be
 126   /// passed or returned from functions.
 127   class ABIInfo {
 128   public:
 129     virtual ~ABIInfo();
 130
 131     virtual void computeInfo(CodeGen::CGFunctionInfo &FI,
 132                              ASTContext &Ctx,
 133                              llvm::LLVMContext &VMContext) const = 0;
 134
 135     /// EmitVAArg - Emit the target dependent code to load a value of
 136     /// \arg Ty from the va_list pointed to by \arg VAListAddr.
 137
 138     // FIXME: This is a gaping layering violation if we wanted to drop
 139     // the ABI information any lower than CodeGen. Of course, for
 140     // VAArg handling it has to be at this level; there is no way to
 141     // abstract this out.
 142     virtual llvm::Value *EmitVAArg(llvm::Value *VAListAddr, QualType Ty,
 143                                    CodeGen::CodeGenFunction &CGF) const = 0;
 144   };
 145 }  // end namespace clang
 146
 147 #endif