|
0
|
1 /* Subroutines for insn-output.c for Windows NT.
|
|
|
2 Contributed by Douglas Rupp (drupp@cs.washington.edu)
|
|
|
3 Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
|
|
|
4 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
|
|
|
5
|
|
|
6 This file is part of GCC.
|
|
|
7
|
|
|
8 GCC is free software; you can redistribute it and/or modify it under
|
|
|
9 the terms of the GNU General Public License as published by the Free
|
|
|
10 Software Foundation; either version 3, or (at your option) any later
|
|
|
11 version.
|
|
|
12
|
|
|
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
16 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 "rtl.h"
|
|
|
27 #include "regs.h"
|
|
|
28 #include "hard-reg-set.h"
|
|
|
29 #include "output.h"
|
|
|
30 #include "tree.h"
|
|
|
31 #include "flags.h"
|
|
|
32 #include "tm_p.h"
|
|
|
33 #include "toplev.h"
|
|
|
34 #include "hashtab.h"
|
|
|
35 #include "langhooks.h"
|
|
|
36 #include "ggc.h"
|
|
|
37 #include "target.h"
|
|
|
38
|
|
|
39 /* i386/PE specific attribute support.
|
|
|
40
|
|
|
41 i386/PE has two new attributes:
|
|
|
42 dllexport - for exporting a function/variable that will live in a dll
|
|
|
43 dllimport - for importing a function/variable from a dll
|
|
|
44
|
|
|
45 Microsoft allows multiple declspecs in one __declspec, separating
|
|
|
46 them with spaces. We do NOT support this. Instead, use __declspec
|
|
|
47 multiple times.
|
|
|
48 */
|
|
|
49
|
|
|
50 /* Handle a "shared" attribute;
|
|
|
51 arguments as in struct attribute_spec.handler. */
|
|
|
52 tree
|
|
|
53 ix86_handle_shared_attribute (tree *node, tree name,
|
|
|
54 tree args ATTRIBUTE_UNUSED,
|
|
|
55 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
|
|
|
56 {
|
|
|
57 if (TREE_CODE (*node) != VAR_DECL)
|
|
|
58 {
|
|
|
59 warning (OPT_Wattributes, "%qs attribute only applies to variables",
|
|
|
60 IDENTIFIER_POINTER (name));
|
|
|
61 *no_add_attrs = true;
|
|
|
62 }
|
|
|
63
|
|
|
64 return NULL_TREE;
|
|
|
65 }
|
|
|
66
|
|
|
67 /* Handle a "selectany" attribute;
|
|
|
68 arguments as in struct attribute_spec.handler. */
|
|
|
69 tree
|
|
|
70 ix86_handle_selectany_attribute (tree *node, tree name,
|
|
|
71 tree args ATTRIBUTE_UNUSED,
|
|
|
72 int flags ATTRIBUTE_UNUSED,
|
|
|
73 bool *no_add_attrs)
|
|
|
74 {
|
|
|
75 /* The attribute applies only to objects that are initialized and have
|
|
|
76 external linkage. However, we may not know about initialization
|
|
|
77 until the language frontend has processed the decl. We'll check for
|
|
|
78 initialization later in encode_section_info. */
|
|
|
79 if (TREE_CODE (*node) != VAR_DECL || !TREE_PUBLIC (*node))
|
|
|
80 {
|
|
|
81 error ("%qs attribute applies only to initialized variables"
|
|
|
82 " with external linkage", IDENTIFIER_POINTER (name));
|
|
|
83 *no_add_attrs = true;
|
|
|
84 }
|
|
|
85
|
|
|
86 return NULL_TREE;
|
|
|
87 }
|
|
|
88
|
|
|
89
|
|
|
90 /* Return the type that we should use to determine if DECL is
|
|
|
91 imported or exported. */
|
|
|
92
|
|
|
93 static tree
|
|
|
94 associated_type (tree decl)
|
|
|
95 {
|
|
|
96 return (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
|
|
|
97 ? DECL_CONTEXT (decl) : NULL_TREE);
|
|
|
98 }
|
|
|
99
|
|
|
100 /* Return true if DECL should be a dllexport'd object. */
|
|
|
101
|
|
|
102 static bool
|
|
|
103 i386_pe_determine_dllexport_p (tree decl)
|
|
|
104 {
|
|
|
105 tree assoc;
|
|
|
106
|
|
|
107 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
|
|
|
108 return false;
|
|
|
109
|
|
|
110 if (lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
|
|
|
111 return true;
|
|
|
112
|
|
|
113 /* Also mark class members of exported classes with dllexport. */
|
|
|
114 assoc = associated_type (decl);
|
|
|
115 if (assoc && lookup_attribute ("dllexport", TYPE_ATTRIBUTES (assoc)))
|
|
|
116 return i386_pe_type_dllexport_p (decl);
|
|
|
117
|
|
|
118 return false;
|
|
|
119 }
|
|
|
120
|
|
|
121 /* Return true if DECL should be a dllimport'd object. */
|
|
|
122
|
|
|
123 static bool
|
|
|
124 i386_pe_determine_dllimport_p (tree decl)
|
|
|
125 {
|
|
|
126 tree assoc;
|
|
|
127
|
|
|
128 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
|
|
|
129 return false;
|
|
|
130
|
|
|
131 /* Lookup the attribute in addition to checking the DECL_DLLIMPORT_P flag.
|
|
|
132 We may need to override an earlier decision. */
|
|
|
133 if (DECL_DLLIMPORT_P (decl))
|
|
|
134 return true;
|
|
|
135
|
|
|
136 /* The DECL_DLLIMPORT_P flag was set for decls in the class definition
|
|
|
137 by targetm.cxx.adjust_class_at_definition. Check again to emit
|
|
|
138 warnings if the class attribute has been overridden by an
|
|
|
139 out-of-class definition. */
|
|
|
140 assoc = associated_type (decl);
|
|
|
141 if (assoc && lookup_attribute ("dllimport", TYPE_ATTRIBUTES (assoc)))
|
|
|
142 return i386_pe_type_dllimport_p (decl);
|
|
|
143
|
|
|
144 return false;
|
|
|
145 }
|
|
|
146
|
|
|
147 /* Handle the -mno-fun-dllimport target switch. */
|
|
|
148
|
|
|
149 bool
|
|
|
150 i386_pe_valid_dllimport_attribute_p (const_tree decl)
|
|
|
151 {
|
|
|
152 if (TARGET_NOP_FUN_DLLIMPORT && TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
153 return false;
|
|
|
154 return true;
|
|
|
155 }
|
|
|
156
|
|
|
157 /* Return string which is the function name, identified by ID, modified
|
|
|
158 with a suffix consisting of an atsign (@) followed by the number of
|
|
|
159 bytes of arguments. If ID is NULL use the DECL_NAME as base. If
|
|
|
160 FASTCALL is true, also add the FASTCALL_PREFIX.
|
|
|
161 Return NULL if no change required. */
|
|
|
162
|
|
|
163 static tree
|
|
|
164 gen_stdcall_or_fastcall_suffix (tree decl, tree id, bool fastcall)
|
|
|
165 {
|
|
|
166 HOST_WIDE_INT total = 0;
|
|
|
167 const char *old_str = IDENTIFIER_POINTER (id != NULL_TREE ? id : DECL_NAME (decl));
|
|
|
168 char *new_str, *p;
|
|
|
169 tree type = TREE_TYPE (decl);
|
|
|
170 tree arg;
|
|
|
171 function_args_iterator args_iter;
|
|
|
172
|
|
|
173 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
|
|
|
174
|
|
|
175 if (prototype_p (type))
|
|
|
176 {
|
|
|
177 /* This attribute is ignored for variadic functions. */
|
|
|
178 if (stdarg_p (type))
|
|
|
179 return NULL_TREE;
|
|
|
180
|
|
|
181 /* Quit if we hit an incomplete type. Error is reported
|
|
|
182 by convert_arguments in c-typeck.c or cp/typeck.c. */
|
|
|
183 FOREACH_FUNCTION_ARGS(type, arg, args_iter)
|
|
|
184 {
|
|
|
185 HOST_WIDE_INT parm_size;
|
|
|
186 HOST_WIDE_INT parm_boundary_bytes = PARM_BOUNDARY / BITS_PER_UNIT;
|
|
|
187
|
|
|
188 if (! COMPLETE_TYPE_P (arg))
|
|
|
189 break;
|
|
|
190
|
|
|
191 parm_size = int_size_in_bytes (arg);
|
|
|
192 if (parm_size < 0)
|
|
|
193 break;
|
|
|
194
|
|
|
195 /* Must round up to include padding. This is done the same
|
|
|
196 way as in store_one_arg. */
|
|
|
197 parm_size = ((parm_size + parm_boundary_bytes - 1)
|
|
|
198 / parm_boundary_bytes * parm_boundary_bytes);
|
|
|
199 total += parm_size;
|
|
|
200 }
|
|
|
201 }
|
|
|
202 /* Assume max of 8 base 10 digits in the suffix. */
|
|
|
203 p = new_str = XALLOCAVEC (char, 1 + strlen (old_str) + 1 + 8 + 1);
|
|
|
204 if (fastcall)
|
|
|
205 *p++ = FASTCALL_PREFIX;
|
|
|
206 sprintf (p, "%s@" HOST_WIDE_INT_PRINT_DEC, old_str, total);
|
|
|
207
|
|
|
208 return get_identifier (new_str);
|
|
|
209 }
|
|
|
210
|
|
|
211 /* Maybe decorate and get a new identifier for the DECL of a stdcall or
|
|
|
212 fastcall function. The original identifier is supplied in ID. */
|
|
|
213
|
|
|
214 static tree
|
|
|
215 i386_pe_maybe_mangle_decl_assembler_name (tree decl, tree id)
|
|
|
216 {
|
|
|
217 tree new_id = NULL_TREE;
|
|
|
218
|
|
|
219 if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
220 {
|
|
|
221 tree type_attributes = TYPE_ATTRIBUTES (TREE_TYPE (decl));
|
|
|
222 if (lookup_attribute ("stdcall", type_attributes))
|
|
|
223 new_id = gen_stdcall_or_fastcall_suffix (decl, id, false);
|
|
|
224 else if (lookup_attribute ("fastcall", type_attributes))
|
|
|
225 new_id = gen_stdcall_or_fastcall_suffix (decl, id, true);
|
|
|
226 }
|
|
|
227
|
|
|
228 return new_id;
|
|
|
229 }
|
|
|
230
|
|
|
231 /* This is used as a target hook to modify the DECL_ASSEMBLER_NAME
|
|
|
232 in the language-independent default hook
|
|
|
233 langhooks,c:lhd_set_decl_assembler_name ()
|
|
|
234 and in cp/mangle,c:mangle_decl (). */
|
|
|
235 tree
|
|
|
236 i386_pe_mangle_decl_assembler_name (tree decl, tree id)
|
|
|
237 {
|
|
|
238 tree new_id = i386_pe_maybe_mangle_decl_assembler_name (decl, id);
|
|
|
239
|
|
|
240 return (new_id ? new_id : id);
|
|
|
241 }
|
|
|
242
|
|
|
243 void
|
|
|
244 i386_pe_encode_section_info (tree decl, rtx rtl, int first)
|
|
|
245 {
|
|
|
246 rtx symbol;
|
|
|
247 int flags;
|
|
|
248
|
|
|
249 /* Do this last, due to our frobbing of DECL_DLLIMPORT_P above. */
|
|
|
250 default_encode_section_info (decl, rtl, first);
|
|
|
251
|
|
|
252 /* Careful not to prod global register variables. */
|
|
|
253 if (!MEM_P (rtl))
|
|
|
254 return;
|
|
|
255
|
|
|
256 symbol = XEXP (rtl, 0);
|
|
|
257 gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
|
|
|
258
|
|
|
259 switch (TREE_CODE (decl))
|
|
|
260 {
|
|
|
261 case FUNCTION_DECL:
|
|
|
262 /* FIXME: Imported stdcall names are not modified by the Ada frontend.
|
|
|
263 Check and decorate the RTL name now. */
|
|
|
264 if (strcmp (lang_hooks.name, "GNU Ada") == 0)
|
|
|
265 {
|
|
|
266 tree new_id;
|
|
|
267 tree old_id = DECL_ASSEMBLER_NAME (decl);
|
|
|
268 const char* asm_str = IDENTIFIER_POINTER (old_id);
|
|
|
269 /* Do not change the identifier if a verbatim asmspec
|
|
|
270 or if stdcall suffix already added. */
|
|
|
271 if (!(*asm_str == '*' || strchr (asm_str, '@'))
|
|
|
272 && (new_id = i386_pe_maybe_mangle_decl_assembler_name (decl,
|
|
|
273 old_id)))
|
|
|
274 XSTR (symbol, 0) = IDENTIFIER_POINTER (new_id);
|
|
|
275 }
|
|
|
276 break;
|
|
|
277
|
|
|
278 case VAR_DECL:
|
|
|
279 if (lookup_attribute ("selectany", DECL_ATTRIBUTES (decl)))
|
|
|
280 {
|
|
|
281 if (DECL_INITIAL (decl)
|
|
|
282 /* If an object is initialized with a ctor, the static
|
|
|
283 initialization and destruction code for it is present in
|
|
|
284 each unit defining the object. The code that calls the
|
|
|
285 ctor is protected by a link-once guard variable, so that
|
|
|
286 the object still has link-once semantics, */
|
|
|
287 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
|
|
|
288 make_decl_one_only (decl);
|
|
|
289 else
|
|
|
290 error ("%q+D:'selectany' attribute applies only to "
|
|
|
291 "initialized objects", decl);
|
|
|
292 }
|
|
|
293 break;
|
|
|
294
|
|
|
295 default:
|
|
|
296 return;
|
|
|
297 }
|
|
|
298
|
|
|
299 /* Mark the decl so we can tell from the rtl whether the object is
|
|
|
300 dllexport'd or dllimport'd. tree.c: merge_dllimport_decl_attributes
|
|
|
301 handles dllexport/dllimport override semantics. */
|
|
|
302 flags = (SYMBOL_REF_FLAGS (symbol) &
|
|
|
303 ~(SYMBOL_FLAG_DLLIMPORT | SYMBOL_FLAG_DLLEXPORT));
|
|
|
304 if (i386_pe_determine_dllexport_p (decl))
|
|
|
305 flags |= SYMBOL_FLAG_DLLEXPORT;
|
|
|
306 else if (i386_pe_determine_dllimport_p (decl))
|
|
|
307 {
|
|
|
308 flags |= SYMBOL_FLAG_DLLIMPORT;
|
|
|
309 /* If we went through the associated_type path, this won't already
|
|
|
310 be set. Though, frankly, this seems wrong, and should be fixed
|
|
|
311 elsewhere. */
|
|
|
312 if (!DECL_DLLIMPORT_P (decl))
|
|
|
313 {
|
|
|
314 DECL_DLLIMPORT_P (decl) = 1;
|
|
|
315 flags &= ~SYMBOL_FLAG_LOCAL;
|
|
|
316 }
|
|
|
317 }
|
|
|
318 SYMBOL_REF_FLAGS (symbol) = flags;
|
|
|
319 }
|
|
|
320
|
|
|
321 bool
|
|
|
322 i386_pe_binds_local_p (const_tree exp)
|
|
|
323 {
|
|
|
324 /* PE does not do dynamic binding. Indeed, the only kind of
|
|
|
325 non-local reference comes from a dllimport'd symbol. */
|
|
|
326 if ((TREE_CODE (exp) == VAR_DECL || TREE_CODE (exp) == FUNCTION_DECL)
|
|
|
327 && DECL_DLLIMPORT_P (exp))
|
|
|
328 return false;
|
|
|
329
|
|
|
330 return true;
|
|
|
331 }
|
|
|
332
|
|
|
333 /* Also strip the fastcall prefix and stdcall suffix. */
|
|
|
334
|
|
|
335 const char *
|
|
|
336 i386_pe_strip_name_encoding_full (const char *str)
|
|
|
337 {
|
|
|
338 const char *p;
|
|
|
339 const char *name = default_strip_name_encoding (str);
|
|
|
340
|
|
|
341 /* Strip leading '@' on fastcall symbols. */
|
|
|
342 if (*name == '@')
|
|
|
343 name++;
|
|
|
344
|
|
|
345 /* Strip trailing "@n". */
|
|
|
346 p = strchr (name, '@');
|
|
|
347 if (p)
|
|
|
348 return ggc_alloc_string (name, p - name);
|
|
|
349
|
|
|
350 return name;
|
|
|
351 }
|
|
|
352
|
|
|
353 void
|
|
|
354 i386_pe_unique_section (tree decl, int reloc)
|
|
|
355 {
|
|
|
356 int len;
|
|
|
357 const char *name, *prefix;
|
|
|
358 char *string;
|
|
|
359
|
|
|
360 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
|
|
361 name = i386_pe_strip_name_encoding_full (name);
|
|
|
362
|
|
|
363 /* The object is put in, for example, section .text$foo.
|
|
|
364 The linker will then ultimately place them in .text
|
|
|
365 (everything from the $ on is stripped). Don't put
|
|
|
366 read-only data in .rdata section to avoid a PE linker
|
|
|
367 bug when .rdata$* grouped sections are used in code
|
|
|
368 without a .rdata section. */
|
|
|
369 if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
370 prefix = ".text$";
|
|
|
371 else if (decl_readonly_section (decl, reloc))
|
|
|
372 prefix = ".rdata$";
|
|
|
373 else
|
|
|
374 prefix = ".data$";
|
|
|
375 len = strlen (name) + strlen (prefix);
|
|
|
376 string = XALLOCAVEC (char, len + 1);
|
|
|
377 sprintf (string, "%s%s", prefix, name);
|
|
|
378
|
|
|
379 DECL_SECTION_NAME (decl) = build_string (len, string);
|
|
|
380 }
|
|
|
381
|
|
|
382 /* Select a set of attributes for section NAME based on the properties
|
|
|
383 of DECL and whether or not RELOC indicates that DECL's initializer
|
|
|
384 might contain runtime relocations.
|
|
|
385
|
|
|
386 We make the section read-only and executable for a function decl,
|
|
|
387 read-only for a const data decl, and writable for a non-const data decl.
|
|
|
388
|
|
|
389 If the section has already been defined, to not allow it to have
|
|
|
390 different attributes, as (1) this is ambiguous since we're not seeing
|
|
|
391 all the declarations up front and (2) some assemblers (e.g. SVR4)
|
|
|
392 do not recognize section redefinitions. */
|
|
|
393 /* ??? This differs from the "standard" PE implementation in that we
|
|
|
394 handle the SHARED variable attribute. Should this be done for all
|
|
|
395 PE targets? */
|
|
|
396
|
|
|
397 #define SECTION_PE_SHARED SECTION_MACH_DEP
|
|
|
398
|
|
|
399 unsigned int
|
|
|
400 i386_pe_section_type_flags (tree decl, const char *name, int reloc)
|
|
|
401 {
|
|
|
402 static htab_t htab;
|
|
|
403 unsigned int flags;
|
|
|
404 unsigned int **slot;
|
|
|
405
|
|
|
406 /* The names we put in the hashtable will always be the unique
|
|
|
407 versions given to us by the stringtable, so we can just use
|
|
|
408 their addresses as the keys. */
|
|
|
409 if (!htab)
|
|
|
410 htab = htab_create (31, htab_hash_pointer, htab_eq_pointer, NULL);
|
|
|
411
|
|
|
412 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
413 flags = SECTION_CODE;
|
|
|
414 else if (decl && decl_readonly_section (decl, reloc))
|
|
|
415 flags = 0;
|
|
|
416 else if (current_function_decl
|
|
|
417 && cfun
|
|
|
418 && crtl->subsections.unlikely_text_section_name
|
|
|
419 && strcmp (name, crtl->subsections.unlikely_text_section_name) == 0)
|
|
|
420 flags = SECTION_CODE;
|
|
|
421 else if (!decl
|
|
|
422 && (!current_function_decl || !cfun)
|
|
|
423 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
|
|
|
424 flags = SECTION_CODE;
|
|
|
425 else
|
|
|
426 {
|
|
|
427 flags = SECTION_WRITE;
|
|
|
428
|
|
|
429 if (decl && TREE_CODE (decl) == VAR_DECL
|
|
|
430 && lookup_attribute ("shared", DECL_ATTRIBUTES (decl)))
|
|
|
431 flags |= SECTION_PE_SHARED;
|
|
|
432 }
|
|
|
433
|
|
|
434 if (decl && DECL_ONE_ONLY (decl))
|
|
|
435 flags |= SECTION_LINKONCE;
|
|
|
436
|
|
|
437 /* See if we already have an entry for this section. */
|
|
|
438 slot = (unsigned int **) htab_find_slot (htab, name, INSERT);
|
|
|
439 if (!*slot)
|
|
|
440 {
|
|
|
441 *slot = (unsigned int *) xmalloc (sizeof (unsigned int));
|
|
|
442 **slot = flags;
|
|
|
443 }
|
|
|
444 else
|
|
|
445 {
|
|
|
446 if (decl && **slot != flags)
|
|
|
447 error ("%q+D causes a section type conflict", decl);
|
|
|
448 }
|
|
|
449
|
|
|
450 return flags;
|
|
|
451 }
|
|
|
452
|
|
|
453 void
|
|
|
454 i386_pe_asm_named_section (const char *name, unsigned int flags,
|
|
|
455 tree decl)
|
|
|
456 {
|
|
|
457 char flagchars[8], *f = flagchars;
|
|
|
458
|
|
|
459 if ((flags & (SECTION_CODE | SECTION_WRITE)) == 0)
|
|
|
460 /* readonly data */
|
|
|
461 {
|
|
|
462 *f++ ='d'; /* This is necessary for older versions of gas. */
|
|
|
463 *f++ ='r';
|
|
|
464 }
|
|
|
465 else
|
|
|
466 {
|
|
|
467 if (flags & SECTION_CODE)
|
|
|
468 *f++ = 'x';
|
|
|
469 if (flags & SECTION_WRITE)
|
|
|
470 *f++ = 'w';
|
|
|
471 if (flags & SECTION_PE_SHARED)
|
|
|
472 *f++ = 's';
|
|
|
473 }
|
|
|
474
|
|
|
475 *f = '\0';
|
|
|
476
|
|
|
477 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
|
|
|
478
|
|
|
479 if (flags & SECTION_LINKONCE)
|
|
|
480 {
|
|
|
481 /* Functions may have been compiled at various levels of
|
|
|
482 optimization so we can't use `same_size' here.
|
|
|
483 Instead, have the linker pick one, without warning.
|
|
|
484 If 'selectany' attribute has been specified, MS compiler
|
|
|
485 sets 'discard' characteristic, rather than telling linker
|
|
|
486 to warn of size or content mismatch, so do the same. */
|
|
|
487 bool discard = (flags & SECTION_CODE)
|
|
|
488 || lookup_attribute ("selectany",
|
|
|
489 DECL_ATTRIBUTES (decl));
|
|
|
490 fprintf (asm_out_file, "\t.linkonce %s\n",
|
|
|
491 (discard ? "discard" : "same_size"));
|
|
|
492 }
|
|
|
493 }
|
|
|
494
|
|
|
495 void
|
|
|
496 i386_pe_asm_output_aligned_decl_common (FILE *stream, tree decl,
|
|
|
497 const char *name, HOST_WIDE_INT size,
|
|
|
498 HOST_WIDE_INT align ATTRIBUTE_UNUSED)
|
|
|
499 {
|
|
|
500 HOST_WIDE_INT rounded;
|
|
|
501
|
|
|
502 /* Compute as in assemble_noswitch_variable, since we don't actually
|
|
|
503 support aligned common. */
|
|
|
504 rounded = size ? size : 1;
|
|
|
505 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
|
|
|
506 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
|
|
|
507 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
|
|
|
508
|
|
|
509 i386_pe_maybe_record_exported_symbol (decl, name, 1);
|
|
|
510
|
|
|
511 fprintf (stream, "\t.comm\t");
|
|
|
512 assemble_name (stream, name);
|
|
|
513 fprintf (stream, ", " HOST_WIDE_INT_PRINT_DEC "\t" ASM_COMMENT_START
|
|
|
514 " " HOST_WIDE_INT_PRINT_DEC "\n",
|
|
|
515 rounded, size);
|
|
|
516 }
|
|
|
517
|
|
|
518 /* The Microsoft linker requires that every function be marked as
|
|
|
519 DT_FCN. When using gas on cygwin, we must emit appropriate .type
|
|
|
520 directives. */
|
|
|
521
|
|
|
522 #include "gsyms.h"
|
|
|
523
|
|
|
524 /* Mark a function appropriately. This should only be called for
|
|
|
525 functions for which we are not emitting COFF debugging information.
|
|
|
526 FILE is the assembler output file, NAME is the name of the
|
|
|
527 function, and PUB is nonzero if the function is globally
|
|
|
528 visible. */
|
|
|
529
|
|
|
530 void
|
|
|
531 i386_pe_declare_function_type (FILE *file, const char *name, int pub)
|
|
|
532 {
|
|
|
533 fprintf (file, "\t.def\t");
|
|
|
534 assemble_name (file, name);
|
|
|
535 fprintf (file, ";\t.scl\t%d;\t.type\t%d;\t.endef\n",
|
|
|
536 pub ? (int) C_EXT : (int) C_STAT,
|
|
|
537 (int) DT_FCN << N_BTSHFT);
|
|
|
538 }
|
|
|
539
|
|
|
540 /* Keep a list of external functions. */
|
|
|
541
|
|
|
542 struct extern_list GTY(())
|
|
|
543 {
|
|
|
544 struct extern_list *next;
|
|
|
545 tree decl;
|
|
|
546 const char *name;
|
|
|
547 };
|
|
|
548
|
|
|
549 static GTY(()) struct extern_list *extern_head;
|
|
|
550
|
|
|
551 /* Assemble an external function reference. We need to keep a list of
|
|
|
552 these, so that we can output the function types at the end of the
|
|
|
553 assembly. We can't output the types now, because we might see a
|
|
|
554 definition of the function later on and emit debugging information
|
|
|
555 for it then. */
|
|
|
556
|
|
|
557 void
|
|
|
558 i386_pe_record_external_function (tree decl, const char *name)
|
|
|
559 {
|
|
|
560 struct extern_list *p;
|
|
|
561
|
|
|
562 p = (struct extern_list *) ggc_alloc (sizeof *p);
|
|
|
563 p->next = extern_head;
|
|
|
564 p->decl = decl;
|
|
|
565 p->name = name;
|
|
|
566 extern_head = p;
|
|
|
567 }
|
|
|
568
|
|
|
569 /* Keep a list of exported symbols. */
|
|
|
570
|
|
|
571 struct export_list GTY(())
|
|
|
572 {
|
|
|
573 struct export_list *next;
|
|
|
574 const char *name;
|
|
|
575 int is_data; /* used to type tag exported symbols. */
|
|
|
576 };
|
|
|
577
|
|
|
578 static GTY(()) struct export_list *export_head;
|
|
|
579
|
|
|
580 /* Assemble an export symbol entry. We need to keep a list of
|
|
|
581 these, so that we can output the export list at the end of the
|
|
|
582 assembly. We used to output these export symbols in each function,
|
|
|
583 but that causes problems with GNU ld when the sections are
|
|
|
584 linkonce. */
|
|
|
585
|
|
|
586 void
|
|
|
587 i386_pe_maybe_record_exported_symbol (tree decl, const char *name, int is_data)
|
|
|
588 {
|
|
|
589 rtx symbol;
|
|
|
590 struct export_list *p;
|
|
|
591
|
|
|
592 symbol = XEXP (DECL_RTL (decl), 0);
|
|
|
593 gcc_assert (GET_CODE (symbol) == SYMBOL_REF);
|
|
|
594 if (!SYMBOL_REF_DLLEXPORT_P (symbol))
|
|
|
595 return;
|
|
|
596
|
|
|
597 p = (struct export_list *) ggc_alloc (sizeof *p);
|
|
|
598 p->next = export_head;
|
|
|
599 p->name = name;
|
|
|
600 p->is_data = is_data;
|
|
|
601 export_head = p;
|
|
|
602 }
|
|
|
603
|
|
|
604 /* This is called at the end of assembly. For each external function
|
|
|
605 which has not been defined, we output a declaration now. We also
|
|
|
606 output the .drectve section. */
|
|
|
607
|
|
|
608 void
|
|
|
609 i386_pe_file_end (void)
|
|
|
610 {
|
|
|
611 struct extern_list *p;
|
|
|
612
|
|
|
613 ix86_file_end ();
|
|
|
614
|
|
|
615 for (p = extern_head; p != NULL; p = p->next)
|
|
|
616 {
|
|
|
617 tree decl;
|
|
|
618
|
|
|
619 decl = p->decl;
|
|
|
620
|
|
|
621 /* Positively ensure only one declaration for any given symbol. */
|
|
|
622 if (! TREE_ASM_WRITTEN (decl)
|
|
|
623 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
|
|
|
624 {
|
|
|
625 TREE_ASM_WRITTEN (decl) = 1;
|
|
|
626 i386_pe_declare_function_type (asm_out_file, p->name,
|
|
|
627 TREE_PUBLIC (decl));
|
|
|
628 }
|
|
|
629 }
|
|
|
630
|
|
|
631 if (export_head)
|
|
|
632 {
|
|
|
633 struct export_list *q;
|
|
|
634 drectve_section ();
|
|
|
635 for (q = export_head; q != NULL; q = q->next)
|
|
|
636 {
|
|
|
637 fprintf (asm_out_file, "\t.ascii \" -export:%s%s\"\n",
|
|
|
638 default_strip_name_encoding (q->name),
|
|
|
639 (q->is_data ? ",data" : ""));
|
|
|
640 }
|
|
|
641 }
|
|
|
642 }
|
|
|
643
|
|
|
644 #include "gt-winnt.h"
|
