|
0
|
1 /* v850 specific, C compiler specific functions.
|
|
|
2 Copyright (C) 2000, 2007 Free Software Foundation, Inc.
|
|
|
3 Contributed by Jeff Law (law@cygnus.com).
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify
|
|
|
8 it under the terms of the GNU General Public License as published by
|
|
|
9 the Free Software Foundation; either version 3, or (at your option)
|
|
|
10 any later version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful,
|
|
|
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
15 GNU General Public License for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "tm.h"
|
|
|
25 #include "cpplib.h"
|
|
|
26 #include "tree.h"
|
|
|
27 #include "c-pragma.h"
|
|
|
28 #include "toplev.h"
|
|
|
29 #include "ggc.h"
|
|
|
30 #include "tm_p.h"
|
|
|
31
|
|
|
32 #ifndef streq
|
|
|
33 #define streq(a,b) (strcmp (a, b) == 0)
|
|
|
34 #endif
|
|
|
35
|
|
|
36 static int pop_data_area (v850_data_area);
|
|
|
37 static int push_data_area (v850_data_area);
|
|
|
38 static void mark_current_function_as_interrupt (void);
|
|
|
39
|
|
|
40 /* Push a data area onto the stack. */
|
|
|
41
|
|
|
42 static int
|
|
|
43 push_data_area (v850_data_area data_area)
|
|
|
44 {
|
|
|
45 data_area_stack_element * elem;
|
|
|
46
|
|
|
47 elem = (data_area_stack_element *) xmalloc (sizeof (* elem));
|
|
|
48
|
|
|
49 if (elem == NULL)
|
|
|
50 return 0;
|
|
|
51
|
|
|
52 elem->prev = data_area_stack;
|
|
|
53 elem->data_area = data_area;
|
|
|
54
|
|
|
55 data_area_stack = elem;
|
|
|
56
|
|
|
57 return 1;
|
|
|
58 }
|
|
|
59
|
|
|
60 /* Remove a data area from the stack. */
|
|
|
61
|
|
|
62 static int
|
|
|
63 pop_data_area (v850_data_area data_area)
|
|
|
64 {
|
|
|
65 if (data_area_stack == NULL)
|
|
|
66 warning (OPT_Wpragmas, "#pragma GHS endXXXX found without "
|
|
|
67 "previous startXXX");
|
|
|
68 else if (data_area != data_area_stack->data_area)
|
|
|
69 warning (OPT_Wpragmas, "#pragma GHS endXXX does not match "
|
|
|
70 "previous startXXX");
|
|
|
71 else
|
|
|
72 {
|
|
|
73 data_area_stack_element * elem;
|
|
|
74
|
|
|
75 elem = data_area_stack;
|
|
|
76 data_area_stack = data_area_stack->prev;
|
|
|
77
|
|
|
78 free (elem);
|
|
|
79
|
|
|
80 return 1;
|
|
|
81 }
|
|
|
82
|
|
|
83 return 0;
|
|
|
84 }
|
|
|
85
|
|
|
86 /* Set the machine specific 'interrupt' attribute on the current function. */
|
|
|
87
|
|
|
88 static void
|
|
|
89 mark_current_function_as_interrupt (void)
|
|
|
90 {
|
|
|
91 tree name;
|
|
|
92
|
|
|
93 if (current_function_decl == NULL_TREE)
|
|
|
94 {
|
|
|
95 warning (0, "cannot set interrupt attribute: no current function");
|
|
|
96 return;
|
|
|
97 }
|
|
|
98
|
|
|
99 name = get_identifier ("interrupt");
|
|
|
100
|
|
|
101 if (name == NULL_TREE || TREE_CODE (name) != IDENTIFIER_NODE)
|
|
|
102 {
|
|
|
103 warning (0, "cannot set interrupt attribute: no such identifier");
|
|
|
104 return;
|
|
|
105 }
|
|
|
106
|
|
|
107 decl_attributes (¤t_function_decl,
|
|
|
108 tree_cons (name, NULL_TREE, NULL_TREE), 0);
|
|
|
109 }
|
|
|
110
|
|
|
111
|
|
|
112 /* Support for GHS pragmata. */
|
|
|
113
|
|
|
114 void
|
|
|
115 ghs_pragma_section (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
116 {
|
|
|
117 int repeat;
|
|
|
118
|
|
|
119 /* #pragma ghs section [name = alias [, name = alias [, ...]]] */
|
|
|
120 do
|
|
|
121 {
|
|
|
122 tree x;
|
|
|
123 enum cpp_ttype type;
|
|
|
124 const char *sect, *alias;
|
|
|
125 enum GHS_section_kind kind;
|
|
|
126
|
|
|
127 type = pragma_lex (&x);
|
|
|
128
|
|
|
129 if (type == CPP_EOF && !repeat)
|
|
|
130 goto reset;
|
|
|
131 else if (type == CPP_NAME)
|
|
|
132 sect = IDENTIFIER_POINTER (x);
|
|
|
133 else
|
|
|
134 goto bad;
|
|
|
135 repeat = 0;
|
|
|
136
|
|
|
137 if (pragma_lex (&x) != CPP_EQ)
|
|
|
138 goto bad;
|
|
|
139 if (pragma_lex (&x) != CPP_NAME)
|
|
|
140 goto bad;
|
|
|
141
|
|
|
142 alias = IDENTIFIER_POINTER (x);
|
|
|
143
|
|
|
144 type = pragma_lex (&x);
|
|
|
145 if (type == CPP_COMMA)
|
|
|
146 repeat = 1;
|
|
|
147 else if (type != CPP_EOF)
|
|
|
148 warning (OPT_Wpragmas, "junk at end of #pragma ghs section");
|
|
|
149
|
|
|
150 if (streq (sect, "data")) kind = GHS_SECTION_KIND_DATA;
|
|
|
151 else if (streq (sect, "text")) kind = GHS_SECTION_KIND_TEXT;
|
|
|
152 else if (streq (sect, "rodata")) kind = GHS_SECTION_KIND_RODATA;
|
|
|
153 else if (streq (sect, "const")) kind = GHS_SECTION_KIND_RODATA;
|
|
|
154 else if (streq (sect, "rosdata")) kind = GHS_SECTION_KIND_ROSDATA;
|
|
|
155 else if (streq (sect, "rozdata")) kind = GHS_SECTION_KIND_ROZDATA;
|
|
|
156 else if (streq (sect, "sdata")) kind = GHS_SECTION_KIND_SDATA;
|
|
|
157 else if (streq (sect, "tdata")) kind = GHS_SECTION_KIND_TDATA;
|
|
|
158 else if (streq (sect, "zdata")) kind = GHS_SECTION_KIND_ZDATA;
|
|
|
159 /* According to GHS beta documentation, the following should not be
|
|
|
160 allowed! */
|
|
|
161 else if (streq (sect, "bss")) kind = GHS_SECTION_KIND_BSS;
|
|
|
162 else if (streq (sect, "zbss")) kind = GHS_SECTION_KIND_ZDATA;
|
|
|
163 else
|
|
|
164 {
|
|
|
165 warning (0, "unrecognized section name \"%s\"", sect);
|
|
|
166 return;
|
|
|
167 }
|
|
|
168
|
|
|
169 if (streq (alias, "default"))
|
|
|
170 GHS_current_section_names [kind] = NULL;
|
|
|
171 else
|
|
|
172 GHS_current_section_names [kind] =
|
|
|
173 build_string (strlen (alias) + 1, alias);
|
|
|
174 }
|
|
|
175 while (repeat);
|
|
|
176
|
|
|
177 return;
|
|
|
178
|
|
|
179 bad:
|
|
|
180 warning (OPT_Wpragmas, "malformed #pragma ghs section");
|
|
|
181 return;
|
|
|
182
|
|
|
183 reset:
|
|
|
184 /* #pragma ghs section \n: Reset all section names back to their defaults. */
|
|
|
185 {
|
|
|
186 int i;
|
|
|
187
|
|
|
188 for (i = COUNT_OF_GHS_SECTION_KINDS; i--;)
|
|
|
189 GHS_current_section_names [i] = NULL;
|
|
|
190 }
|
|
|
191 }
|
|
|
192
|
|
|
193 void
|
|
|
194 ghs_pragma_interrupt (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
195 {
|
|
|
196 tree x;
|
|
|
197
|
|
|
198 if (pragma_lex (&x) != CPP_EOF)
|
|
|
199 warning (OPT_Wpragmas, "junk at end of #pragma ghs interrupt");
|
|
|
200
|
|
|
201 mark_current_function_as_interrupt ();
|
|
|
202 }
|
|
|
203
|
|
|
204 void
|
|
|
205 ghs_pragma_starttda (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
206 {
|
|
|
207 tree x;
|
|
|
208
|
|
|
209 if (pragma_lex (&x) != CPP_EOF)
|
|
|
210 warning (OPT_Wpragmas, "junk at end of #pragma ghs starttda");
|
|
|
211
|
|
|
212 push_data_area (DATA_AREA_TDA);
|
|
|
213 }
|
|
|
214
|
|
|
215 void
|
|
|
216 ghs_pragma_startsda (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
217 {
|
|
|
218 tree x;
|
|
|
219
|
|
|
220 if (pragma_lex (&x) != CPP_EOF)
|
|
|
221 warning (OPT_Wpragmas, "junk at end of #pragma ghs startsda");
|
|
|
222
|
|
|
223 push_data_area (DATA_AREA_SDA);
|
|
|
224 }
|
|
|
225
|
|
|
226 void
|
|
|
227 ghs_pragma_startzda (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
228 {
|
|
|
229 tree x;
|
|
|
230
|
|
|
231 if (pragma_lex (&x) != CPP_EOF)
|
|
|
232 warning (OPT_Wpragmas, "junk at end of #pragma ghs startzda");
|
|
|
233
|
|
|
234 push_data_area (DATA_AREA_ZDA);
|
|
|
235 }
|
|
|
236
|
|
|
237 void
|
|
|
238 ghs_pragma_endtda (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
239 {
|
|
|
240 tree x;
|
|
|
241
|
|
|
242 if (pragma_lex (&x) != CPP_EOF)
|
|
|
243 warning (OPT_Wpragmas, "junk at end of #pragma ghs endtda");
|
|
|
244
|
|
|
245 pop_data_area (DATA_AREA_TDA);
|
|
|
246 }
|
|
|
247
|
|
|
248 void
|
|
|
249 ghs_pragma_endsda (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
250 {
|
|
|
251 tree x;
|
|
|
252
|
|
|
253 if (pragma_lex (&x) != CPP_EOF)
|
|
|
254 warning (OPT_Wpragmas, "junk at end of #pragma ghs endsda");
|
|
|
255
|
|
|
256 pop_data_area (DATA_AREA_SDA);
|
|
|
257 }
|
|
|
258
|
|
|
259 void
|
|
|
260 ghs_pragma_endzda (cpp_reader * pfile ATTRIBUTE_UNUSED)
|
|
|
261 {
|
|
|
262 tree x;
|
|
|
263
|
|
|
264 if (pragma_lex (&x) != CPP_EOF)
|
|
|
265 warning (OPT_Wpragmas, "junk at end of #pragma ghs endzda");
|
|
|
266
|
|
|
267 pop_data_area (DATA_AREA_ZDA);
|
|
|
268 }
|
