gas/config/obj-coff-seh.c

   1 /* seh pdata/xdata coff object file format
   2    Copyright 2009, 2010
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GAS.
   6
   7    GAS is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3, or (at your option)
  10    any later version.
  11
  12    GAS is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GAS; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  20    02110-1301, USA.  */
  21
  22 #include "obj-coff-seh.h"
  23
  24
  25 /* Private segment collection list.  */
  26 struct seh_seg_list {
  27   segT seg;
  28   int subseg;
  29   char *seg_name;
  30 };
  31
  32 /* Local data.  */
  33 static seh_context *seh_ctx_cur = NULL;
  34
  35 static struct hash_control *seh_hash;
  36
  37 static struct seh_seg_list *x_segcur = NULL;
  38 static struct seh_seg_list *p_segcur = NULL;
  39
  40 static void write_function_xdata (seh_context *);
  41 static void write_function_pdata (seh_context *);
  42
  43 \f
  44 /* Build based on segment the derived .pdata/.xdata
  45    segment name containing origin segment's postfix name part.  */
  46 static char *
  47 get_pxdata_name (segT seg, const char *base_name)
  48 {
  49   const char *name,*dollar, *dot;
  50   char *sname;
  51
  52   name = bfd_get_section_name (stdoutput, seg);
  53
  54   dollar = strchr (name, '$');
  55   dot = strchr (name + 1, '.');
  56
  57   if (!dollar && !dot)
  58     name = "";
  59   else if (!dollar)
  60     name = dot;
  61   else if (!dot)
  62     name = dollar;
  63   else if (dot < dollar)
  64     name = dot;
  65   else
  66     name = dollar;
  67
  68   sname = concat (base_name, name, NULL);
  69
  70   return sname;
  71 }
  72
  73 /* Allocate a seh_seg_list structure.  */
  74 static struct seh_seg_list *
  75 alloc_pxdata_item (segT seg, int subseg, char *name)
  76 {
  77   struct seh_seg_list *r;
  78
  79   r = (struct seh_seg_list *)
  80     xmalloc (sizeof (struct seh_seg_list) + strlen (name));
  81   r->seg = seg;
  82   r->subseg = subseg;
  83   r->seg_name = name;
  84   return r;
  85 }
  86
  87 /* Generate pdata/xdata segment with same linkonce properties
  88    of based segment.  */
  89 static segT
  90 make_pxdata_seg (segT cseg, char *name)
  91 {
  92   segT save_seg = now_seg;
  93   int save_subseg = now_subseg;
  94   segT r;
  95   flagword flags;
  96
  97   r = subseg_new (name, 0);
  98   /* Check if code segment is marked as linked once.  */
  99   flags = bfd_get_section_flags (stdoutput, cseg)
 100     & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
 101        | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
 102        | SEC_LINK_DUPLICATES_SAME_CONTENTS);
 103
 104   /* Add standard section flags.  */
 105   flags |= SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA;
 106
 107   /* Apply possibly linked once flags to new generated segment, too.  */
 108   if (!bfd_set_section_flags (stdoutput, r, flags))
 109     as_bad (_("bfd_set_section_flags: %s"),
 110             bfd_errmsg (bfd_get_error ()));
 111
 112   /* Restore to previous segment.  */
 113   subseg_set (save_seg, save_subseg);
 114   return r;
 115 }
 116
 117 static void
 118 seh_hash_insert (const char *name, struct seh_seg_list *item)
 119 {
 120   const char *error_string;
 121
 122   if ((error_string = hash_jam (seh_hash, name, (char *) item)))
 123     as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
 124               name, error_string);
 125 }
 126
 127 static struct seh_seg_list *
 128 seh_hash_find (char *name)
 129 {
 130   return (struct seh_seg_list *) hash_find (seh_hash, name);
 131 }
 132
 133 static struct seh_seg_list *
 134 seh_hash_find_or_make (segT cseg, const char *base_name)
 135 {
 136   struct seh_seg_list *item;
 137   char *name;
 138
 139   /* Initialize seh_hash once.  */
 140   if (!seh_hash)
 141     seh_hash = hash_new ();
 142
 143   name = get_pxdata_name (cseg, base_name);
 144
 145   item = seh_hash_find (name);
 146   if (!item)
 147     {
 148       item = alloc_pxdata_item (make_pxdata_seg (cseg, name), 0, name);
 149
 150       seh_hash_insert (item->seg_name, item);
 151     }
 152   else
 153     free (name);
 154
 155   return item;
 156 }
 157
 158 /* Check if current segment has same name.  */
 159 static int
 160 seh_validate_seg (const char *directive)
 161 {
 162   const char *cseg_name, *nseg_name;
 163   if (seh_ctx_cur->code_seg == now_seg)
 164     return 1;
 165   cseg_name = bfd_get_section_name (stdoutput, seh_ctx_cur->code_seg);
 166   nseg_name = bfd_get_section_name (stdoutput, now_seg);
 167   as_bad (_("%s used in segment '%s' instead of expected '%s'"),
 168           directive, nseg_name, cseg_name);
 169   ignore_rest_of_line ();
 170   return 0;
 171 }
 172
 173 static void
 174 switch_xdata (int subseg, segT code_seg)
 175 {
 176   x_segcur = seh_hash_find_or_make (code_seg, ".xdata");
 177
 178   subseg_set (x_segcur->seg, subseg);
 179 }
 180
 181 static void
 182 switch_pdata (segT code_seg)
 183 {
 184   p_segcur = seh_hash_find_or_make (code_seg, ".pdata");
 185
 186   subseg_set (p_segcur->seg, p_segcur->subseg);
 187 }
 188 \f
 189 /* Parsing routines.  */
 190
 191 /* Return the style of SEH unwind info to generate.  */
 192
 193 static seh_kind
 194 seh_get_target_kind (void)
 195 {
 196   if (!stdoutput)
 197     return seh_kind_unknown;
 198   switch (bfd_get_arch (stdoutput))
 199     {
 200     case bfd_arch_arm:
 201     case bfd_arch_powerpc:
 202     case bfd_arch_sh:
 203       return seh_kind_arm;
 204     case bfd_arch_i386:
 205       switch (bfd_get_mach (stdoutput))
 206         {
 207         case bfd_mach_x86_64:
 208         case bfd_mach_x86_64_intel_syntax:
 209           return seh_kind_x64;
 210         default:
 211           break;
 212         }
 213       /* FALL THROUGH.  */
 214     case bfd_arch_mips:
 215       return seh_kind_mips;
 216     case bfd_arch_ia64:
 217       /* Should return seh_kind_x64.  But not implemented yet.  */
 218       return seh_kind_unknown;
 219     default:
 220       break;
 221     }
 222   return seh_kind_unknown;
 223 }
 224
 225 /* Verify that we're in the context of a seh_proc.  */
 226
 227 static int
 228 verify_context (const char *directive)
 229 {
 230   if (seh_ctx_cur == NULL)
 231     {
 232       as_bad (_("%s used outside of .seh_proc block"), directive);
 233       ignore_rest_of_line ();
 234       return 0;
 235     }
 236   return 1;
 237 }
 238
 239 /* Similar, except we also verify the appropriate target.  */
 240
 241 static int
 242 verify_context_and_target (const char *directive, seh_kind target)
 243 {
 244   if (seh_get_target_kind () != target)
 245     {
 246       as_warn (_("%s ignored for this target"), directive);
 247       ignore_rest_of_line ();
 248       return 0;
 249     }
 250   return verify_context (directive);
 251 }
 252
 253 /* Skip whitespace and a comma.  Error if the comma is not seen.  */
 254
 255 static int
 256 skip_whitespace_and_comma (int required)
 257 {
 258   SKIP_WHITESPACE ();
 259   if (*input_line_pointer == ',')
 260     {
 261       input_line_pointer++;
 262       SKIP_WHITESPACE ();
 263       return 1;
 264     }
 265   else if (required)
 266     {
 267       as_bad (_("missing separator"));
 268       ignore_rest_of_line ();
 269     }
 270   else
 271     demand_empty_rest_of_line ();
 272   return 0;
 273 }
 274
 275 /* Mark current context to use 32-bit instruction (arm).  */
 276
 277 static void
 278 obj_coff_seh_32 (int what)
 279 {
 280   if (!verify_context_and_target ((what ? ".seh_32" : ".seh_no32"),
 281                                   seh_kind_arm))
 282     return;
 283
 284   seh_ctx_cur->use_instruction_32 = (what ? 1 : 0);
 285   demand_empty_rest_of_line ();
 286 }
 287
 288 /* Set for current context the handler and optional data (arm).  */
 289
 290 static void
 291 obj_coff_seh_eh (int what ATTRIBUTE_UNUSED)
 292 {
 293   if (!verify_context_and_target (".seh_eh", seh_kind_arm))
 294     return;
 295
 296   /* Write block to .text if exception handler is set.  */
 297   seh_ctx_cur->handler_written = 1;
 298   emit_expr (&seh_ctx_cur->handler, 4);
 299   emit_expr (&seh_ctx_cur->handler_data, 4);
 300
 301   demand_empty_rest_of_line ();
 302 }
 303
 304 /* Set for current context the default handler (x64).  */
 305
 306 static void
 307 obj_coff_seh_handler (int what ATTRIBUTE_UNUSED)
 308 {
 309   char *symbol_name;
 310   char name_end;
 311
 312   if (!verify_context (".seh_handler"))
 313     return;
 314
 315   if (*input_line_pointer == 0 || *input_line_pointer == '\n')
 316     {
 317       as_bad (_(".seh_handler requires a handler"));
 318       demand_empty_rest_of_line ();
 319       return;
 320     }
 321
 322   SKIP_WHITESPACE ();
 323
 324   if (*input_line_pointer == '@')
 325     {
 326       symbol_name = input_line_pointer;
 327       name_end = get_symbol_end ();
 328
 329       seh_ctx_cur->handler.X_op = O_constant;
 330       seh_ctx_cur->handler.X_add_number = 0;
 331
 332       if (strcasecmp (symbol_name, "@0") == 0
 333           || strcasecmp (symbol_name, "@null") == 0)
 334         ;
 335       else if (strcasecmp (symbol_name, "@1") == 0)
 336         seh_ctx_cur->handler.X_add_number = 1;
 337       else
 338         as_bad (_("unknown constant value '%s' for handler"), symbol_name);
 339
 340       *input_line_pointer = name_end;
 341     }
 342   else
 343     expression (&seh_ctx_cur->handler);
 344
 345   seh_ctx_cur->handler_data.X_op = O_constant;
 346   seh_ctx_cur->handler_data.X_add_number = 0;
 347   seh_ctx_cur->handler_flags = 0;
 348
 349   if (!skip_whitespace_and_comma (0))
 350     return;
 351
 352   if (seh_get_target_kind () == seh_kind_x64)
 353     {
 354       do
 355         {
 356           symbol_name = input_line_pointer;
 357           name_end = get_symbol_end ();
 358
 359           if (strcasecmp (symbol_name, "@unwind") == 0)
 360             seh_ctx_cur->handler_flags |= UNW_FLAG_UHANDLER;
 361           else if (strcasecmp (symbol_name, "@except") == 0)
 362             seh_ctx_cur->handler_flags |= UNW_FLAG_EHANDLER;
 363           else
 364             as_bad (_(".seh_handler constant '%s' unknown"), symbol_name);
 365
 366           *input_line_pointer = name_end;
 367         }
 368       while (skip_whitespace_and_comma (0));
 369     }
 370   else
 371     {
 372       expression (&seh_ctx_cur->handler_data);
 373       demand_empty_rest_of_line ();
 374
 375       if (seh_ctx_cur->handler_written)
 376         as_warn (_(".seh_handler after .seh_eh is ignored"));
 377     }
 378 }
 379
 380 /* Switch to subsection for handler data for exception region (x64).  */
 381
 382 static void
 383 obj_coff_seh_handlerdata (int what ATTRIBUTE_UNUSED)
 384 {
 385   if (!verify_context_and_target (".seh_handlerdata", seh_kind_x64))
 386     return;
 387   demand_empty_rest_of_line ();
 388
 389   switch_xdata (seh_ctx_cur->subsection + 1, seh_ctx_cur->code_seg);
 390 }
 391
 392 /* Mark end of current context.  */
 393
 394 static void
 395 do_seh_endproc (void)
 396 {
 397   seh_ctx_cur->end_addr = symbol_temp_new_now ();
 398
 399   write_function_xdata (seh_ctx_cur);
 400   write_function_pdata (seh_ctx_cur);
 401   seh_ctx_cur = NULL;
 402 }
 403
 404 static void
 405 obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED)
 406 {
 407   demand_empty_rest_of_line ();
 408   if (seh_ctx_cur == NULL)
 409     {
 410       as_bad (_(".seh_endproc used without .seh_proc"));
 411       return;
 412     }
 413   seh_validate_seg (".seh_endproc");
 414   do_seh_endproc ();
 415 }
 416
 417 /* Mark begin of new context.  */
 418
 419 static void
 420 obj_coff_seh_proc (int what ATTRIBUTE_UNUSED)
 421 {
 422   char *symbol_name;
 423   char name_end;
 424
 425   if (seh_ctx_cur != NULL)
 426     {
 427       as_bad (_("previous SEH entry not closed (missing .seh_endproc)"));
 428       do_seh_endproc ();
 429     }
 430
 431   if (*input_line_pointer == 0 || *input_line_pointer == '\n')
 432     {
 433       as_bad (_(".seh_proc requires function label name"));
 434       demand_empty_rest_of_line ();
 435       return;
 436     }
 437
 438   seh_ctx_cur = XCNEW (seh_context);
 439
 440   seh_ctx_cur->code_seg = now_seg;
 441
 442   if (seh_get_target_kind () == seh_kind_x64)
 443     {
 444       x_segcur = seh_hash_find_or_make (seh_ctx_cur->code_seg, ".xdata");
 445       seh_ctx_cur->subsection = x_segcur->subseg;
 446       x_segcur->subseg += 2;
 447     }
 448
 449   SKIP_WHITESPACE ();
 450
 451   symbol_name = input_line_pointer;
 452   name_end = get_symbol_end ();
 453   seh_ctx_cur->func_name = xstrdup (symbol_name);
 454   *input_line_pointer = name_end;
 455
 456   demand_empty_rest_of_line ();
 457
 458   seh_ctx_cur->start_addr = symbol_temp_new_now ();
 459 }
 460
 461 /* Mark end of prologue for current context.  */
 462
 463 static void
 464 obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED)
 465 {
 466   if (!verify_context (".seh_endprologue")
 467       || !seh_validate_seg (".seh_endprologue"))
 468     return;
 469   demand_empty_rest_of_line ();
 470
 471   if (seh_ctx_cur->endprologue_addr != NULL)
 472     as_warn (_("duplicate .seh_endprologue in .seh_proc block"));
 473   else
 474     seh_ctx_cur->endprologue_addr = symbol_temp_new_now ();
 475 }
 476
 477 /* End-of-file hook.  */
 478
 479 void
 480 obj_coff_seh_do_final (void)
 481 {
 482   if (seh_ctx_cur != NULL)
 483     {
 484       as_bad (_("open SEH entry at end of file (missing .cfi_endproc)"));
 485       do_seh_endproc ();
 486     }
 487 }
 488
 489 /* Enter a prologue element into current context (x64).  */
 490
 491 static void
 492 seh_x64_make_prologue_element (int code, int info, offsetT off)
 493 {
 494   seh_prologue_element *n;
 495
 496   if (seh_ctx_cur == NULL)
 497     return;
 498   if (seh_ctx_cur->elems_count == seh_ctx_cur->elems_max)
 499     {
 500       seh_ctx_cur->elems_max += 8;
 501       seh_ctx_cur->elems = XRESIZEVEC (seh_prologue_element,
 502                                        seh_ctx_cur->elems,
 503                                        seh_ctx_cur->elems_max);
 504     }
 505
 506   n = &seh_ctx_cur->elems[seh_ctx_cur->elems_count++];
 507   n->code = code;
 508   n->info = info;
 509   n->off = off;
 510   n->pc_addr = symbol_temp_new_now ();
 511 }
 512
 513 /* Helper to read a register name from input stream (x64).  */
 514
 515 static int
 516 seh_x64_read_reg (const char *directive, int kind)
 517 {
 518   static const char * const int_regs[16] =
 519     { "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
 520       "r8","r9","r10","r11","r12","r13","r14","r15" };
 521   static const char * const xmm_regs[16] =
 522     { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
 523       "xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" };
 524
 525   const char * const *regs = NULL;
 526   char name_end;
 527   char *symbol_name = NULL;
 528   int i;
 529
 530   switch (kind)
 531     {
 532     case 0:
 533     case 1:
 534       regs = int_regs;
 535       break;
 536     case 2:
 537       regs = xmm_regs;
 538       break;
 539     default:
 540       abort ();
 541     }
 542
 543   SKIP_WHITESPACE ();
 544   if (*input_line_pointer == '%')
 545     ++input_line_pointer;
 546   symbol_name = input_line_pointer;
 547   name_end = get_symbol_end ();
 548
 549   for (i = 0; i < 16; i++)
 550     if (! strcasecmp (regs[i], symbol_name))
 551       break;
 552
 553   *input_line_pointer = name_end;
 554
 555   /* Error if register not found, or EAX used as a frame pointer.  */
 556   if (i == 16 || (kind == 0 && i == 0))
 557     {
 558       as_bad (_("invalid register for %s"), directive);
 559       return -1;
 560     }
 561
 562   return i;
 563 }
 564
 565 /* Add a register push-unwind token to the current context.  */
 566
 567 static void
 568 obj_coff_seh_pushreg (int what ATTRIBUTE_UNUSED)
 569 {
 570   int reg;
 571
 572   if (!verify_context_and_target (".seh_pushreg", seh_kind_x64)
 573       || !seh_validate_seg (".seh_pushreg"))
 574     return;
 575
 576   reg = seh_x64_read_reg (".seh_pushreg", 1);
 577   demand_empty_rest_of_line ();
 578
 579   if (reg < 0)
 580     return;
 581
 582   seh_x64_make_prologue_element (UWOP_PUSH_NONVOL, reg, 0);
 583 }
 584
 585 /* Add a register frame-unwind token to the current context.  */
 586
 587 static void
 588 obj_coff_seh_pushframe (int what ATTRIBUTE_UNUSED)
 589 {
 590   if (!verify_context_and_target (".seh_pushframe", seh_kind_x64)
 591       || !seh_validate_seg (".seh_pushframe"))
 592     return;
 593   demand_empty_rest_of_line ();
 594
 595   seh_x64_make_prologue_element (UWOP_PUSH_MACHFRAME, 0, 0);
 596 }
 597
 598 /* Add a register save-unwind token to current context.  */
 599
 600 static void
 601 obj_coff_seh_save (int what)
 602 {
 603   const char *directive = (what == 1 ? ".seh_savereg" : ".seh_savexmm");
 604   int code, reg, scale;
 605   offsetT off;
 606
 607   if (!verify_context_and_target (directive, seh_kind_x64)
 608       || !seh_validate_seg (directive))
 609     return;
 610
 611   reg = seh_x64_read_reg (directive, what);
 612
 613   if (!skip_whitespace_and_comma (1))
 614     return;
 615
 616   off = get_absolute_expression ();
 617   demand_empty_rest_of_line ();
 618
 619   if (reg < 0)
 620     return;
 621   if (off < 0)
 622     {
 623       as_bad (_("%s offset is negative"), directive);
 624       return;
 625     }
 626
 627   scale = (what == 1 ? 8 : 16);
 628
 629   if ((off & (scale - 1)) == 0 && off <= (offsetT) (0xffff * scale))
 630     {
 631       code = (what == 1 ? UWOP_SAVE_NONVOL : UWOP_SAVE_XMM128);
 632       off /= scale;
 633     }
 634   else if (off < (offsetT) 0xffffffff)
 635     code = (what == 1 ? UWOP_SAVE_NONVOL_FAR : UWOP_SAVE_XMM128_FAR);
 636   else
 637     {
 638       as_bad (_("%s offset out of range"), directive);
 639       return;
 640     }
 641
 642   seh_x64_make_prologue_element (code, reg, off);
 643 }
 644
 645 /* Add a stack-allocation token to current context.  */
 646
 647 static void
 648 obj_coff_seh_stackalloc (int what ATTRIBUTE_UNUSED)
 649 {
 650   offsetT off;
 651   int code, info;
 652
 653   if (!verify_context_and_target (".seh_stackalloc", seh_kind_x64)
 654       || !seh_validate_seg (".seh_stackalloc"))
 655     return;
 656
 657   off = get_absolute_expression ();
 658   demand_empty_rest_of_line ();
 659
 660   if (off == 0)
 661     return;
 662   if (off < 0)
 663     {
 664       as_bad (_(".seh_stackalloc offset is negative"));
 665       return;
 666     }
 667
 668   if ((off & 7) == 0 && off <= 128)
 669     code = UWOP_ALLOC_SMALL, info = (off - 8) >> 3, off = 0;
 670   else if ((off & 7) == 0 && off <= (offsetT) (0xffff * 8))
 671     code = UWOP_ALLOC_LARGE, info = 0, off >>= 3;
 672   else if (off <= (offsetT) 0xffffffff)
 673     code = UWOP_ALLOC_LARGE, info = 1;
 674   else
 675     {
 676       as_bad (_(".seh_stackalloc offset out of range"));
 677       return;
 678     }
 679
 680   seh_x64_make_prologue_element (code, info, off);
 681 }
 682
 683 /* Add a frame-pointer token to current context.  */
 684
 685 static void
 686 obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED)
 687 {
 688   offsetT off;
 689   int reg;
 690
 691   if (!verify_context_and_target (".seh_setframe", seh_kind_x64)
 692       || !seh_validate_seg (".seh_setframe"))
 693     return;
 694
 695   reg = seh_x64_read_reg (".seh_setframe", 0);
 696
 697   if (!skip_whitespace_and_comma (1))
 698     return;
 699
 700   off = get_absolute_expression ();
 701   demand_empty_rest_of_line ();
 702
 703   if (reg < 0)
 704     return;
 705   if (off < 0)
 706     as_bad (_(".seh_setframe offset is negative"));
 707   else if (off > 240)
 708     as_bad (_(".seh_setframe offset out of range"));
 709   else if (off & 15)
 710     as_bad (_(".seh_setframe offset not a multiple of 16"));
 711   else if (seh_ctx_cur->framereg != 0)
 712     as_bad (_("duplicate .seh_setframe in current .seh_proc"));
 713   else
 714     {
 715       seh_ctx_cur->framereg = reg;
 716       seh_ctx_cur->frameoff = off;
 717       seh_x64_make_prologue_element (UWOP_SET_FPREG, 0, 0);
 718     }
 719 }
 720 \f
 721 /* Data writing routines.  */
 722
 723 /* Output raw integers in 1, 2, or 4 bytes.  */
 724
 725 static inline void
 726 out_one (int byte)
 727 {
 728   FRAG_APPEND_1_CHAR (byte);
 729 }
 730
 731 static inline void
 732 out_two (int data)
 733 {
 734   md_number_to_chars (frag_more (2), data, 2);
 735 }
 736
 737 static inline void
 738 out_four (int data)
 739 {
 740   md_number_to_chars (frag_more (4), data, 4);
 741 }
 742
 743 /* Write out prologue data for x64.  */
 744
 745 static void
 746 seh_x64_write_prologue_data (const seh_context *c)
 747 {
 748   int i;
 749
 750   /* We have to store in reverse order.  */
 751   for (i = c->elems_count - 1; i >= 0; --i)
 752     {
 753       const seh_prologue_element *e = c->elems + i;
 754       expressionS exp;
 755
 756       /* First comes byte offset in code.  */
 757       exp.X_op = O_subtract;
 758       exp.X_add_symbol = e->pc_addr;
 759       exp.X_op_symbol = c->start_addr;
 760       exp.X_add_number = 0;
 761       emit_expr (&exp, 1);
 762
 763       /* Second comes code+info packed into a byte.  */
 764       out_one ((e->info << 4) | e->code);
 765
 766       switch (e->code)
 767         {
 768         case UWOP_PUSH_NONVOL:
 769         case UWOP_ALLOC_SMALL:
 770         case UWOP_SET_FPREG:
 771         case UWOP_PUSH_MACHFRAME:
 772           /* These have no extra data.  */
 773           break;
 774
 775         case UWOP_ALLOC_LARGE:
 776           if (e->info)
 777             {
 778         case UWOP_SAVE_NONVOL_FAR:
 779         case UWOP_SAVE_XMM128_FAR:
 780               /* An unscaled 4 byte offset.  */
 781               out_four (e->off);
 782               break;
 783             }
 784           /* FALLTHRU */
 785
 786         case UWOP_SAVE_NONVOL:
 787         case UWOP_SAVE_XMM128:
 788           /* A scaled 2 byte offset.  */
 789           out_two (e->off);
 790           break;
 791
 792         default:
 793           abort ();
 794         }
 795     }
 796 }
 797
 798 static int
 799 seh_x64_size_prologue_data (const seh_context *c)
 800 {
 801   int i, ret = 0;
 802
 803   for (i = c->elems_count - 1; i >= 0; --i)
 804     switch (c->elems[i].code)
 805       {
 806       case UWOP_PUSH_NONVOL:
 807       case UWOP_ALLOC_SMALL:
 808       case UWOP_SET_FPREG:
 809       case UWOP_PUSH_MACHFRAME:
 810         ret += 1;
 811         break;
 812
 813       case UWOP_SAVE_NONVOL:
 814       case UWOP_SAVE_XMM128:
 815         ret += 2;
 816         break;
 817
 818       case UWOP_SAVE_NONVOL_FAR:
 819       case UWOP_SAVE_XMM128_FAR:
 820         ret += 3;
 821         break;
 822
 823       case UWOP_ALLOC_LARGE:
 824         ret += (c->elems[i].info ? 3 : 2);
 825         break;
 826
 827       default:
 828         abort ();
 829       }
 830
 831   return ret;
 832 }
 833
 834 /* Write out the xdata information for one function (x64).  */
 835
 836 static void
 837 seh_x64_write_function_xdata (seh_context *c)
 838 {
 839   int flags, count_unwind_codes;
 840   expressionS exp;
 841
 842   /* Set 4-byte alignment.  */
 843   frag_align (2, 0, 0);
 844
 845   c->xdata_addr = symbol_temp_new_now ();
 846   flags = c->handler_flags;
 847   count_unwind_codes = seh_x64_size_prologue_data (c);
 848
 849   /* ubyte:3 version, ubyte:5 flags.  */
 850   out_one ((flags << 3) | 1);
 851
 852   /* Size of prologue.  */
 853   if (c->endprologue_addr)
 854     {
 855       exp.X_op = O_subtract;
 856       exp.X_add_symbol = c->endprologue_addr;
 857       exp.X_op_symbol = c->start_addr;
 858       exp.X_add_number = 0;
 859       emit_expr (&exp, 1);
 860     }
 861   else
 862     out_one (0);
 863
 864   /* Number of slots (i.e. shorts) in the unwind codes array.  */
 865   if (count_unwind_codes > 255)
 866     as_fatal (_("too much unwind data in this .seh_proc"));
 867   out_one (count_unwind_codes);
 868
 869   /* ubyte:4 frame-reg, ubyte:4 frame-reg-offset.  */
 870   /* Note that frameoff is already a multiple of 16, and therefore
 871      the offset is already both scaled and shifted into place.  */
 872   out_one (c->frameoff | c->framereg);
 873
 874   seh_x64_write_prologue_data (c);
 875
 876   /* We need to align prologue data.  */
 877   if (count_unwind_codes & 1)
 878     out_two (0);
 879
 880   if (flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER))
 881     {
 882       /* Force the use of segment-relative relocations instead of absolute
 883          valued expressions.  Don't adjust for constants (e.g. NULL).  */
 884       if (c->handler.X_op == O_symbol)
 885         c->handler.X_op = O_symbol_rva;
 886       emit_expr (&c->handler, 4);
 887     }
 888
 889   /* Handler data will be tacked in here by subsections.  */
 890 }
 891
 892 /* Write out xdata for one function.  */
 893
 894 static void
 895 write_function_xdata (seh_context *c)
 896 {
 897   segT save_seg = now_seg;
 898   int save_subseg = now_subseg;
 899
 900   /* MIPS, SH, ARM don't have xdata.  */
 901   if (seh_get_target_kind () != seh_kind_x64)
 902     return;
 903
 904   switch_xdata (c->subsection, c->code_seg);
 905
 906   seh_x64_write_function_xdata (c);
 907
 908   subseg_set (save_seg, save_subseg);
 909 }
 910
 911 /* Write pdata section data for one function (arm).  */
 912
 913 static void
 914 seh_arm_write_function_pdata (seh_context *c)
 915 {
 916   expressionS exp;
 917   unsigned int prol_len = 0, func_len = 0;
 918   unsigned int val;
 919
 920   /* Start address of the function.  */
 921   exp.X_op = O_symbol;
 922   exp.X_add_symbol = c->start_addr;
 923   exp.X_add_number = 0;
 924   emit_expr (&exp, 4);
 925
 926   exp.X_op = O_subtract;
 927   exp.X_add_symbol = c->end_addr;
 928   exp.X_op_symbol = c->start_addr;
 929   exp.X_add_number = 0;
 930   if (resolve_expression (&exp) && exp.X_op == O_constant)
 931     func_len = exp.X_add_number;
 932   else
 933     as_bad (_(".seh_endproc in a different section from .seh_proc"));
 934
 935   if (c->endprologue_addr)
 936     {
 937       exp.X_op = O_subtract;
 938       exp.X_add_symbol = c->endprologue_addr;
 939       exp.X_op_symbol = c->start_addr;
 940       exp.X_add_number = 0;
 941
 942       if (resolve_expression (&exp) && exp.X_op == O_constant)
 943         prol_len = exp.X_add_number;
 944       else
 945         as_bad (_(".seh_endprologue in a different section from .seh_proc"));
 946     }
 947
 948   /* Both function and prologue are in units of instructions.  */
 949   func_len >>= (c->use_instruction_32 ? 2 : 1);
 950   prol_len >>= (c->use_instruction_32 ? 2 : 1);
 951
 952   /* Assemble the second word of the pdata.  */
 953   val  = prol_len & 0xff;
 954   val |= (func_len & 0x3fffff) << 8;
 955   if (c->use_instruction_32)
 956     val |= 0x40000000U;
 957   if (c->handler_written)
 958     val |= 0x80000000U;
 959   out_four (val);
 960 }
 961
 962 /* Write out pdata for one function.  */
 963
 964 static void
 965 write_function_pdata (seh_context *c)
 966 {
 967   expressionS exp;
 968   segT save_seg = now_seg;
 969   int save_subseg = now_subseg;
 970   memset (&exp, 0, sizeof (expressionS));
 971   switch_pdata (c->code_seg);
 972
 973   switch (seh_get_target_kind ())
 974     {
 975     case seh_kind_x64:
 976       exp.X_op = O_symbol_rva;
 977       exp.X_add_number = 0;
 978
 979       exp.X_add_symbol = c->start_addr;
 980       emit_expr (&exp, 4);
 981       exp.X_op = O_symbol_rva;
 982       exp.X_add_number = 0;
 983       exp.X_add_symbol = c->end_addr;
 984       emit_expr (&exp, 4);
 985       exp.X_op = O_symbol_rva;
 986       exp.X_add_number = 0;
 987       exp.X_add_symbol = c->xdata_addr;
 988       emit_expr (&exp, 4);
 989       break;
 990
 991     case seh_kind_mips:
 992       exp.X_op = O_symbol;
 993       exp.X_add_number = 0;
 994
 995       exp.X_add_symbol = c->start_addr;
 996       emit_expr (&exp, 4);
 997       exp.X_add_symbol = c->end_addr;
 998       emit_expr (&exp, 4);
 999
1000       emit_expr (&c->handler, 4);
1001       emit_expr (&c->handler_data, 4);
1002
1003       exp.X_add_symbol = (c->endprologue_addr
1004                           ? c->endprologue_addr
1005                           : c->start_addr);
1006       emit_expr (&exp, 4);
1007       break;
1008
1009     case seh_kind_arm:
1010       seh_arm_write_function_pdata (c);
1011       break;
1012
1013     default:
1014       abort ();
1015     }
1016
1017   subseg_set (save_seg, save_subseg);
1018 }