src/llvm/lib/Target/Hexagon/HexagonVarargsCallingConvention.h

   1 //===-- HexagonVarargsCallingConvention.h - Calling Conventions -*- 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 // This file declares the functions that assign locations to outgoing function
  11 // arguments. Adapted from the target independent version but this handles
  12 // calls to varargs functions
  13 //
  14 //===----------------------------------------------------------------------===//
  15 //
  16
  17
  18
  19
  20 static bool RetCC_Hexagon32_VarArgs(unsigned ValNo, EVT ValVT,
  21                                     EVT LocVT, CCValAssign::LocInfo LocInfo,
  22                                     ISD::ArgFlagsTy ArgFlags,
  23                                     Hexagon_CCState &State,
  24                                     int NonVarArgsParams,
  25                                     int CurrentParam,
  26                                     bool ForceMem);
  27
  28
  29 static bool CC_Hexagon32_VarArgs(unsigned ValNo, EVT ValVT,
  30                                  EVT LocVT, CCValAssign::LocInfo LocInfo,
  31                                  ISD::ArgFlagsTy ArgFlags,
  32                                  Hexagon_CCState &State,
  33                                  int NonVarArgsParams,
  34                                  int CurrentParam,
  35                                  bool ForceMem) {
  36   unsigned ByValSize = 0;
  37   if (ArgFlags.isByVal() &&
  38       ((ByValSize = ArgFlags.getByValSize()) >
  39        (MVT(MVT::i64).getSizeInBits() / 8))) {
  40     ForceMem = true;
  41   }
  42
  43
  44   // Only assign registers for named (non-varargs) arguments
  45   if ( !ForceMem && ((NonVarArgsParams == -1) || (CurrentParam <=
  46                                                   NonVarArgsParams))) {
  47
  48     if (LocVT == MVT::i32 ||
  49         LocVT == MVT::i16 ||
  50         LocVT == MVT::i8 ||
  51         LocVT == MVT::f32) {
  52       static const unsigned RegList1[] = {
  53         Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4,
  54         Hexagon::R5
  55       };
  56       if (unsigned Reg = State.AllocateReg(RegList1, 6)) {
  57         State.addLoc(CCValAssign::getReg(ValNo, ValVT.getSimpleVT(), Reg,
  58                                          LocVT.getSimpleVT(), LocInfo));
  59         return false;
  60       }
  61     }
  62
  63     if (LocVT == MVT::i64 ||
  64         LocVT == MVT::f64) {
  65       static const unsigned RegList2[] = {
  66         Hexagon::D0, Hexagon::D1, Hexagon::D2
  67       };
  68       if (unsigned Reg = State.AllocateReg(RegList2, 3)) {
  69         State.addLoc(CCValAssign::getReg(ValNo, ValVT.getSimpleVT(), Reg,
  70                                          LocVT.getSimpleVT(), LocInfo));
  71         return false;
  72       }
  73     }
  74   }
  75
  76   const Type* ArgTy = LocVT.getTypeForEVT(State.getContext());
  77   unsigned Alignment = State.getTarget()
  78                            .getSubtargetImpl()
  79                            ->getDataLayout()
  80                            ->getABITypeAlignment(ArgTy);
  81   unsigned Size =
  82       State.getTarget().getSubtargetImpl()->getDataLayout()->getTypeSizeInBits(
  83           ArgTy) /
  84       8;
  85
  86   // If it's passed by value, then we need the size of the aggregate not of
  87   // the pointer.
  88   if (ArgFlags.isByVal()) {
  89     Size = ByValSize;
  90
  91     // Hexagon_TODO: Get the alignment of the contained type here.
  92     Alignment = 8;
  93   }
  94
  95   unsigned Offset3 = State.AllocateStack(Size, Alignment);
  96   State.addLoc(CCValAssign::getMem(ValNo, ValVT.getSimpleVT(), Offset3,
  97                                    LocVT.getSimpleVT(), LocInfo));
  98   return false;
  99 }
 100
 101
 102 static bool RetCC_Hexagon32_VarArgs(unsigned ValNo, EVT ValVT,
 103                                     EVT LocVT, CCValAssign::LocInfo LocInfo,
 104                                     ISD::ArgFlagsTy ArgFlags,
 105                                     Hexagon_CCState &State,
 106                                     int NonVarArgsParams,
 107                                     int CurrentParam,
 108                                     bool ForceMem) {
 109
 110   if (LocVT == MVT::i32 ||
 111       LocVT == MVT::f32) {
 112     static const unsigned RegList1[] = {
 113       Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4,
 114       Hexagon::R5
 115     };
 116     if (unsigned Reg = State.AllocateReg(RegList1, 6)) {
 117       State.addLoc(CCValAssign::getReg(ValNo, ValVT.getSimpleVT(), Reg,
 118                                        LocVT.getSimpleVT(), LocInfo));
 119       return false;
 120     }
 121   }
 122
 123   if (LocVT == MVT::i64 ||
 124       LocVT == MVT::f64) {
 125     static const unsigned RegList2[] = {
 126       Hexagon::D0, Hexagon::D1, Hexagon::D2
 127     };
 128     if (unsigned Reg = State.AllocateReg(RegList2, 3)) {
 129       State.addLoc(CCValAssign::getReg(ValNo, ValVT.getSimpleVT(), Reg,
 130                                        LocVT.getSimpleVT(), LocInfo));
 131       return false;
 132     }
 133   }
 134
 135   const Type* ArgTy = LocVT.getTypeForEVT(State.getContext());
 136   unsigned Alignment = State.getTarget()
 137                            .getSubtargetImpl()
 138                            ->getDataLayout()
 139                            ->getABITypeAlignment(ArgTy);
 140   unsigned Size =
 141       State.getTarget().getSubtargetImpl()->getDataLayout()->getTypeSizeInBits(
 142           ArgTy) /
 143       8;
 144
 145   unsigned Offset3 = State.AllocateStack(Size, Alignment);
 146   State.addLoc(CCValAssign::getMem(ValNo, ValVT.getSimpleVT(), Offset3,
 147                                    LocVT.getSimpleVT(), LocInfo));
 148   return false;
 149 }