nsz Git - libfirm/blob - ir/be/arm/arm_cconv.c

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   calling convention helpers
  23  * @author  Matthias Braun
  24  */
  25 #include "config.h"
  26
  27 #include "arm_cconv.h"
  28 #include "irmode.h"
  29 #include "typerep.h"
  30 #include "xmalloc.h"
  31 #include "error.h"
  32 #include "util.h"
  33
  34 static const unsigned ignore_regs[] = {
  35         REG_R12,
  36         REG_SP,
  37         REG_PC,
  38         REG_FL,
  39 };
  40
  41 static const arch_register_t* const param_regs[] = {
  42         &arm_registers[REG_R0],
  43         &arm_registers[REG_R1],
  44         &arm_registers[REG_R2],
  45         &arm_registers[REG_R3]
  46 };
  47
  48 static const arch_register_t* const result_regs[] = {
  49         &arm_registers[REG_R0],
  50         &arm_registers[REG_R1],
  51         &arm_registers[REG_R2],
  52         &arm_registers[REG_R3]
  53 };
  54
  55 static const arch_register_t* const float_result_regs[] = {
  56         &arm_registers[REG_F0],
  57         &arm_registers[REG_F1]
  58 };
  59
  60 calling_convention_t *arm_decide_calling_convention(const ir_graph *irg,
  61                                                     ir_type *function_type)
  62 {
  63         unsigned              stack_offset      = 0;
  64         unsigned              n_param_regs_used = 0;
  65         reg_or_stackslot_t   *params;
  66         reg_or_stackslot_t   *results;
  67         size_t const          n_param_regs        = ARRAY_SIZE(param_regs);
  68         size_t const          n_result_regs       = ARRAY_SIZE(result_regs);
  69         size_t const          n_float_result_regs = ARRAY_SIZE(float_result_regs);
  70         size_t                n_params;
  71         size_t                n_results;
  72         size_t                i;
  73         size_t                regnum;
  74         size_t                float_regnum;
  75         calling_convention_t *cconv;
  76
  77         /* determine how parameters are passed */
  78         n_params = get_method_n_params(function_type);
  79         regnum   = 0;
  80         params   = XMALLOCNZ(reg_or_stackslot_t, n_params);
  81
  82         for (i = 0; i < n_params; ++i) {
  83                 ir_type            *param_type = get_method_param_type(function_type,i);
  84                 ir_mode            *mode       = get_type_mode(param_type);
  85                 int                 bits       = get_mode_size_bits(mode);
  86                 reg_or_stackslot_t *param      = &params[i];
  87                 param->type = param_type;
  88
  89                 if (regnum < n_param_regs) {
  90                         const arch_register_t *reg = param_regs[regnum++];
  91                         param->reg0 = reg;
  92                 } else {
  93                         param->offset = stack_offset;
  94                         /* increase offset 4 bytes so everything is aligned */
  95                         stack_offset += bits > 32 ? bits/8 : 4;
  96                         continue;
  97                 }
  98
  99                 /* we might need a 2nd 32bit component (for 64bit or double values) */
 100                 if (bits > 32) {
 101                         if (bits > 64)
 102                                 panic("only 32 and 64bit modes supported");
 103
 104                         if (regnum < n_param_regs) {
 105                                 const arch_register_t *reg = param_regs[regnum++];
 106                                 param->reg1 = reg;
 107                         } else {
 108                                 ir_mode *pmode = param_regs[0]->reg_class->mode;
 109                                 ir_type *type  = get_type_for_mode(pmode);
 110                                 param->type    = type;
 111                                 param->offset  = stack_offset;
 112                                 assert(get_mode_size_bits(pmode) == 32);
 113                                 stack_offset += 4;
 114                         }
 115                 }
 116         }
 117         n_param_regs_used = regnum;
 118
 119         n_results    = get_method_n_ress(function_type);
 120         regnum       = 0;
 121         float_regnum = 0;
 122         results      = XMALLOCNZ(reg_or_stackslot_t, n_results);
 123         for (i = 0; i < n_results; ++i) {
 124                 ir_type            *result_type = get_method_res_type(function_type, i);
 125                 ir_mode            *result_mode = get_type_mode(result_type);
 126                 reg_or_stackslot_t *result      = &results[i];
 127
 128                 if (mode_is_float(result_mode)) {
 129                         if (float_regnum >= n_float_result_regs) {
 130                                 panic("Too many float results");
 131                         } else {
 132                                 const arch_register_t *reg = float_result_regs[float_regnum++];
 133                                 result->reg0 = reg;
 134                         }
 135                 } else {
 136                         if (get_mode_size_bits(result_mode) > 32) {
 137                                 panic("Results with more than 32bits not supported yet");
 138                         }
 139
 140                         if (regnum >= n_result_regs) {
 141                                 panic("Too many results");
 142                         } else {
 143                                 const arch_register_t *reg = result_regs[regnum++];
 144                                 result->reg0 = reg;
 145                         }
 146                 }
 147         }
 148
 149         cconv                   = XMALLOCZ(calling_convention_t);
 150         cconv->parameters       = params;
 151         cconv->param_stack_size = stack_offset;
 152         cconv->n_reg_params     = n_param_regs_used;
 153         cconv->results          = results;
 154
 155         /* setup allocatable registers */
 156         if (irg != NULL) {
 157                 be_irg_t       *birg      = be_birg_from_irg(irg);
 158                 size_t          n_ignores = ARRAY_SIZE(ignore_regs);
 159                 struct obstack *obst      = &birg->obst;
 160                 size_t          r;
 161
 162                 assert(birg->allocatable_regs == NULL);
 163                 birg->allocatable_regs = rbitset_obstack_alloc(obst, N_ARM_REGISTERS);
 164                 rbitset_set_all(birg->allocatable_regs, N_ARM_REGISTERS);
 165                 for (r = 0; r < n_ignores; ++r) {
 166                         rbitset_clear(birg->allocatable_regs, ignore_regs[r]);
 167                 }
 168         }
 169
 170         return cconv;
 171 }
 172
 173 void arm_free_calling_convention(calling_convention_t *cconv)
 174 {
 175         free(cconv->parameters);
 176         free(cconv->results);
 177         free(cconv);
 178 }