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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [config/] [sol2-c.c] - Blame information for rev 709

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 709 jeremybenn
/* Solaris support needed only by C/C++ frontends.
2
   Copyright (C) 2004, 2005, 2007, 2009, 2010, 2011
3
   Free Software Foundation, Inc.
4
   Contributed by CodeSourcery, LLC.
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 "tree.h"
26
#include "tm.h"
27
#include "tm_p.h"
28
 
29
#include "c-family/c-format.h"
30
#include "intl.h"
31
 
32
#include "cpplib.h"
33
#include "c-family/c-pragma.h"
34
#include "c-family/c-common.h"
35
 
36
/* cmn_err only accepts "l" and "ll".  */
37
static const format_length_info cmn_err_length_specs[] =
38
{
39
  { "l", FMT_LEN_l, STD_C89, "ll", FMT_LEN_ll, STD_C89, 0 },
40
  { NULL, FMT_LEN_none, STD_C89, NULL, FMT_LEN_none, STD_C89, 0 }
41
};
42
 
43
static const format_flag_spec cmn_err_flag_specs[] =
44
{
45
  { 'w',  0, 0, N_("field width"),     N_("field width in printf format"),     STD_C89 },
46
  { 'L',  0, 0, N_("length modifier"), N_("length modifier in printf format"), STD_C89 },
47
  { 0, 0, 0, NULL, NULL, STD_C89 }
48
};
49
 
50
 
51
static const format_flag_pair cmn_err_flag_pairs[] =
52
{
53
  { 0, 0, 0, 0 }
54
};
55
 
56
static const format_char_info bitfield_string_type =
57
  { "b",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "",   "cR", NULL };
58
 
59
static const format_char_info cmn_err_char_table[] =
60
{
61
  /* C89 conversion specifiers.  */
62
  { "dD",  0, STD_C89, { T89_I,   BADLEN,  BADLEN,  T89_L,   T9L_LL,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w",  "",   NULL },
63
  { "oOxX",0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w",  "",   NULL },
64
  { "u",   0, STD_C89, { T89_UI,  BADLEN,  BADLEN,  T89_UL,  T9L_ULL, BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w",  "",   NULL },
65
  { "c",   0, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w",  "",   NULL },
66
  { "p",   1, STD_C89, { T89_V,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w", "c",  NULL },
67
  { "s",   1, STD_C89, { T89_C,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w",  "cR", NULL },
68
  { "b",   0, STD_C89, { T89_I,   BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN,  BADLEN  }, "w",   "",   &bitfield_string_type },
69
  { NULL,  0, STD_C89, NOLENGTHS, NULL, NULL, NULL }
70
};
71
 
72
EXPORTED_CONST format_kind_info solaris_format_types[] = {
73
  { "cmn_err",  cmn_err_length_specs,  cmn_err_char_table, "", NULL,
74
    cmn_err_flag_specs, cmn_err_flag_pairs,
75
    FMT_FLAG_ARG_CONVERT|FMT_FLAG_EMPTY_PREC_OK,
76
    'w', 0, 0, 0, 'L', 0,
77
    &integer_type_node, &integer_type_node
78
  }
79
};
80
 
81
/* Handle #pragma align ALIGNMENT (VAR [, VAR]...)  */
82
 
83
static void
84
solaris_pragma_align (cpp_reader *pfile ATTRIBUTE_UNUSED)
85
{
86
  tree t, x;
87
  enum cpp_ttype ttype;
88
  HOST_WIDE_INT low;
89
 
90
  if (pragma_lex (&x) != CPP_NUMBER
91
      || pragma_lex (&t) != CPP_OPEN_PAREN)
92
    {
93
      warning (0, "malformed %<#pragma align%>, ignoring");
94
      return;
95
    }
96
 
97
  low = TREE_INT_CST_LOW (x);
98
  if (TREE_INT_CST_HIGH (x) != 0
99
      || (low != 1 && low != 2 && low != 4 && low != 8 && low != 16
100
          && low != 32 && low != 64 && low != 128))
101
    {
102
      warning (0, "invalid alignment for %<#pragma align%>, ignoring");
103
      return;
104
    }
105
 
106
  ttype = pragma_lex (&t);
107
  if (ttype != CPP_NAME)
108
    {
109
      warning (0, "malformed %<#pragma align%>, ignoring");
110
      return;
111
    }
112
 
113
  while (1)
114
    {
115
      tree decl = identifier_global_value (t);
116
      if (decl && DECL_P (decl))
117
        warning (0, "%<#pragma align%> must appear before the declaration of "
118
                 "%D, ignoring", decl);
119
      else
120
        solaris_pending_aligns = tree_cons (t, build_tree_list (NULL, x),
121
                                            solaris_pending_aligns);
122
 
123
      ttype = pragma_lex (&t);
124
      if (ttype == CPP_COMMA)
125
        {
126
          ttype = pragma_lex (&t);
127
          if (ttype != CPP_NAME)
128
            {
129
              warning (0, "malformed %<#pragma align%>");
130
              return;
131
            }
132
        }
133
      else if (ttype == CPP_CLOSE_PAREN)
134
        {
135
          if (pragma_lex (&t) != CPP_EOF)
136
            warning (0, "junk at end of %<#pragma align%>");
137
          return;
138
        }
139
      else
140
        {
141
          warning (0, "malformed %<#pragma align%>");
142
          return;
143
        }
144
    }
145
}
146
 
147
/* Handle #pragma init (function [, function]...)  */
148
 
149
static void
150
solaris_pragma_init (cpp_reader *pfile ATTRIBUTE_UNUSED)
151
{
152
  tree t;
153
  enum cpp_ttype ttype;
154
 
155
  if (pragma_lex (&t) != CPP_OPEN_PAREN)
156
    {
157
      warning (0, "malformed %<#pragma init%>, ignoring");
158
      return;
159
    }
160
 
161
  ttype = pragma_lex (&t);
162
  if (ttype != CPP_NAME)
163
    {
164
      warning (0, "malformed %<#pragma init%>, ignoring");
165
      return;
166
    }
167
 
168
  while (1)
169
    {
170
      tree decl = identifier_global_value (t);
171
      if (decl && DECL_P (decl))
172
        {
173
          tree attrs = build_tree_list (get_identifier ("init"),
174
                                        NULL);
175
          TREE_USED (decl) = 1;
176
          DECL_PRESERVE_P (decl) = 1;
177
          decl_attributes (&decl, attrs, 0);
178
        }
179
      else
180
        solaris_pending_inits = tree_cons (t, NULL, solaris_pending_inits);
181
 
182
      ttype = pragma_lex (&t);
183
      if (ttype == CPP_COMMA)
184
        {
185
          ttype = pragma_lex (&t);
186
          if (ttype != CPP_NAME)
187
            {
188
              warning (0, "malformed %<#pragma init%>");
189
              return;
190
            }
191
        }
192
      else if (ttype == CPP_CLOSE_PAREN)
193
        {
194
          if (pragma_lex (&t) != CPP_EOF)
195
            warning (0, "junk at end of %<#pragma init%>");
196
          return;
197
        }
198
      else
199
        {
200
          warning (0, "malformed %<#pragma init%>");
201
          return;
202
        }
203
    }
204
}
205
 
206
/* Handle #pragma fini (function [, function]...)  */
207
 
208
static void
209
solaris_pragma_fini (cpp_reader *pfile ATTRIBUTE_UNUSED)
210
{
211
  tree t;
212
  enum cpp_ttype ttype;
213
 
214
  if (pragma_lex (&t) != CPP_OPEN_PAREN)
215
    {
216
      warning (0, "malformed %<#pragma fini%>, ignoring");
217
      return;
218
    }
219
 
220
  ttype = pragma_lex (&t);
221
  if (ttype != CPP_NAME)
222
    {
223
      warning (0, "malformed %<#pragma fini%>, ignoring");
224
      return;
225
    }
226
 
227
  while (1)
228
    {
229
      tree decl = identifier_global_value (t);
230
      if (decl && DECL_P (decl))
231
        {
232
          tree attrs = build_tree_list (get_identifier ("fini"),
233
                                        NULL);
234
          TREE_USED (decl) = 1;
235
          DECL_PRESERVE_P (decl) = 1;
236
          decl_attributes (&decl, attrs, 0);
237
        }
238
      else
239
        solaris_pending_finis = tree_cons (t, NULL, solaris_pending_finis);
240
 
241
      ttype = pragma_lex (&t);
242
      if (ttype == CPP_COMMA)
243
        {
244
          ttype = pragma_lex (&t);
245
          if (ttype != CPP_NAME)
246
            {
247
              warning (0, "malformed %<#pragma fini%>");
248
              return;
249
            }
250
        }
251
      else if (ttype == CPP_CLOSE_PAREN)
252
        {
253
          if (pragma_lex (&t) != CPP_EOF)
254
            warning (0, "junk at end of %<#pragma fini%>");
255
          return;
256
        }
257
      else
258
        {
259
          warning (0, "malformed %<#pragma fini%>");
260
          return;
261
        }
262
    }
263
}
264
 
265
/* Register Solaris-specific #pragma directives.  */
266
 
267
void
268
solaris_register_pragmas (void)
269
{
270
  c_register_pragma_with_expansion (0, "align", solaris_pragma_align);
271
  c_register_pragma (0, "init", solaris_pragma_init);
272
  c_register_pragma (0, "fini", solaris_pragma_fini);
273
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.