projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2009-08-18 Sterling Augustine <sterling@tensilica.com>
[deliverable/binutils-gdb.git] / gas / config / obj-coff-seh.c
CommitLineData
987499b2
KT		 1#include "obj-coff-seh.h"
2
3/* Forward declarations. */
4static seh_kind seh_get_target_kind (void);
5static int seh_symbol (bfd *, const char *, const char *, const char *, asection *, int, int);
6static void seh_reloc (bfd *, bfd_size_type, int, int);
7static void save_relocs (asection *sec);
8static asection *quick_section (bfd *abfd, const char *name, int flags, int align);
9static void seh_symbol_init (bfd *abfd, unsigned int added);
10static void seh_emit_rva (const char *);
11static void seh_emit_long (const char *);
12static void seh_make_globl (char *);
13static segT seh_make_section (void);
14static segT seh_make_section2 (const char *section_name, unsigned flags);
15static char *seh_make_xlbl_name (seh_context *);
16static char *make_seh_text_label (seh_context *c, symbolS **addr);
17
18static void seh_write_text_eh_data (const char *hnd, const char *hnd_data);
19static void seh_emit_rva (const char *name);
20static int seh_needed_unwind_info (seh_context *);
21static void seh_fill_pcsyms (const seh_context *c, char **, int *);
22static size_t seh_getelm_data_size (const seh_context *, int, int);
23static size_t seh_getsize_of_unwind_entry (seh_context *, int, int, int);
24static void seh_make_unwind_entry (const seh_context *, char *, int, int, int, unsigned char *, size_t *, int);
25static size_t seh_getsize_unwind_data (seh_context *);
26static void seh_create_unwind_data (seh_context *, unsigned char *, size_t);
27static void seh_make_function_entry_xdata (seh_context *, char *, char *, char *, unsigned char *, size_t *,int);
28static seh_scope_elem *seh_x64_makescope_elem (seh_context *, const char *, const char *, const char *, const char *);
29
30/* Local data. */
31static asymbol **symtab;
32static int symptr;
33static arelent *reltab = 0;
34static int relcount = 0, relsize = 0;
35
36static seh_context *seh_ctx_root = NULL;
37static seh_context *seh_ctx = NULL;
38static seh_context *seh_ctx_cur = NULL;
39
40/* Write xdata for arm, sh3, sh4, and ppc. */
41static void
42seh_write_text_eh_data (const char *hnd, const char *hnd_data)
43{
44 if (!hnd || *hnd==0)
45 return;
46 if (hnd[0] == '@')
47 seh_emit_long ("0");
48 else
49 seh_emit_long (hnd);
50 if (!hnd_data || hnd_data[0] == '@')
51 seh_emit_long ("0");
52 else
53 seh_emit_long (hnd_data);
54}
55
56/* Generate initial pdata for x64 and mips. */
57static void
58make_function_entry_pdata (seh_context *c)
59{
60 segT sec = NULL;
61 segT current_seg = now_seg;
62 subsegT current_subseg = now_subseg;
63
64 sec = seh_make_section ();
65 switch (seh_get_target_kind ())
66 {
67 case seh_kind_x64:
68 subseg_set (sec, 0);
69 seh_emit_rva (c->func_name);
70 seh_emit_rva (c->end_symbol);
71 seh_emit_rva (c->xdata_first);
72 break;
73 case seh_kind_mips:
74 subseg_set (sec, 0);
75 seh_emit_long (c->func_name);
76 seh_emit_long (c->end_symbol);
77 if (c->handler_name == NULL)
78 seh_emit_long ("0");
79 else if (c->handler_name[0] == '@')
80 {
81 if (strcasecmp (c->handler_name, "@1") == 0)
82 seh_emit_long ("1");
83 else
84 seh_emit_long ("0");
85 }
86 else
87 seh_emit_long (c->handler_name);
88 if (c->handler_data_name == NULL || c->handler_data_name[0] == '@')
89 seh_emit_long ("0");
90 else
91 seh_emit_long (c->handler_data_name);
92 seh_emit_long (c->endprologue_symbol ? c->endprologue_symbol : c->func_name);
93 break;
94 default:
95 break;
96 }
97 subseg_set (current_seg, current_subseg);
98}
99
100static void
101seh_x64_write_xdata (void)
102{
103 seh_context *h;
104 size_t xdata_size = 0, count_syms = 0;
105 size_t xdata_offs = 0;
106 unsigned char *data;
107 segT seg_xdata;
108 bfd *abfd = stdoutput;
109
110 h = seh_ctx_root;
111 if (h->done)
112 return;
113 while (h != NULL)
114 {
115 h->xdata_offset = xdata_size;
116 xdata_size += seh_getsize_unwind_data (h);
117 count_syms += h->count_syms;
118 h = h->next;
119 }
120
121 if (xdata_size == 0)
122 return;
123
124 seh_symbol_init (abfd, count_syms);
125 data = xmalloc (xdata_size);
126 seg_xdata = quick_section (abfd, ".xdata", SEC_HAS_CONTENTS, 3);
127 seg_xdata->contents = data;
128 memset (data, 0, xdata_size);
129 bfd_set_section_size (abfd, seg_xdata, xdata_size);
130 h = seh_ctx_root;
131 while (h != NULL)
132 {
133 xdata_offs = h->xdata_offset;
134 h->section = seg_xdata;
135 h->abfd = abfd;
136 if (h->done == 0)
137 {
138 h->done = 1;
139 seh_create_unwind_data (h, data, xdata_offs);
140 h->done = 1;
141 }
142 h = h->next;
143 }
144 save_relocs (seg_xdata);
145 bfd_set_symtab (abfd, symtab, symptr);
146 bfd_set_section_contents (abfd, seg_xdata, data, 0, xdata_size);
147}
148
149static void
150seh_arm_create_pdata (seh_context *c, unsigned char *data, size_t pdata_offs)
151{
152 int idx;
153 unsigned int val;
154 valueT func_len = 0;
155 valueT prolog_len = 0;
156 valueT start_len = 0;
157 func_len = resolve_symbol_value (c->end_addr);
158 start_len = resolve_symbol_value (c->start_addr);
159 if (c->endprologue_addr)
160 prolog_len = resolve_symbol_value (c->endprologue_addr);
161 else
162 prolog_len = start_len;
163 func_len -= start_len;
164 prolog_len -= start_len;
165 if (!c || !data)
166 return;
167 /* $$$$ */
168 idx = seh_symbol (c->abfd, c->start_symbol, "", "", UNDSEC, BSF_GLOBAL, 0);
169 seh_reloc (c->abfd, pdata_offs, BFD_RELOC_32, idx);
170 val = (unsigned int) func_len;
171 val <<= 8;
172 val |= ((unsigned int) prolog_len & 0xffU);
173 if (c->use_instruction_32)
174 val |= 0x40000000U;
175 if (c->handler_written)
176 val |= 0x80000000U;
177 bfd_put_32 (c->abfd, (bfd_vma) val, data + pdata_offs + 4);
178}
179
180static void
181seh_arm_write_pdata (void)
182{
183 seh_context *h;
184 size_t pdata_size = 0, count_syms = 0;
185 size_t pdata_offs = 0;
186 unsigned char *data;
187 segT seg_pdata;
188 bfd *abfd = stdoutput;
189
190 h = seh_ctx_root;
191 if (h->done)
192 return;
193 while (h != NULL)
194 {
195 h->xdata_offset = pdata_size;
196 pdata_size += 8;
197 count_syms += 1;
198 h = h->next;
199 }
200
201 if (pdata_size == 0)
202 return;
203
204 seh_symbol_init (abfd, count_syms);
205 data = xmalloc (pdata_size);
206 seg_pdata = quick_section (abfd, ".pdata", SEC_HAS_CONTENTS, 3);
207 seg_pdata->contents = data;
208 memset (data, 0, pdata_size);
209 bfd_set_section_size (abfd, seg_pdata, pdata_size);
210 h = seh_ctx_root;
211 while (h != NULL)
212 {
213 pdata_offs = h->xdata_offset;
214 h->section = seg_pdata;
215 h->abfd = abfd;
216 if (h->done != 0)
217 {
218 seh_arm_create_pdata (h, data, pdata_offs);
219 h->done = 1;
220 }
221 h = h->next;
222 }
223 save_relocs (seg_pdata);
224 bfd_set_symtab (abfd, symtab, symptr);
225 bfd_set_section_contents (abfd, seg_pdata, data, 0, pdata_size);
226}
227
228void
229obj_coff_seh_do_final (void)
230{
231 switch (seh_get_target_kind ())
232 {
233 case seh_kind_mips:
234 default:
235 break;
236 case seh_kind_arm:
237 seh_arm_write_pdata ();
238 break;
239 case seh_kind_x64:
240 seh_x64_write_xdata ();
241 break;
242 }
243}
244
245static void
246seh_x64_make_prologue_element (int kind, int reg, bfd_vma off)
247{
248 seh_prologue_element *n;
249 if (seh_ctx_cur == NULL)
250 return;
251 if (seh_ctx_cur->elems_count == seh_ctx_cur->elems_max)
252 {
253 seh_ctx_cur->elems = (seh_prologue_element *)
254 xrealloc (seh_ctx_cur->elems,
255 ((seh_ctx_cur->elems_max + 8) * sizeof (seh_prologue_element)));
256 seh_ctx_cur->elems_max += 8;
257 }
258 n = &seh_ctx_cur->elems[seh_ctx_cur->elems_count];
259 memset (n, 0, sizeof (seh_prologue_element));
260 n->kind = kind;
261 n->reg = reg;
262 n->offset = off;
263 n->pc_symbol = make_seh_text_label (seh_ctx_cur, &(n->pc_addr));
264 seh_ctx_cur->elems_count += 1;
265}
266
267static int
268seh_x64_read_reg (const char *tok, int kind, int *regno)
269{
270 static const char *frame_regs[16] =
271 { "cfa", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
272 "r8","r9","r10","r11","r12","r13","r14","r15" };
273 static const char *int_regs[16] =
274 { "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
275 "r8","r9","r10","r11","r12","r13","r14","r15" };
276 static const char *xmm_regs[16] =
277 { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
278 "xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" };
279 static const char *mm_regs[16] =
280 { "xmm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7",
281 "xmm8", "mm9", "mm10","mm11","mm12","mm13","mm14","mm15" };
282 const char **p = NULL;
283 char name_end;
284 char *symbol_name = NULL;
285 int i;
286
287 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
288 input_line_pointer++;
289 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
290 input_line_pointer++;
291 switch (kind)
292 {
293 case 0:
294 p = frame_regs;
295 break;
296 case 1:
297 p = int_regs;
298 break;
299 case 2:
300 p = mm_regs;
301 break;
302 case 3:
303 p = xmm_regs;
304 break;
305 default:
306 abort ();
307 }
308 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
309 {
310 return 0;
311 }
312 if (*input_line_pointer == '%')
313 ++input_line_pointer;
314 symbol_name = input_line_pointer;
315 name_end = get_symbol_end ();
316 for (i = 0; i < 16; i++)
317 {
318 if (! strcasecmp (p[i], symbol_name))
319 break;
320 }
321 if (i == 16)
322 {
323 as_warn (_("In %s we found the invalid register name %s.\n"),
324 tok, symbol_name);
325 }
326 *input_line_pointer = name_end;
327 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
328 input_line_pointer++;
329 if (*input_line_pointer == ',')
330 ++input_line_pointer;
331 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
332 input_line_pointer++;
333 *regno = i;
334 return i != 16;
335}
336
337static int
338seh_read_offset (const char *tok, bfd_vma *off)
339{
340 bfd_vma r, v = 0, base = 10;
341 int had_one = 0;
342
343 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
344 input_line_pointer++;
345 if (*input_line_pointer == '0')
346 {
347 ++input_line_pointer;
348 had_one = 1;
349 base = 8;
350 switch ((*input_line_pointer))
351 {
352 case 'x':
353 case 'X':
354 base = 16;
355 ++input_line_pointer;
356 break;
357 case 'd':
358 case 'D':
359 base = 10;
360 input_line_pointer++;
361 break;
362 case 'o':
363 case 'O':
364 base = 8;
365 input_line_pointer++;
366 break;
367 }
368 }
369 while (*input_line_pointer != 0)
370 {
371 if (input_line_pointer[0] >= '0' && input_line_pointer[0] <='9')
372 r = (bfd_vma) (input_line_pointer[0] - '0');
373 else if (base == 16 && input_line_pointer[0] >= 'a' && input_line_pointer[0] <='f')
374 r = (bfd_vma) ((input_line_pointer[0] - 'a') + 10);
375 else if (base == 16 && input_line_pointer[0] >= 'A' && input_line_pointer[0] <='F')
376 r = (bfd_vma) ((input_line_pointer[0] - 'A') + 10);
377 else
378 break;
379 input_line_pointer++;
380 v *= base;
381 v += r;
382 had_one = 1;
383 }
384 *off = v;
385 if (had_one == 0)
386 {
387 as_warn (_("In %s we expect a number.\n"),
388 tok);
389 }
390 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
391 input_line_pointer++;
392 if (*input_line_pointer == ',')
393 ++input_line_pointer;
394 while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
395 input_line_pointer++;
396 return had_one != 0;
397}
398
399static void
400obj_coff_seh_32 (int what)
401{
402 if (seh_ctx_cur == NULL)
403 {
404 as_fatal (_(".seh_eh requires to be in .seh_proc/.seh_endproc block.\n"));
405 demand_empty_rest_of_line ();
406 return;
407 }
408 seh_ctx_cur->use_instruction_32 = (what ? 1 : 0);
409 if (seh_get_target_kind () == seh_kind_arm)
410 as_warn (_(".seh_%s32 is ignored for this target."), (what ? "" : "no"));
411 demand_empty_rest_of_line ();
412}
413
414static void
415obj_coff_seh_eh (int what ATTRIBUTE_UNUSED)
416{
417 if (seh_ctx_cur == NULL)
418 {
419 as_fatal (_(".seh_eh requires to be in .seh_proc/.seh_endproc block.\n"));
420 demand_empty_rest_of_line ();
421 return;
422 }
423 if (seh_get_target_kind () == seh_kind_arm)
424 {
425 seh_ctx_cur->handler_written = 1;
426 /* write block to .text if exception handler is set. */
427 seh_write_text_eh_data (seh_ctx_cur->handler_name, seh_ctx_cur->handler_data_name);
428 }
429 demand_empty_rest_of_line ();
430}
431
432static void
433obj_coff_seh_handler (int what ATTRIBUTE_UNUSED)
434{
435 char *symbol_name;
436 char name_end;
437
438 if (seh_ctx_cur == NULL)
439 {
440 as_fatal (_(".seh_handler requires to be in .seh_proc/.seh_endproc block.\n"));
441 demand_empty_rest_of_line ();
442 return;
443 }
444 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
445 {
446 as_fatal (_(".seh_handler requires a handler lable name.\n"));
447 demand_empty_rest_of_line ();
448 return;
449 }
450
451 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
452 input_line_pointer++;
453 symbol_name = input_line_pointer;
454 name_end = get_symbol_end ();
455 seh_ctx->handler_name = xstrdup (symbol_name);
456 if (symbol_name[0] == '@')
457 {
458 if (strcasecmp (symbol_name, "@0") != 0 && strcasecmp (symbol_name, "@1") != 0
459 && strcasecmp (symbol_name, "@null") != 0)
460 as_warn (_("Unknown constant value ,%s' for handler."), symbol_name);
461 }
462 *input_line_pointer = name_end;
463 seh_ctx->handler_data_name = NULL;
464 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
465 input_line_pointer++;
466 symbol_name = input_line_pointer;
467 if (*input_line_pointer != '\n' && *input_line_pointer != 0)
468 {
469 name_end = get_symbol_end ();
470 seh_ctx->handler_data_name = xstrdup (symbol_name);
471 if (symbol_name[0] == '@')
472 {
473 if (seh_get_target_kind () != seh_kind_x64)
474 as_fatal (_("For this target .seh_handler doesn't support constant user-data."));
475 else if (strcasecmp (symbol_name, "@unwind") != 0 &&
476 strcasecmp (symbol_name, "@except") != 0)
477 as_warn (_("For .seh_handler the constant ,%s' is ignored."), symbol_name);
478 }
479 *input_line_pointer = name_end;
480 }
481 if (seh_ctx_cur->handler_written)
482 as_warn (_(".seh_handler is ignored as .seh_eh was seen before."));
483 demand_empty_rest_of_line ();
484}
485
486static void
487obj_coff_seh_scope (int what ATTRIBUTE_UNUSED)
488{
489 char *symbol_name,*beg = NULL,*end = NULL, *handl = NULL, *jmp = NULL;
490 char name_end;
491
492 if (seh_ctx_cur == NULL)
493 {
494 as_fatal (_(".seh_scope requires to be in .seh_proc/.seh_endproc block.\n"));
495 demand_empty_rest_of_line ();
496 return;
497 }
498
499 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
500 input_line_pointer++;
501 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
502 {
503 as_fatal (_(".seh_scope requires four symbol names.\n"));
504 demand_empty_rest_of_line ();
505 return;
506 }
507 symbol_name = input_line_pointer;
508 name_end = get_symbol_end ();
509 beg = xstrdup (symbol_name);
510 *input_line_pointer = name_end;
511 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
512 input_line_pointer++;
513 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
514 {
515 as_fatal (_(".seh_scope requires three more symbol names.\n"));
516 demand_empty_rest_of_line ();
517 return;
518 }
519 symbol_name = input_line_pointer;
520 name_end = get_symbol_end ();
521 end = xstrdup (symbol_name);
522 *input_line_pointer = name_end;
523 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
524 input_line_pointer++;
525 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
526 {
527 as_fatal (_(".seh_scope requires two more symbol names.\n"));
528 demand_empty_rest_of_line ();
529 return;
530 }
531 symbol_name = input_line_pointer;
532 name_end = get_symbol_end ();
533 handl = xstrdup (symbol_name);
534 *input_line_pointer = name_end;
535 if (*handl == '@')
536 {
537 if (strcasecmp (handl, "@0") != 0 && strcasecmp (handl, "@1") != 0
538 && strcasecmp (handl, "@null") != 0)
539 as_warn (_("Unknown constant for handler ,%s'."), handl);
540 }
541
542 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
543 input_line_pointer++;
544 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
545 {
546 as_fatal (_(".seh_scope requires one more symbol names.\n"));
547 demand_empty_rest_of_line ();
548 return;
549 }
550 symbol_name = input_line_pointer;
551 name_end = get_symbol_end ();
552 jmp = xstrdup (symbol_name);
553 *input_line_pointer = name_end;
554 if (*jmp == '@')
555 {
556 if (strcasecmp (jmp, "@0") != 0 && strcasecmp (handl, "@null") != 0)
557 as_warn (_("Unknown constant for jump ,%s'."), jmp);
558 }
559
560 if (seh_get_target_kind () != seh_kind_x64)
561 as_warn (_(".seh_scope is ignored for this target."));
562 else
563 seh_x64_makescope_elem (seh_ctx_cur, beg, end, handl, jmp);
564 if (beg)
565 free (beg);
566 if (end)
567 free (end);
568 if (handl)
569 free (handl);
570 if (jmp)
571 free (jmp);
572 demand_empty_rest_of_line ();
573}
574
575static void
576obj_coff_seh_proc (int what ATTRIBUTE_UNUSED)
577{
578 char *symbol_name;
579 char name_end;
580
581 if (seh_ctx_cur != NULL)
582 {
583 as_warn (_(".seh_proc has to be closed by .seh_endprog\n"));
584 obj_coff_seh_endproc (0);
585 }
586
587 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
588 {
589 as_fatal (_(".seh_proc requires function lable name.\n"));
590 demand_empty_rest_of_line ();
591 return;
592 }
593
594 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
595 input_line_pointer++;
596 symbol_name = input_line_pointer;
597 name_end = get_symbol_end ();
598
599 if (seh_ctx == NULL)
600 seh_ctx_root = seh_ctx = (seh_context *) xmalloc (sizeof (seh_context));
601 else
602 {
603 seh_ctx->next = (seh_context *) xmalloc (sizeof (seh_context));
604 seh_ctx = seh_ctx->next;
605 }
606 seh_ctx_cur = seh_ctx;
607 memset (seh_ctx, 0, sizeof (seh_context));
608
609 seh_ctx->func_name = xstrdup (symbol_name);
610 *input_line_pointer = name_end;
611 while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',')
612 input_line_pointer++;
613 seh_ctx->start_symbol = make_seh_text_label (seh_ctx_cur, &(seh_ctx_cur->start_addr));
614 demand_empty_rest_of_line ();
615}
616
617static void
618obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED)
619{
620 if (seh_ctx_cur == NULL)
621 {
622 as_warn (_(".seh_endprog without prior .seh_proc (ignored)\n"));
623 demand_empty_rest_of_line ();
624 return;
625 }
626 seh_ctx->end_symbol = make_seh_text_label (seh_ctx, &(seh_ctx->end_addr));
627 seh_ctx->xdata_first = seh_make_xlbl_name (seh_ctx);
628 make_function_entry_pdata (seh_ctx);
629 seh_ctx_cur = NULL;
630 demand_empty_rest_of_line ();
631}
632
633static void
634obj_coff_seh_push (int what)
635{
636 int reg = 0;
637 int kind = -1;
638 if (seh_ctx_cur == NULL)
639 {
640 as_warn (_(".seh_push used outside of .seh_proc block.\n"));
641 demand_empty_rest_of_line ();
642 return;
643 }
644 /* what 0:reg, 1:pushframe. */
645 switch (what)
646 {
647 case 0:
648 if (seh_x64_read_reg (".seh_push", 1, &reg))
649 kind = UWOP_PUSH_NONVOL;
650 else
651 as_warn (_(".seh_pushreg expects register argument."));
652 break;
653 case 1:
654 kind = UWOP_PUSH_MACHFRAME;
655 break;
656 default:
657 abort ();
658 }
659 if (seh_get_target_kind () != seh_kind_x64)
660 as_warn (_(".seh_save... is ignored for this target.\n"));
661 else if (kind != -1)
662 seh_x64_make_prologue_element (kind, reg, 0);
663 demand_empty_rest_of_line ();
664}
665
666static void
667obj_coff_seh_save (int what)
668{
669 int reg;
670 bfd_vma off;
671 int kind;
672 int ok = 1;
673
674 /* what 0:reg, 1:mm, 2:xmm. */
675 switch (what)
676 {
677 case 0:
678 ok &= seh_x64_read_reg (".seh_savereg", 1, &reg);
679 kind = UWOP_SAVE_NONVOL;
680 break;
681 case 1:
682 ok &= seh_x64_read_reg (".seh_savemm", 2, &reg);
683 kind = UWOP_SAVE_XMM;
684 break;
685 case 2:
686 ok &= seh_x64_read_reg (".seh_savexmm", 3, &reg);
687 kind = UWOP_SAVE_XMM128;
688 break;
689 default:
690 abort ();
691 }
692 ok &= seh_read_offset (".seh_save", &off);
693 if (seh_ctx_cur == NULL)
694 {
695 as_warn (_(".seh_save used outside of .seh_proc block.\n"));
696 demand_empty_rest_of_line ();
697 return;
698 }
699 if (seh_get_target_kind () != seh_kind_x64)
700 as_warn (_(".seh_save... is ignored for this target.\n"));
701 else
702 seh_x64_make_prologue_element (kind, reg, off);
703 demand_empty_rest_of_line ();
704}
705
706static void
707obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED)
708{
709 if (seh_ctx_cur == NULL)
710 {
711 as_warn (_(".seh_endprologue used outside of .seh_proc block.\n"));
712 demand_empty_rest_of_line ();
713 return;
714 }
715 if (seh_ctx_cur->endprologue_symbol != NULL)
716 as_warn (_(".seh_endprologue used more then once in .seh_proc block.\n"));
717 else
718 seh_ctx_cur->endprologue_symbol = make_seh_text_label (seh_ctx_cur, &seh_ctx_cur->endprologue_addr);
719}
720
721static void
722obj_coff_seh_stack_alloc (int what ATTRIBUTE_UNUSED)
723{
724 bfd_vma size;
725 if (seh_ctx_cur == NULL)
726 {
727 as_warn (_(".seh_stackalloc used outside of .seh_proc block.\n"));
728 demand_empty_rest_of_line ();
729 return;
730 }
731 if (seh_read_offset (".seh_stackalloc", &size))
732 {
733 if (seh_get_target_kind () != seh_kind_x64)
734 as_warn (_(".seh_stackalloc is ignored for this target.\n"));
735 else
736 seh_x64_make_prologue_element (UWOP_ALLOC_LARGE, 0, size);
737 }
738}
739
740static void
741obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED)
742{
743 int reg;
744 int ok = 1;
745 bfd_vma off;
746
747 ok &= seh_x64_read_reg (".seh_setframe", 0, &reg);
748 ok &= seh_read_offset (".seh_setframe", &off);
749 if (seh_ctx_cur == NULL)
750 {
751 as_warn (_(".seh_setframe used outside of .seh_proc block.\n"));
752 demand_empty_rest_of_line ();
753 return;
754 }
755 if (ok)
756 {
757 seh_ctx_cur->framereg = reg;
758 seh_ctx_cur->frameoff = off;
759 }
760 if (seh_get_target_kind () != seh_kind_x64)
761 as_warn (_(".seh_setframe is ignored for this target.\n"));
762 demand_empty_rest_of_line ();
763}
764
765/* Misc function helpers. */
766static void
767seh_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx)
768{
769 if (relcount >= relsize - 1)
770 {
771 relsize += 10;
772 if (reltab)
773 reltab = xrealloc (reltab, relsize * sizeof (arelent));
774 else
775 reltab = xmalloc (relsize * sizeof (arelent));
776 }
777 reltab[relcount].address = address;
778 reltab[relcount].addend = 0;
779 reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto);
780 reltab[relcount].sym_ptr_ptr = symtab + symidx;
781 relcount++;
782}
783
784static void
785save_relocs (asection *sec)
786{
787 int i;
788
789 sec->relocation = reltab;
790 sec->reloc_count = relcount;
791 sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *));
792 for (i = 0; i < relcount; i++)
793 sec->orelocation[i] = sec->relocation + i;
794 sec->orelocation[relcount] = 0;
795 sec->flags |= SEC_RELOC;
796 reltab = 0;
797 relcount = relsize = 0;
798}
799
800static void
801seh_symbol_init (bfd *abfd, unsigned int added)
802{
803 unsigned int oldcount;
804 oldcount = bfd_get_symcount (abfd);
805 symptr = oldcount;
806 symtab = xmalloc ((oldcount + added + 6) * sizeof (asymbol *));
807 if (oldcount > 0)
808 memcpy (symtab, bfd_get_outsymbols (abfd), sizeof (asymbol *) * oldcount);
809}
810
811static int
812seh_symbol (bfd *abfd, const char *n1, const char *n2, const char *n3,
813 asection *sec, int flags, int addr)
814{
815 asymbol *sym;
816 char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1);
817 int ret = symptr;
818 strcpy (name, n1);
819 strcat (name, n2);
820 strcat (name, n3);
821 sym = bfd_make_empty_symbol (abfd);
822 sym->name = name;
823 sym->section = sec;
824 sym->flags = flags;
825 sym->value = addr;
826 symtab[symptr++] = sym;
827 return ret;
828}
829
830static asection *
831quick_section (bfd *abfd, const char *name, int flags, int align)
832{
833 asection *sec;
834 asymbol *sym;
835 sec = seh_make_section2 (name, flags);
836 bfd_set_section_alignment (abfd, sec, align);
837 /* Remember to undo this before trying to link internally! */
838
839 sym = bfd_make_empty_symbol (abfd);
840 symtab[symptr++] = sym;
841 sym->name = sec->name;
842 sym->section = sec;
843 sym->flags = BSF_LOCAL;
844 sym->value = 0;
845
846 return sec;
847}
848
849static seh_kind
850seh_get_target_kind (void)
851{
852 if (!stdoutput)
853 return seh_kind_unknown;
854 switch (bfd_get_arch (stdoutput))
855 {
856 case bfd_arch_arm:
857 case bfd_arch_powerpc:
858 case bfd_arch_sh:
859 return seh_kind_arm;
860 case bfd_arch_i386:
861 switch (bfd_get_mach (stdoutput))
862 {
863 case bfd_mach_x86_64:
864 case bfd_mach_x86_64_intel_syntax:
865 return seh_kind_x64;
866 default:
867 break;
868 }
869 /* FALL THROUGH. */
870 case bfd_arch_mips:
871 return seh_kind_mips;
872 case bfd_arch_ia64:
873 /* Should return seh_kind_x64. But not implemented yet. */
874 return seh_kind_unknown;
875 default:
876 break;
877 }
878 return seh_kind_unknown;
879}
880
881static void
882seh_emit_rva (const char *name)
883{
884 char *p = (char *) xmalloc (strlen (name) + 1);
885 char *s = input_line_pointer;
886
887 strcpy (p, name);
888 input_line_pointer = p;
889 s_rva (4);
890 input_line_pointer = s;
891}
892
893static void
894seh_emit_long (const char *name)
895{
896 char *p = (char *) xmalloc (strlen (name) + 1);
897 char *s = input_line_pointer;
898
899 strcpy (p, name);
900 input_line_pointer = p;
901 cons (4);
902 input_line_pointer = s;
903}
904
905static void
906seh_make_globl (char *sym_name)
907{
908 char *s = input_line_pointer;
909
910 input_line_pointer = sym_name;
911 s_globl (4);
912 input_line_pointer = s;
913}
914
915static segT
916seh_make_section2 (const char *section_name, unsigned flags)
917{
918 char *name;
919 segT sec;
920
921 name = xmalloc (strlen (section_name) + 1);
922 strcpy (name, section_name);
923
924 sec = subseg_new (name, (subsegT) 0);
925 bfd_set_section_flags (stdoutput, sec,
926 ((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA | flags)
927 & bfd_applicable_section_flags (stdoutput)));
928
929 return sec;
930}
931
932static segT
933seh_make_section (void)
934{
935 static segT seg_pdata = NULL;
936 segT sec = NULL;
937
938 if (!seg_pdata)
939 seg_pdata = seh_make_section2 (".pdata", 0);
940 sec = seg_pdata;
941 return sec;
942}
943
944static char *
945seh_make_xlbl_name (seh_context *c)
946{
947 size_t len = strlen (".seh_xlbl_") + strlen (c->func_name) + 9 + 1;
948 char *ret = (char*) xmalloc (len);
949 if (!ret)
950 as_fatal (_("Out of memory for xdata lable for %s"), c->func_name);
951 else
952 sprintf (ret, ".seh_xlbl_%s_%x", c->func_name, + c->xlbl_count);
953 c->xlbl_count += 1;
954 return ret;
955}
956
957static char *
958make_seh_text_label (seh_context *c, symbolS **addr)
959{
960 char *sym_name;
961 size_t len = strlen (".seh_tlbl_") + strlen (c->func_name) + 9 + 1;
962 sym_name = (char *) xmalloc (len);
963 if (!sym_name)
964 as_fatal (_("Allocating memory for SEH's text symbol for %s failed"), c->func_name);
965 sprintf (sym_name, ".seh_tlbl_%s_%x", c->func_name, c->tlbl_count);
966 c->tlbl_count += 1;
967 if (addr)
968 {
969 seh_make_globl (sym_name);
970 *addr = colon (sym_name);
971 }
972 return sym_name;
973}
974
975/* x64 secific functions. */
976
977static void
978seh_fill_pcsyms (const seh_context *c, char **names, int *idx)
979{
980 size_t i;
981 int count = 1;
982 valueT start_off = resolve_symbol_value (c->start_addr);
983 valueT un_off;
984 seh_prologue_element *e = c->elems;
985 names[0] = c->start_symbol;
986 idx[0] = 0;
987 if (c->elems_count == 0)
988 return;
989 for (i = 0; i < c->elems_count; i++)
990 {
991 un_off = resolve_symbol_value (e[i].pc_addr);
992 if ((un_off - start_off) > 255)
993 {
994 names[count] = e[i].pc_symbol;
995 idx[count] = (int) i;
996 count++;
997 start_off = un_off;
998 }
999 }
1000}
1001
1002static int
1003seh_needed_unwind_info (seh_context *c)
1004{
1005 size_t i;
1006 int count = 1;
1007 valueT start_off = resolve_symbol_value (c->start_addr);
1008 valueT un_off;
1009 seh_prologue_element *e = c->elems;
1010 if (c->elems_count == 0)
1011 return count;
1012 for (i = 0; i < c->elems_count; i++)
1013 {
1014 un_off = resolve_symbol_value (e[i].pc_addr);
1015 if ((un_off - start_off) > 255)
1016 {
1017 count++;
1018 start_off = un_off;
1019 }
1020 }
1021 return count;
1022}
1023
1024static size_t
1025seh_getelm_data_size (const seh_context *c, int elm_start, int elm_end)
1026{
1027 size_t ret = PEX64_UWI_SIZEOF_UWCODE_ARRAY (elm_end - elm_start);
1028 while (elm_start < elm_end)
1029 {
1030 switch (c->elems[elm_start].kind)
1031 {
1032 case UWOP_PUSH_NONVOL:
1033 case UWOP_PUSH_MACHFRAME:
1034 ret += 2;
1035 break;
1036 case UWOP_SAVE_NONVOL:
1037 case UWOP_SAVE_XMM:
1038 case UWOP_SAVE_XMM128:
1039 if ((c->elems[elm_start].offset & 7) != 0 ||
1040 ((c->elems[elm_start].offset / 8) > 0xffff))
1041 ret += 6;
1042 else
1043 ret += 4;
1044 break;
1045 case UWOP_ALLOC_LARGE:
1046 ret += 4;
1047 break;
1048 default:
1049 break;
1050 }
1051 elm_start++;
1052 }
1053 return ret;
1054}
1055
1056static size_t
1057seh_getsize_of_unwind_entry (seh_context *c, int elm_start, int elm_end, int bechain)
1058{
1059 size_t ret = seh_getelm_data_size(c, elm_start, elm_end);
1060 c->count_syms += 1;
1061 if (bechain)
1062 {
1063 ret += 4 + 4;
1064 c->count_syms += 1;
1065 c->count_reloc += 1;
1066 }
1067 else
1068 {
1069 ret += 4;
1070 if (c->handler_name != NULL)
1071 {
1072 if (c->handler_data_name != NULL
1073 && c->handler_data_name[0] != '@')
1074 {
1075 ret += 4;
1076 c->count_syms += 2;
1077 c->count_reloc += 2;
1078 }
1079 else
1080 {
1081 ret += 8 + (c->scope_count * 4) * 4;
1082 c->count_syms += (c->scope_count * 4) + 1;
1083 c->count_reloc += (c->scope_count * 4) + 1;
1084 }
1085 }
1086 }
1087 return ret;
1088}
1089
1090static void
1091seh_make_unwind_entry (const seh_context *c, char *name, int elm_start, int elm_end, int bechain,
1092 unsigned char *data, size_t *poffs, int no)
1093{
1094 size_t off = *poffs;
1095 size_t it;
1096 valueT start_off = resolve_symbol_value (c->start_addr);
1097 valueT end_prologue;
1098 size_t uwcodes = seh_getelm_data_size(c, elm_start, elm_end);
1099 unsigned int flag = UNW_FLAG_NHANDLER;
1100 int idx;
1101
1102 if (c->handler_name != NULL)
1103 {
1104 flag = UNW_FLAG_EHANDLER;
1105 if (c->handler_data_name != NULL && c->handler_data_name[0] != '@')
1106 flag = UNW_FLAG_FHANDLER;
1107 else if (c->handler_data_name != NULL &&
1108 strcasecmp (c->handler_data_name, "@unwind") == 0)
1109 flag = UNW_FLAG_UHANDLER;
1110 }
1111 if (!c->endprologue_addr)
1112 end_prologue = start_off;
1113 else
1114 end_prologue = resolve_symbol_value (c->endprologue_addr);
1115 seh_symbol (c->abfd, name, "", "", c->section, BSF_GLOBAL, (int) off);
1116 data[off++] = (1 | ((bechain ? UNW_FLAG_CHAININFO : flag) << 3));
1117 if (elm_start != 0)
1118 start_off = (valueT) c->elems[elm_start].offset;
1119 end_prologue -= start_off;
1120 if (end_prologue > 255)
1121 end_prologue = 255;
1122 data[off++] = (unsigned char) end_prologue;
1123 data[off++] = (unsigned char) (uwcodes / 2);
1124 data[off] = (unsigned char) c->framereg;
1125 data[off++] |= (unsigned char) ((c->frameoff / 16) << 4);
1126 off += uwcodes;
1127 if (bechain)
1128 {
1129 char n[100];
1130 sprintf (n,"%x", no);
1131 idx = seh_symbol (c->abfd, ".xdata_fct", c->func_name, n, UNDSEC, BSF_GLOBAL, (int) off);
1132 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1133 off += 4;
1134 }
1135 else if (c->handler_name != NULL)
1136 {
1137 if (flag == UNW_FLAG_FHANDLER)
1138 {
1139 if (strcasecmp (c->handler_name, "@1") == 0)
1140 bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]);
1141 else if (c->handler_name[0] != '@')
1142 {
1143 idx = seh_symbol (c->abfd, c->handler_name, "", "", UNDSEC, BSF_GLOBAL, 0);
1144 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1145 }
1146 off += 4;
1147 idx = seh_symbol (c->abfd, c->handler_data_name, "", "", UNDSEC, BSF_GLOBAL, 0);
1148 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1149 off += 4;
1150 }
1151 else if (flag == UNW_FLAG_UHANDLER || flag == UNW_FLAG_EHANDLER)
1152 {
1153 if (strcasecmp (c->handler_name, "@1") == 0)
1154 bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]);
1155 else if (c->handler_name[0] != '@')
1156 {
1157 idx = seh_symbol (c->abfd, c->handler_name, "", "", UNDSEC, BSF_GLOBAL, 0);
1158 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1159 }
1160 off += 4;
1161 bfd_put_32 (c->abfd, (bfd_vma) c->scope_count, &data[off]);
1162 off += 4;
1163 for (it = 0; it < c->scope_count; it++)
1164 {
1165 idx = seh_symbol (c->abfd, c->scopes[it].begin_addr, "", "", UNDSEC, BSF_GLOBAL, 0);
1166 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1167 off += 4;
1168 idx = seh_symbol (c->abfd, c->scopes[it].end_addr, "", "", UNDSEC, BSF_GLOBAL, 0);
1169 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1170 off += 4;
1171 if (c->scopes[it].handler_addr[0] == '@')
1172 {
1173 if (strcasecmp (c->scopes[it].handler_addr, "@1") == 0)
1174 bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]);
1175 }
1176 else
1177 {
1178 idx = seh_symbol (c->abfd, c->scopes[it].handler_addr, "", "", UNDSEC, BSF_GLOBAL, 0);
1179 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1180 }
1181 off += 4;
1182 if (c->scopes[it].jump_addr[0] == '@')
1183 {
1184 if (strcasecmp (c->scopes[it].jump_addr, "@1") == 0)
1185 bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]);
1186 }
1187 else
1188 {
1189 idx = seh_symbol (c->abfd, c->scopes[it].jump_addr, "", "", UNDSEC, BSF_GLOBAL, 0);
1190 seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx);
1191 }
1192 off += 4;
1193 }
1194 }
1195 }
1196 *poffs = off;
1197}
1198
1199static size_t
1200seh_getsize_unwind_data (seh_context *c)
1201{
1202 int need = seh_needed_unwind_info (c);
1203 int i;
1204 char **names = (char **) xmalloc (sizeof (char *) * need);
1205 char **pc_syms = (char **) xmalloc (sizeof (char *) * need);
1206 int *elm_start = (int *) xmalloc (sizeof (int) * (need + 1));
1207 size_t xdata_sz = 0;
1208
1209 seh_fill_pcsyms (c, pc_syms, elm_start);
1210 elm_start[need] = c->elems_count;
1211
1212 xdata_sz += ((12 * (size_t) need));
1213 c->count_syms += 5 * need;
1214 xdata_sz += (seh_getsize_of_unwind_entry (c, elm_start[0], elm_start[1], 1 != need) + 7) & ~7;
1215 for (i = 1; i < need; i++)
1216 {
1217 xdata_sz += (seh_getsize_of_unwind_entry (c, elm_start[i], elm_start[i + 1], 1 != need) + 7) & ~7;
1218 }
1219
1220 /* Create lable names for .xdata unwind info. */
1221 names[0] = c->xdata_first;
1222 for (i = 1; i < need; i++)
1223 names[i] = seh_make_xlbl_name (c);
1224 c->xdata_names = names;
1225 c->xdata_pcsyms = pc_syms;
1226 c->xdata_elm_start = elm_start;
1227 c->xdata_sz = xdata_sz;
1228 return xdata_sz;
1229}
1230
1231static void
1232seh_create_unwind_data (seh_context *c, unsigned char *data, size_t offs)
1233{
1234 int need = seh_needed_unwind_info (c);
1235 int i;
1236 char **names = c->xdata_names;
1237 char **pc_syms = c->xdata_pcsyms;
1238 int *elm_start = c->xdata_elm_start;
1239
1240 for (i = 1; i < need; i++)
1241 {
1242 seh_make_function_entry_xdata (c, pc_syms[i], c->end_symbol, names[i], data, &offs, i);
1243 }
1244 /* Generate the function entry. Remark, that just
1245 first is in .pdata section and already emitted. */
1246 seh_make_unwind_entry (c, c->xdata_first, elm_start[0], elm_start[1], 1 != need, data, &offs, 1);
1247 for (i = 1; i < need; i++)
1248 {
1249 seh_make_unwind_entry (c, names[i], elm_start[i], elm_start[i + 1], (i + 1) != need, data, &offs, i + 1);
1250 }
1251 for (i = 1; i < need; i++)
1252 free (names[i]);
1253 free (names);
1254 free (pc_syms);
1255 free (elm_start);
1256 c->xdata_names = NULL;
1257 c->xdata_pcsyms = NULL;
1258 c->xdata_elm_start = NULL;
1259}
1260
1261static void
1262seh_make_function_entry_xdata (seh_context *c, char *pc_start, char *pc_end, char *pc_xdata, unsigned char *data, size_t *poffs,int no)
1263{
1264 bfd_vma addr = (bfd_vma) *poffs;
1265 int idx;
1266 char s[100];
1267 if (!data)
1268 return;
1269 sprintf (s,"%x",no);
1270 seh_symbol (c->abfd, ".xdata_fct",c->func_name, s, c->section, BSF_GLOBAL, (int) poffs[0]);
1271 idx = seh_symbol (c->abfd, pc_start,"","", UNDSEC, BSF_GLOBAL,0);
1272 seh_reloc (c->abfd, addr, BFD_RELOC_RVA, idx);
1273 idx = seh_symbol (c->abfd, pc_end,"","", UNDSEC, BSF_GLOBAL,0);
1274 seh_reloc (c->abfd, addr + 4, BFD_RELOC_RVA, idx);
1275 idx = seh_symbol (c->abfd, pc_xdata,"","", UNDSEC, BSF_GLOBAL,0);
1276 seh_reloc (c->abfd, addr + 8, BFD_RELOC_RVA, idx);
1277 poffs[0] += 12;
1278}
1279
1280static seh_scope_elem *
1281seh_x64_makescope_elem (seh_context *c, const char *begin, const char *end,
1282 const char *handler, const char *jmp)
1283{
1284 seh_scope_elem *r;
1285 if (!end || !begin)
1286 return NULL;
1287 if (c->scope_count >= c->scope_max)
1288 {
1289 seh_scope_elem *h = (seh_scope_elem *) xmalloc (sizeof (seh_scope_elem) * (c->scope_max + 8));
1290 memset (h, 0, sizeof (seh_scope_elem) * (c->scope_max + 8));
1291 if (c->scopes != NULL)
1292 memcpy (h, c->scopes, sizeof (seh_scope_elem) * c->scope_max);
1293 if (c->scopes != NULL)
1294 free (c->scopes);
1295 c->scopes = h;
1296 c->scope_max += 8;
1297 }
1298 r = &c->scopes[c->scope_count++];
1299 r->begin_addr = xstrdup (begin);
1300 r->end_addr = xstrdup (end);
1301 r->handler_addr = (!handler ? NULL : xstrdup (handler));
1302 r->jump_addr = (!jmp ? NULL : xstrdup (jmp));
1303 return r;
1304}
GDB Binutils - Deliverables
This page took 0.07034 seconds and 4 git commands to generate.