Mercurial > hg > CbC > CbC_gcc

comparison gcc/config/i386/winnt.c @ 0:a06113de4d67

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first commit
author kent <kent@cr.ie.u-ryukyu.ac.jp>
date Fri, 17 Jul 2009 14:47:48 +0900
parents
children 77e2b8dfacca
comparison
equal deleted inserted replaced
-1:000000000000 0:a06113de4d67
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"