Mercurial > hg > CbC > CbC_gcc
comparison gcc/c/c-objc-common.c @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
1 /* Some code common to C and ObjC front ends. | |
2 Copyright (C) 2001-2017 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 "c-tree.h" | |
24 #include "intl.h" | |
25 #include "c-family/c-pretty-print.h" | |
26 #include "tree-pretty-print.h" | |
27 #include "gimple-pretty-print.h" | |
28 #include "langhooks.h" | |
29 #include "c-objc-common.h" | |
30 | |
31 static bool c_tree_printer (pretty_printer *, text_info *, const char *, | |
32 int, bool, bool, bool, bool, const char **); | |
33 | |
34 bool | |
35 c_missing_noreturn_ok_p (tree decl) | |
36 { | |
37 /* A missing noreturn is not ok for freestanding implementations and | |
38 ok for the `main' function in hosted implementations. */ | |
39 return flag_hosted && MAIN_NAME_P (DECL_ASSEMBLER_NAME (decl)); | |
40 } | |
41 | |
42 /* Called from check_global_declaration. */ | |
43 | |
44 bool | |
45 c_warn_unused_global_decl (const_tree decl) | |
46 { | |
47 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl)) | |
48 return false; | |
49 if (DECL_IN_SYSTEM_HEADER (decl)) | |
50 return false; | |
51 | |
52 return true; | |
53 } | |
54 | |
55 /* Initialization common to C and Objective-C front ends. */ | |
56 bool | |
57 c_objc_common_init (void) | |
58 { | |
59 c_init_decl_processing (); | |
60 | |
61 return c_common_init (); | |
62 } | |
63 | |
64 /* Called during diagnostic message formatting process to print a | |
65 source-level entity onto BUFFER. The meaning of the format specifiers | |
66 is as follows: | |
67 %D: a general decl, | |
68 %E: an identifier or expression, | |
69 %F: a function declaration, | |
70 %G: a Gimple call statement, | |
71 %K: a CALL_EXPR, | |
72 %T: a type. | |
73 %V: a list of type qualifiers from a tree. | |
74 %v: an explicit list of type qualifiers | |
75 %#v: an explicit list of type qualifiers of a function type. | |
76 | |
77 Please notice when called, the `%' part was already skipped by the | |
78 diagnostic machinery. */ | |
79 static bool | |
80 c_tree_printer (pretty_printer *pp, text_info *text, const char *spec, | |
81 int precision, bool wide, bool set_locus, bool hash, | |
82 bool, const char **) | |
83 { | |
84 tree t = NULL_TREE; | |
85 tree name; | |
86 // FIXME: the next cast should be a dynamic_cast, when it is permitted. | |
87 c_pretty_printer *cpp = (c_pretty_printer *) pp; | |
88 pp->padding = pp_none; | |
89 | |
90 if (precision != 0 || wide) | |
91 return false; | |
92 | |
93 if (*spec == 'G') | |
94 { | |
95 percent_G_format (text); | |
96 return true; | |
97 } | |
98 | |
99 if (*spec == 'K') | |
100 { | |
101 t = va_arg (*text->args_ptr, tree); | |
102 percent_K_format (text, t); | |
103 return true; | |
104 } | |
105 | |
106 if (*spec != 'v') | |
107 { | |
108 t = va_arg (*text->args_ptr, tree); | |
109 if (set_locus) | |
110 text->set_location (0, DECL_SOURCE_LOCATION (t), true); | |
111 } | |
112 | |
113 switch (*spec) | |
114 { | |
115 case 'D': | |
116 if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t)) | |
117 { | |
118 t = DECL_DEBUG_EXPR (t); | |
119 if (!DECL_P (t)) | |
120 { | |
121 cpp->expression (t); | |
122 return true; | |
123 } | |
124 } | |
125 /* FALLTHRU */ | |
126 | |
127 case 'F': | |
128 if (DECL_NAME (t)) | |
129 { | |
130 pp_identifier (cpp, lang_hooks.decl_printable_name (t, 2)); | |
131 return true; | |
132 } | |
133 break; | |
134 | |
135 case 'T': | |
136 { | |
137 gcc_assert (TYPE_P (t)); | |
138 struct obstack *ob = pp_buffer (cpp)->obstack; | |
139 char *p = (char *) obstack_base (ob); | |
140 /* Remember the end of the initial dump. */ | |
141 int len = obstack_object_size (ob); | |
142 | |
143 name = TYPE_NAME (t); | |
144 if (name && TREE_CODE (name) == TYPE_DECL && DECL_NAME (name)) | |
145 pp_identifier (cpp, lang_hooks.decl_printable_name (name, 2)); | |
146 else | |
147 cpp->type_id (t); | |
148 | |
149 /* If we're printing a type that involves typedefs, also print the | |
150 stripped version. But sometimes the stripped version looks | |
151 exactly the same, so we don't want it after all. To avoid | |
152 printing it in that case, we play ugly obstack games. */ | |
153 if (TYPE_CANONICAL (t) && t != TYPE_CANONICAL (t)) | |
154 { | |
155 c_pretty_printer cpp2; | |
156 /* Print the stripped version into a temporary printer. */ | |
157 cpp2.type_id (TYPE_CANONICAL (t)); | |
158 struct obstack *ob2 = cpp2.buffer->obstack; | |
159 /* Get the stripped version from the temporary printer. */ | |
160 const char *aka = (char *) obstack_base (ob2); | |
161 int aka_len = obstack_object_size (ob2); | |
162 int type1_len = obstack_object_size (ob) - len; | |
163 | |
164 /* If they are identical, bail out. */ | |
165 if (aka_len == type1_len && memcmp (p + len, aka, aka_len) == 0) | |
166 return true; | |
167 | |
168 /* They're not, print the stripped version now. */ | |
169 pp_c_whitespace (cpp); | |
170 pp_left_brace (cpp); | |
171 pp_c_ws_string (cpp, _("aka")); | |
172 pp_c_whitespace (cpp); | |
173 cpp->type_id (TYPE_CANONICAL (t)); | |
174 pp_right_brace (cpp); | |
175 } | |
176 return true; | |
177 } | |
178 | |
179 case 'E': | |
180 if (TREE_CODE (t) == IDENTIFIER_NODE) | |
181 pp_identifier (cpp, IDENTIFIER_POINTER (t)); | |
182 else | |
183 cpp->expression (t); | |
184 return true; | |
185 | |
186 case 'V': | |
187 pp_c_type_qualifier_list (cpp, t); | |
188 return true; | |
189 | |
190 case 'v': | |
191 pp_c_cv_qualifiers (cpp, va_arg (*text->args_ptr, int), hash); | |
192 return true; | |
193 | |
194 default: | |
195 return false; | |
196 } | |
197 | |
198 pp_string (cpp, _("({anonymous})")); | |
199 return true; | |
200 } | |
201 | |
202 /* In C and ObjC, all decls have "C" linkage. */ | |
203 bool | |
204 has_c_linkage (const_tree decl ATTRIBUTE_UNUSED) | |
205 { | |
206 return true; | |
207 } | |
208 | |
209 void | |
210 c_initialize_diagnostics (diagnostic_context *context) | |
211 { | |
212 pretty_printer *base = context->printer; | |
213 c_pretty_printer *pp = XNEW (c_pretty_printer); | |
214 context->printer = new (pp) c_pretty_printer (); | |
215 | |
216 /* It is safe to free this object because it was previously XNEW()'d. */ | |
217 base->~pretty_printer (); | |
218 XDELETE (base); | |
219 | |
220 c_common_diagnostics_set_defaults (context); | |
221 diagnostic_format_decoder (context) = &c_tree_printer; | |
222 } | |
223 | |
224 int | |
225 c_types_compatible_p (tree x, tree y) | |
226 { | |
227 return comptypes (TYPE_MAIN_VARIANT (x), TYPE_MAIN_VARIANT (y)); | |
228 } | |
229 | |
230 /* Determine if the type is a vla type for the backend. */ | |
231 | |
232 bool | |
233 c_vla_unspec_p (tree x, tree fn ATTRIBUTE_UNUSED) | |
234 { | |
235 return c_vla_type_p (x); | |
236 } |