URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [gcc/] [config/] [v850/] [v850-c.c] - Blame information for rev 783

Details | Compare with Previous | View Log


/* v850 specific, C compiler specific functions.
   Copyright (C) 2000, 2001, 2002, 2003, 2005, 2007, 2009, 2010
   Free Software Foundation, Inc.
   Contributed by Jeff Law (law@cygnus.com).
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
 
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "cpplib.h"
#include "tree.h"
#include "c-family/c-pragma.h"
#include "diagnostic-core.h"
#include "ggc.h"
#include "tm_p.h"
 
#ifndef streq
#define streq(a,b) (strcmp (a, b) == 0)
#endif
 
static int  pop_data_area          (v850_data_area);
static int  push_data_area         (v850_data_area);
static void mark_current_function_as_interrupt (void);
 
/* Push a data area onto the stack.  */
 
static int
push_data_area (v850_data_area data_area)
{
  data_area_stack_element * elem;
 
  elem = (data_area_stack_element *) xmalloc (sizeof (* elem));
 
  if (elem == NULL)
    return 0;
 
  elem->prev      = data_area_stack;
  elem->data_area = data_area;
 
  data_area_stack = elem;
 
  return 1;
}
 
/* Remove a data area from the stack.  */
 
static int
pop_data_area (v850_data_area data_area)
{
  if (data_area_stack == NULL)
    warning (OPT_Wpragmas, "#pragma GHS endXXXX found without "
             "previous startXXX");
  else if (data_area != data_area_stack->data_area)
    warning (OPT_Wpragmas, "#pragma GHS endXXX does not match "
             "previous startXXX");
  else
    {
      data_area_stack_element * elem;
 
      elem = data_area_stack;
      data_area_stack = data_area_stack->prev;
 
      free (elem);
 
      return 1;
    }
 
  return 0;
}
 
/* Set the machine specific 'interrupt' attribute on the current function.  */
 
static void
mark_current_function_as_interrupt (void)
{
  tree name;
 
  if (current_function_decl ==  NULL_TREE)
    {
      warning (0, "cannot set interrupt attribute: no current function");
      return;
    }
 
  name = get_identifier ("interrupt");
 
  if (name == NULL_TREE || TREE_CODE (name) != IDENTIFIER_NODE)
    {
      warning (0, "cannot set interrupt attribute: no such identifier");
      return;
    }
 
  decl_attributes (&current_function_decl,
                   tree_cons (name, NULL_TREE, NULL_TREE), 0);
}
 
 
/* Support for GHS pragmata.  */
 
void
ghs_pragma_section (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  int repeat = 0;
 
  /* #pragma ghs section [name = alias [, name = alias [, ...]]] */
  do
    {
      tree x;
      enum cpp_ttype type;
      tree sect_ident;
      const char *sect, *alias;
      enum GHS_section_kind kind;
 
      type = pragma_lex (&x);
 
      if (type == CPP_EOF && !repeat)
        goto reset;
      else if (type == CPP_NAME)
        {
          sect_ident = x;
          sect = IDENTIFIER_POINTER (sect_ident);
        }
      else
        goto bad;
      repeat = 0;
 
      if (pragma_lex (&x) != CPP_EQ)
        goto bad;
      if (pragma_lex (&x) != CPP_NAME)
        goto bad;
 
      alias = IDENTIFIER_POINTER (x);
 
      type = pragma_lex (&x);
      if (type == CPP_COMMA)
        repeat = 1;
      else if (type != CPP_EOF)
        warning (OPT_Wpragmas, "junk at end of #pragma ghs section");
 
      if      (streq (sect, "data"))    kind = GHS_SECTION_KIND_DATA;
      else if (streq (sect, "text"))    kind = GHS_SECTION_KIND_TEXT;
      else if (streq (sect, "rodata"))  kind = GHS_SECTION_KIND_RODATA;
      else if (streq (sect, "const"))   kind = GHS_SECTION_KIND_RODATA;
      else if (streq (sect, "rosdata")) kind = GHS_SECTION_KIND_ROSDATA;
      else if (streq (sect, "rozdata")) kind = GHS_SECTION_KIND_ROZDATA;
      else if (streq (sect, "sdata"))   kind = GHS_SECTION_KIND_SDATA;
      else if (streq (sect, "tdata"))   kind = GHS_SECTION_KIND_TDATA;
      else if (streq (sect, "zdata"))   kind = GHS_SECTION_KIND_ZDATA;
      /* According to GHS beta documentation, the following should not be
         allowed!  */
      else if (streq (sect, "bss"))     kind = GHS_SECTION_KIND_BSS;
      else if (streq (sect, "zbss"))    kind = GHS_SECTION_KIND_ZDATA;
      else
        {
          warning (0, "unrecognized section name %qE", sect_ident);
          return;
        }
 
      if (streq (alias, "default"))
        GHS_current_section_names [kind] = NULL;
      else
        GHS_current_section_names [kind] =
          build_string (strlen (alias) + 1, alias);
    }
  while (repeat);
 
  return;
 
 bad:
  warning (OPT_Wpragmas, "malformed #pragma ghs section");
  return;
 
 reset:
  /* #pragma ghs section \n: Reset all section names back to their defaults.  */
  {
    int i;
 
    for (i = COUNT_OF_GHS_SECTION_KINDS; i--;)
      GHS_current_section_names [i] = NULL;
  }
}
 
void
ghs_pragma_interrupt (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs interrupt");
 
  mark_current_function_as_interrupt ();
}
 
void
ghs_pragma_starttda (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs starttda");
 
  push_data_area (DATA_AREA_TDA);
}
 
void
ghs_pragma_startsda (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs startsda");
 
  push_data_area (DATA_AREA_SDA);
}
 
void
ghs_pragma_startzda (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs startzda");
 
  push_data_area (DATA_AREA_ZDA);
}
 
void
ghs_pragma_endtda (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs endtda");
 
  pop_data_area (DATA_AREA_TDA);
}
 
void
ghs_pragma_endsda (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs endsda");
 
  pop_data_area (DATA_AREA_SDA);
}
 
void
ghs_pragma_endzda (cpp_reader * pfile ATTRIBUTE_UNUSED)
{
  tree x;
 
  if (pragma_lex (&x) != CPP_EOF)
    warning (OPT_Wpragmas, "junk at end of #pragma ghs endzda");
 
  pop_data_area (DATA_AREA_ZDA);
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [gcc/] [config/] [v850/] [v850-c.c] - Blame information for rev 783

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