gas/config/obj-coff-seh.c

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