1/* Function return value location for Linux/PPC ABI.
2   Copyright (C) 2005, 2006, 2007, 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 ppc_
34#include "libebl_CPU.h"
35
36
37/* This is the SVR4 ELF ABI convention, but AIX and Linux do not use it.  */
38#define SVR4_STRUCT_RETURN 0
39
40
41/* r3, or pair r3, r4, or quad r3-r6.  */
42static const Dwarf_Op loc_intreg[] =
43  {
44    { .atom = DW_OP_reg3 }, { .atom = DW_OP_piece, .number = 4 },
45    { .atom = DW_OP_reg4 }, { .atom = DW_OP_piece, .number = 4 },
46    { .atom = DW_OP_reg5 }, { .atom = DW_OP_piece, .number = 4 },
47    { .atom = DW_OP_reg6 }, { .atom = DW_OP_piece, .number = 4 },
48  };
49#define nloc_intreg	1
50#define nloc_intregpair	4
51#define nloc_intregquad	8
52
53/* f1.  */
54static const Dwarf_Op loc_fpreg[] =
55  {
56    { .atom = DW_OP_regx, .number = 33 }
57  };
58#define nloc_fpreg	1
59
60/* vr2.  */
61static const Dwarf_Op loc_vmxreg[] =
62  {
63    { .atom = DW_OP_regx, .number = 1124 + 2 }
64  };
65#define nloc_vmxreg	1
66
67/* The return value is a structure and is actually stored in stack space
68   passed in a hidden argument by the caller.  But, the compiler
69   helpfully returns the address of that space in r3.  */
70static const Dwarf_Op loc_aggregate[] =
71  {
72    { .atom = DW_OP_breg3, .number = 0 }
73  };
74#define nloc_aggregate 1
75
76
77/* XXX We should check the SHT_GNU_ATTRIBUTES bits here (or in ppc_init).  */
78static bool
79ppc_altivec_abi (void)
80{
81  return true;
82}
83
84int
85ppc_return_value_location (Dwarf_Die *functypedie, const Dwarf_Op **locp)
86{
87  /* Start with the function's type, and get the DW_AT_type attribute,
88     which is the type of the return value.  */
89
90  Dwarf_Attribute attr_mem;
91  Dwarf_Attribute *attr = dwarf_attr_integrate (functypedie, DW_AT_type,
92						&attr_mem);
93  if (attr == NULL)
94    /* The function has no return value, like a `void' function in C.  */
95    return 0;
96
97  Dwarf_Die die_mem;
98  Dwarf_Die *typedie = dwarf_formref_die (attr, &die_mem);
99  int tag = dwarf_tag (typedie);
100
101  /* Follow typedefs and qualifiers to get to the actual type.  */
102  while (tag == DW_TAG_typedef
103	 || tag == DW_TAG_const_type || tag == DW_TAG_volatile_type
104	 || tag == DW_TAG_restrict_type || tag == DW_TAG_mutable_type)
105    {
106      attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
107      typedie = dwarf_formref_die (attr, &die_mem);
108      tag = dwarf_tag (typedie);
109    }
110
111  Dwarf_Word size;
112  switch (tag)
113    {
114    case -1:
115      return -1;
116
117    case DW_TAG_subrange_type:
118      if (! dwarf_hasattr_integrate (typedie, DW_AT_byte_size))
119	{
120	  attr = dwarf_attr_integrate (typedie, DW_AT_type, &attr_mem);
121	  typedie = dwarf_formref_die (attr, &die_mem);
122	  tag = dwarf_tag (typedie);
123	}
124      /* Fall through.  */
125
126    case DW_TAG_base_type:
127    case DW_TAG_enumeration_type:
128    case DW_TAG_pointer_type:
129    case DW_TAG_ptr_to_member_type:
130      if (dwarf_formudata (dwarf_attr_integrate (typedie, DW_AT_byte_size,
131						 &attr_mem), &size) != 0)
132	{
133	  if (tag == DW_TAG_pointer_type || tag == DW_TAG_ptr_to_member_type)
134	    size = 4;
135	  else
136	    return -1;
137	}
138      if (size <= 8)
139	{
140	  if (tag == DW_TAG_base_type)
141	    {
142	      Dwarf_Word encoding;
143	      if (dwarf_formudata (dwarf_attr_integrate (typedie,
144							 DW_AT_encoding,
145							 &attr_mem),
146				   &encoding) != 0)
147		return -1;
148	      if (encoding == DW_ATE_float)
149		{
150		  *locp = loc_fpreg;
151		  return nloc_fpreg;
152		}
153	    }
154	intreg:
155	  *locp = loc_intreg;
156	  return size <= 4 ? nloc_intreg : nloc_intregpair;
157	}
158
159    aggregate:
160      *locp = loc_aggregate;
161      return nloc_aggregate;
162
163    case DW_TAG_array_type:
164      {
165	bool is_vector;
166	if (dwarf_formflag (dwarf_attr_integrate (typedie, DW_AT_GNU_vector,
167						  &attr_mem), &is_vector) == 0
168	    && is_vector
169	    && dwarf_aggregate_size (typedie, &size) == 0)
170	  switch (size)
171	    {
172	    case 16:
173	      if (ppc_altivec_abi ())
174		{
175		  *locp = loc_vmxreg;
176		  return nloc_vmxreg;
177		}
178	      *locp = loc_intreg;
179	      return nloc_intregquad;
180	    }
181      }
182      /* Fall through.  */
183
184    case DW_TAG_structure_type:
185    case DW_TAG_class_type:
186    case DW_TAG_union_type:
187      if (SVR4_STRUCT_RETURN
188	  && dwarf_aggregate_size (typedie, &size) == 0
189	  && size > 0 && size <= 8)
190	goto intreg;
191      goto aggregate;
192    }
193
194  /* XXX We don't have a good way to return specific errors from ebl calls.
195     This value means we do not understand the type, but it is well-formed
196     DWARF and might be valid.  */
197  return -2;
198}
199