backends/x86_64_retval.c

   1 /* Function return value location for Linux/x86-64 ABI.
   2    Copyright (C) 2005-2010 Red Hat, Inc.
   3    This file is part of Red Hat elfutils.
   4
   5    Red Hat elfutils is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by the
   7    Free Software Foundation; version 2 of the License.
   8
   9    Red Hat elfutils is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with Red Hat elfutils; if not, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA.
  17
  18    Red Hat elfutils is an included package of the Open Invention Network.
  19    An included package of the Open Invention Network is a package for which
  20    Open Invention Network licensees cross-license their patents.  No patent
  21    license is granted, either expressly or impliedly, by designation as an
  22    included package.  Should you wish to participate in the Open Invention
  23    Network licensing program, please visit www.openinventionnetwork.com
  24    <http://www.openinventionnetwork.com>.  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include <config.h>
  28 #endif
  29
  30 #include <assert.h>
  31 #include <dwarf.h>
  32
  33 #define BACKEND x86_64_
  34 #include "libebl_CPU.h"
  35
  36
  37 /* %rax, or pair %rax, %rdx.  */
  38 static const Dwarf_Op loc_intreg[] =
  39   {
  40     { .atom = DW_OP_reg0 }, { .atom = DW_OP_piece, .number = 8 },
  41     { .atom = DW_OP_reg1 }, { .atom = DW_OP_piece, .number = 8 },
  42   };
  43 #define nloc_intreg     1
  44 #define nloc_intregpair 4
  45
  46 /* %st(0), or pair %st(0), %st(1).  */
  47 static const Dwarf_Op loc_x87reg[] =
  48   {
  49     { .atom = DW_OP_regx, .number = 33 },
  50     { .atom = DW_OP_piece, .number = 10 },
  51     { .atom = DW_OP_regx, .number = 34 },
  52     { .atom = DW_OP_piece, .number = 10 },
  53   };
  54 #define nloc_x87reg     1
  55 #define nloc_x87regpair 4
  56
  57 /* %xmm0, or pair %xmm0, %xmm1.  */
  58 static const Dwarf_Op loc_ssereg[] =
  59   {
  60     { .atom = DW_OP_reg17 }, { .atom = DW_OP_piece, .number = 16 },
  61     { .atom = DW_OP_reg18 }, { .atom = DW_OP_piece, .number = 16 },
  62   };
  63 #define nloc_ssereg     1
  64 #define nloc_sseregpair 4
  65
  66 /* The return value is a structure and is actually stored in stack space
  67    passed in a hidden argument by the caller.  But, the compiler
  68    helpfully returns the address of that space in %rax.  */
  69 static const Dwarf_Op loc_aggregate[] =
  70   {
  71     { .atom = DW_OP_breg0, .number = 0 }
  72   };
  73 #define nloc_aggregate 1
  74
  75
  76 int
  77 x86_64_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
  78 {
  79   /* Start with the function's type, and get the DW_AT_type attribute,
  80      which is the type of the return value.  */
  81
  82   Dwarf_Attribute attr_mem;
  83   Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
  84                                                 &attr_mem);
  85   if (attr == NULL)
  86     /* The function has no return value, like a `void' function in C.  */
  87     return 0;
  88
  89   Dwarf_Die die_mem;
  90   Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
  91   int tag = dwarf_tag (typedie);
  92
  93   /* Follow typedefs and qualifiers to get to the actual type.  */
  94   while (tag == DW_TAG_typedef
  95          || tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
  96          || tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
  97     {
  98       attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
  99       typedie = dwarf_formref_die (attr, &die_mem);
 100       tag = dwarf_tag (typedie);
 101     }
 102
 103   Dwarf_Word size;
 104   switch (tag)
 105     {
 106     case -1:
 107       return -1;
 108
 109     case DW_TAG_subrange_type:
 110       if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
 111         {
 112           attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
 113           typedie = dwarf_formref_die (attr, &die_mem);
 114           tag = dwarf_tag (typedie);
 115         }
 116       /* Fall through.  */
 117
 118     case DW_TAG_base_type:
 119     case DW_TAG_enumeration_type:
 120     case DW_TAG_pointer_type:
 121     case DW_TAG_ptr_to_member_type:
 122       if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
 123                                                  &attr_mem), &size) != 0)
 124         {
 125           if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
 126             size = 8;
 127           else
 128             return -1;
 129         }
 130       if (tag == DW_TAG_base_type)
 131         {
 132           Dwarf_Word encoding;
 133           if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_encoding,
 134                                                      &attr_mem),
 135                                &encoding) != 0)
 136             return -1;
 137
 138           switch (encoding)
 139             {
 140             case DW_ATE_complex_float:
 141               switch (size)
 142                 {
 143                 case 4 * 2:     /* complex float */
 144                 case 8 * 2:     /* complex double */
 145                   *locp = loc_ssereg;
 146                   return nloc_sseregpair;
 147                 case 16 * 2:    /* complex long double */
 148                   *locp = loc_x87reg;
 149                   return nloc_x87regpair;
 150                 }
 151               return -2;
 152
 153             case DW_ATE_float:
 154               switch (size)
 155                 {
 156                 case 4: /* float */
 157                 case 8: /* double */
 158                   *locp = loc_ssereg;
 159                   return nloc_ssereg;
 160                 case 16:        /* long double */
 161                   /* XXX distinguish __float128, which is sseregpair?? */
 162                   *locp = loc_x87reg;
 163                   return nloc_x87reg;
 164                 }
 165               return -2;
 166             }
 167         }
 168
 169     intreg:
 170       *locp = loc_intreg;
 171       if (size <= 8)
 172         return nloc_intreg;
 173       if (size <= 16)
 174         return nloc_intregpair;
 175
 176     large:
 177       *locp = loc_aggregate;
 178       return nloc_aggregate;
 179
 180     case DW_TAG_structure_type:
 181     case DW_TAG_class_type:
 182     case DW_TAG_union_type:
 183     case DW_TAG_array_type:
 184       if (dwarf_aggregate_size (typedie, &size) != 0)
 185         goto large;
 186       if (size > 16)
 187         goto large;
 188
 189       /* XXX
 190          Must examine the fields in picayune ways to determine the
 191          actual answer.  This will be right for small C structs
 192          containing integer types and similarly simple cases.
 193       */
 194
 195       goto intreg;
 196     }
 197
 198   /* XXX We don't have a good way to return specific errors from ebl calls.
 199      This value means we do not understand the type, but it is well-formed
 200      DWARF and might be valid.  */
 201   return -2;
 202 }