OSDN Git Service

compiler: Use backend interface for type sizes and alignments.
[pf3gnuchains/gcc-fork.git] / gcc / go / go-backend.c
1 /* go-backend.c -- Go frontend interface to gcc backend.
2    Copyright (C) 2010, 2011, 2012 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "simple-object.h"
24 #include "tm.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "tm_p.h"
28 #include "intl.h"
29 #include "output.h"
30 #include "target.h"
31 #include "common/common-target.h"
32
33 #include "go-c.h"
34
35 /* The segment name we pass to simple_object_start_read to find Go
36    export data.  */
37
38 #ifndef GO_EXPORT_SEGMENT_NAME
39 #define GO_EXPORT_SEGMENT_NAME "__GNU_GO"
40 #endif
41
42 /* The section name we use when reading and writing export data.  */
43
44 #ifndef GO_EXPORT_SECTION_NAME
45 #define GO_EXPORT_SECTION_NAME ".go_export"
46 #endif
47
48 /* This file holds all the cases where the Go frontend needs
49    information from gcc's backend.  */
50
51 /* Return the alignment in bytes of a struct field of type T.  */
52
53 unsigned int
54 go_field_alignment (tree t)
55 {
56   unsigned int v;
57
58   v = TYPE_ALIGN (t);
59
60 #ifdef BIGGEST_FIELD_ALIGNMENT
61   if (v > BIGGEST_FIELD_ALIGNMENT)
62     v = BIGGEST_FIELD_ALIGNMENT;
63 #endif
64
65 #ifdef ADJUST_FIELD_ALIGN
66   {
67     tree field ATTRIBUTE_UNUSED;
68     field = build_decl (UNKNOWN_LOCATION, FIELD_DECL, NULL, t);
69     v = ADJUST_FIELD_ALIGN (field, v);
70   }
71 #endif
72
73   return v / BITS_PER_UNIT;
74 }
75
76 /* Return the size and alignment of a trampoline.  */
77
78 void
79 go_trampoline_info (unsigned int *size, unsigned int *alignment)
80 {
81   *size = TRAMPOLINE_SIZE;
82   *alignment = TRAMPOLINE_ALIGNMENT;
83 }
84
85 /* This is called by the Go frontend proper if the unsafe package was
86    imported.  When that happens we can not do type-based alias
87    analysis.  */
88
89 void
90 go_imported_unsafe (void)
91 {
92   flag_strict_aliasing = false;
93
94   /* This is a real hack.  init_varasm_once has already grabbed an
95      alias set, which we don't want when we aren't doing strict
96      aliasing.  We reinitialize to make it do it again.  This should
97      be OK in practice since we haven't really done anything yet.  */
98   init_varasm_once ();
99
100   /* Let the backend know that the options have changed.  */
101   targetm.override_options_after_change ();
102 }
103
104 /* This is called by the Go frontend proper to add data to the
105    section containing Go export data.  */
106
107 void
108 go_write_export_data (const char *bytes, unsigned int size)
109 {
110   static section* sec;
111
112   if (sec == NULL)
113     {
114       gcc_assert (targetm_common.have_named_sections);
115       sec = get_section (GO_EXPORT_SECTION_NAME, SECTION_DEBUG, NULL);
116     }
117
118   switch_to_section (sec);
119   assemble_string (bytes, size);
120 }
121
122 /* The go_read_export_data function is called by the Go frontend
123    proper to read Go export data from an object file.  FD is a file
124    descriptor open for reading.  OFFSET is the offset within the file
125    where the object file starts; this will be 0 except when reading an
126    archive.  On success this returns NULL and sets *PBUF to a buffer
127    allocated using malloc, of size *PLEN, holding the export data.  If
128    the data is not found, this returns NULL and sets *PBUF to NULL and
129    *PLEN to 0.  If some error occurs, this returns an error message
130    and sets *PERR to an errno value or 0 if there is no relevant
131    errno.  */
132
133 const char *
134 go_read_export_data (int fd, off_t offset, char **pbuf, size_t *plen,
135                      int *perr)
136 {
137   simple_object_read *sobj;
138   const char *errmsg;
139   off_t sec_offset;
140   off_t sec_length;
141   int found;
142   char *buf;
143   ssize_t c;
144
145   *pbuf = NULL;
146   *plen = 0;
147
148   sobj = simple_object_start_read (fd, offset, GO_EXPORT_SEGMENT_NAME,
149                                    &errmsg, perr);
150   if (sobj == NULL)
151     {
152       /* If we get an error here, just pretend that we didn't find any
153          export data.  This is the right thing to do if the error is
154          that the file was not recognized as an object file.  This
155          will ignore file I/O errors, but it's not too big a deal
156          because we will wind up giving some other error later.  */
157       return NULL;
158     }
159
160   found = simple_object_find_section (sobj, GO_EXPORT_SECTION_NAME,
161                                       &sec_offset, &sec_length,
162                                       &errmsg, perr);
163   simple_object_release_read (sobj);
164   if (!found)
165     return errmsg;
166
167   if (lseek (fd, offset + sec_offset, SEEK_SET) < 0)
168     {
169       *perr = errno;
170       return _("lseek failed while reading export data");
171     }
172
173   buf = XNEWVEC (char, sec_length);
174   if (buf == NULL)
175     {
176       *perr = errno;
177       return _("memory allocation failed while reading export data");
178     }
179
180   c = read (fd, buf, sec_length);
181   if (c < 0)
182     {
183       *perr = errno;
184       free (buf);
185       return _("read failed while reading export data");
186     }
187
188   if (c < sec_length)
189     {
190       free (buf);
191       return _("short read while reading export data");
192     }
193
194   *pbuf = buf;
195   *plen = sec_length;
196
197   return NULL;
198 }