forked from KolibriOS/kolibrios
1019 lines
23 KiB
C
1019 lines
23 KiB
C
/* seh pdata/xdata coff object file format
|
||
Copyright 2009, 2010
|
||
Free Software Foundation, Inc.
|
||
|
||
This file is part of GAS.
|
||
|
||
GAS is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3, or (at your option)
|
||
any later version.
|
||
|
||
GAS is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with GAS; see the file COPYING. If not, write to the Free
|
||
Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
|
||
02110-1301, USA. */
|
||
|
||
#include "obj-coff-seh.h"
|
||
|
||
|
||
/* Private segment collection list. */
|
||
struct seh_seg_list {
|
||
segT seg;
|
||
int subseg;
|
||
char *seg_name;
|
||
};
|
||
|
||
/* Local data. */
|
||
static seh_context *seh_ctx_cur = NULL;
|
||
|
||
static struct hash_control *seh_hash;
|
||
|
||
static struct seh_seg_list *x_segcur = NULL;
|
||
static struct seh_seg_list *p_segcur = NULL;
|
||
|
||
static void write_function_xdata (seh_context *);
|
||
static void write_function_pdata (seh_context *);
|
||
|
||
|
||
/* Build based on segment the derived .pdata/.xdata
|
||
segment name containing origin segment's postfix name part. */
|
||
static char *
|
||
get_pxdata_name (segT seg, const char *base_name)
|
||
{
|
||
const char *name,*dollar, *dot;
|
||
char *sname;
|
||
|
||
name = bfd_get_section_name (stdoutput, seg);
|
||
|
||
dollar = strchr (name, '$');
|
||
dot = strchr (name + 1, '.');
|
||
|
||
if (!dollar && !dot)
|
||
name = "";
|
||
else if (!dollar)
|
||
name = dot;
|
||
else if (!dot)
|
||
name = dollar;
|
||
else if (dot < dollar)
|
||
name = dot;
|
||
else
|
||
name = dollar;
|
||
|
||
sname = concat (base_name, name, NULL);
|
||
|
||
return sname;
|
||
}
|
||
|
||
/* Allocate a seh_seg_list structure. */
|
||
static struct seh_seg_list *
|
||
alloc_pxdata_item (segT seg, int subseg, char *name)
|
||
{
|
||
struct seh_seg_list *r;
|
||
|
||
r = (struct seh_seg_list *)
|
||
xmalloc (sizeof (struct seh_seg_list) + strlen (name));
|
||
r->seg = seg;
|
||
r->subseg = subseg;
|
||
r->seg_name = name;
|
||
return r;
|
||
}
|
||
|
||
/* Generate pdata/xdata segment with same linkonce properties
|
||
of based segment. */
|
||
static segT
|
||
make_pxdata_seg (segT cseg, char *name)
|
||
{
|
||
segT save_seg = now_seg;
|
||
int save_subseg = now_subseg;
|
||
segT r;
|
||
flagword flags;
|
||
|
||
r = subseg_new (name, 0);
|
||
/* Check if code segment is marked as linked once. */
|
||
flags = bfd_get_section_flags (stdoutput, cseg)
|
||
& (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
|
||
| SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
|
||
| SEC_LINK_DUPLICATES_SAME_CONTENTS);
|
||
|
||
/* Add standard section flags. */
|
||
flags |= SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA;
|
||
|
||
/* Apply possibly linked once flags to new generated segment, too. */
|
||
if (!bfd_set_section_flags (stdoutput, r, flags))
|
||
as_bad (_("bfd_set_section_flags: %s"),
|
||
bfd_errmsg (bfd_get_error ()));
|
||
|
||
/* Restore to previous segment. */
|
||
subseg_set (save_seg, save_subseg);
|
||
return r;
|
||
}
|
||
|
||
static void
|
||
seh_hash_insert (const char *name, struct seh_seg_list *item)
|
||
{
|
||
const char *error_string;
|
||
|
||
if ((error_string = hash_jam (seh_hash, name, (char *) item)))
|
||
as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
|
||
name, error_string);
|
||
}
|
||
|
||
static struct seh_seg_list *
|
||
seh_hash_find (char *name)
|
||
{
|
||
return (struct seh_seg_list *) hash_find (seh_hash, name);
|
||
}
|
||
|
||
static struct seh_seg_list *
|
||
seh_hash_find_or_make (segT cseg, const char *base_name)
|
||
{
|
||
struct seh_seg_list *item;
|
||
char *name;
|
||
|
||
/* Initialize seh_hash once. */
|
||
if (!seh_hash)
|
||
seh_hash = hash_new ();
|
||
|
||
name = get_pxdata_name (cseg, base_name);
|
||
|
||
item = seh_hash_find (name);
|
||
if (!item)
|
||
{
|
||
item = alloc_pxdata_item (make_pxdata_seg (cseg, name), 0, name);
|
||
|
||
seh_hash_insert (item->seg_name, item);
|
||
}
|
||
else
|
||
free (name);
|
||
|
||
return item;
|
||
}
|
||
|
||
/* Check if current segment has same name. */
|
||
static int
|
||
seh_validate_seg (const char *directive)
|
||
{
|
||
const char *cseg_name, *nseg_name;
|
||
if (seh_ctx_cur->code_seg == now_seg)
|
||
return 1;
|
||
cseg_name = bfd_get_section_name (stdoutput, seh_ctx_cur->code_seg);
|
||
nseg_name = bfd_get_section_name (stdoutput, now_seg);
|
||
as_bad (_("%s used in segment '%s' instead of expected '%s'"),
|
||
directive, nseg_name, cseg_name);
|
||
ignore_rest_of_line ();
|
||
return 0;
|
||
}
|
||
|
||
static void
|
||
switch_xdata (int subseg, segT code_seg)
|
||
{
|
||
x_segcur = seh_hash_find_or_make (code_seg, ".xdata");
|
||
|
||
subseg_set (x_segcur->seg, subseg);
|
||
}
|
||
|
||
static void
|
||
switch_pdata (segT code_seg)
|
||
{
|
||
p_segcur = seh_hash_find_or_make (code_seg, ".pdata");
|
||
|
||
subseg_set (p_segcur->seg, p_segcur->subseg);
|
||
}
|
||
|
||
/* Parsing routines. */
|
||
|
||
/* Return the style of SEH unwind info to generate. */
|
||
|
||
static seh_kind
|
||
seh_get_target_kind (void)
|
||
{
|
||
if (!stdoutput)
|
||
return seh_kind_unknown;
|
||
switch (bfd_get_arch (stdoutput))
|
||
{
|
||
case bfd_arch_arm:
|
||
case bfd_arch_powerpc:
|
||
case bfd_arch_sh:
|
||
return seh_kind_arm;
|
||
case bfd_arch_i386:
|
||
switch (bfd_get_mach (stdoutput))
|
||
{
|
||
case bfd_mach_x86_64:
|
||
case bfd_mach_x86_64_intel_syntax:
|
||
return seh_kind_x64;
|
||
default:
|
||
break;
|
||
}
|
||
/* FALL THROUGH. */
|
||
case bfd_arch_mips:
|
||
return seh_kind_mips;
|
||
case bfd_arch_ia64:
|
||
/* Should return seh_kind_x64. But not implemented yet. */
|
||
return seh_kind_unknown;
|
||
default:
|
||
break;
|
||
}
|
||
return seh_kind_unknown;
|
||
}
|
||
|
||
/* Verify that we're in the context of a seh_proc. */
|
||
|
||
static int
|
||
verify_context (const char *directive)
|
||
{
|
||
if (seh_ctx_cur == NULL)
|
||
{
|
||
as_bad (_("%s used outside of .seh_proc block"), directive);
|
||
ignore_rest_of_line ();
|
||
return 0;
|
||
}
|
||
return 1;
|
||
}
|
||
|
||
/* Similar, except we also verify the appropriate target. */
|
||
|
||
static int
|
||
verify_context_and_target (const char *directive, seh_kind target)
|
||
{
|
||
if (seh_get_target_kind () != target)
|
||
{
|
||
as_warn (_("%s ignored for this target"), directive);
|
||
ignore_rest_of_line ();
|
||
return 0;
|
||
}
|
||
return verify_context (directive);
|
||
}
|
||
|
||
/* Skip whitespace and a comma. Error if the comma is not seen. */
|
||
|
||
static int
|
||
skip_whitespace_and_comma (int required)
|
||
{
|
||
SKIP_WHITESPACE ();
|
||
if (*input_line_pointer == ',')
|
||
{
|
||
input_line_pointer++;
|
||
SKIP_WHITESPACE ();
|
||
return 1;
|
||
}
|
||
else if (required)
|
||
{
|
||
as_bad (_("missing separator"));
|
||
ignore_rest_of_line ();
|
||
}
|
||
else
|
||
demand_empty_rest_of_line ();
|
||
return 0;
|
||
}
|
||
|
||
/* Mark current context to use 32-bit instruction (arm). */
|
||
|
||
static void
|
||
obj_coff_seh_32 (int what)
|
||
{
|
||
if (!verify_context_and_target ((what ? ".seh_32" : ".seh_no32"),
|
||
seh_kind_arm))
|
||
return;
|
||
|
||
seh_ctx_cur->use_instruction_32 = (what ? 1 : 0);
|
||
demand_empty_rest_of_line ();
|
||
}
|
||
|
||
/* Set for current context the handler and optional data (arm). */
|
||
|
||
static void
|
||
obj_coff_seh_eh (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
if (!verify_context_and_target (".seh_eh", seh_kind_arm))
|
||
return;
|
||
|
||
/* Write block to .text if exception handler is set. */
|
||
seh_ctx_cur->handler_written = 1;
|
||
emit_expr (&seh_ctx_cur->handler, 4);
|
||
emit_expr (&seh_ctx_cur->handler_data, 4);
|
||
|
||
demand_empty_rest_of_line ();
|
||
}
|
||
|
||
/* Set for current context the default handler (x64). */
|
||
|
||
static void
|
||
obj_coff_seh_handler (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
char *symbol_name;
|
||
char name_end;
|
||
|
||
if (!verify_context (".seh_handler"))
|
||
return;
|
||
|
||
if (*input_line_pointer == 0 || *input_line_pointer == '\n')
|
||
{
|
||
as_bad (_(".seh_handler requires a handler"));
|
||
demand_empty_rest_of_line ();
|
||
return;
|
||
}
|
||
|
||
SKIP_WHITESPACE ();
|
||
|
||
if (*input_line_pointer == '@')
|
||
{
|
||
symbol_name = input_line_pointer;
|
||
name_end = get_symbol_end ();
|
||
|
||
seh_ctx_cur->handler.X_op = O_constant;
|
||
seh_ctx_cur->handler.X_add_number = 0;
|
||
|
||
if (strcasecmp (symbol_name, "@0") == 0
|
||
|| strcasecmp (symbol_name, "@null") == 0)
|
||
;
|
||
else if (strcasecmp (symbol_name, "@1") == 0)
|
||
seh_ctx_cur->handler.X_add_number = 1;
|
||
else
|
||
as_bad (_("unknown constant value '%s' for handler"), symbol_name);
|
||
|
||
*input_line_pointer = name_end;
|
||
}
|
||
else
|
||
expression (&seh_ctx_cur->handler);
|
||
|
||
seh_ctx_cur->handler_data.X_op = O_constant;
|
||
seh_ctx_cur->handler_data.X_add_number = 0;
|
||
seh_ctx_cur->handler_flags = 0;
|
||
|
||
if (!skip_whitespace_and_comma (0))
|
||
return;
|
||
|
||
if (seh_get_target_kind () == seh_kind_x64)
|
||
{
|
||
do
|
||
{
|
||
symbol_name = input_line_pointer;
|
||
name_end = get_symbol_end ();
|
||
|
||
if (strcasecmp (symbol_name, "@unwind") == 0)
|
||
seh_ctx_cur->handler_flags |= UNW_FLAG_UHANDLER;
|
||
else if (strcasecmp (symbol_name, "@except") == 0)
|
||
seh_ctx_cur->handler_flags |= UNW_FLAG_EHANDLER;
|
||
else
|
||
as_bad (_(".seh_handler constant '%s' unknown"), symbol_name);
|
||
|
||
*input_line_pointer = name_end;
|
||
}
|
||
while (skip_whitespace_and_comma (0));
|
||
}
|
||
else
|
||
{
|
||
expression (&seh_ctx_cur->handler_data);
|
||
demand_empty_rest_of_line ();
|
||
|
||
if (seh_ctx_cur->handler_written)
|
||
as_warn (_(".seh_handler after .seh_eh is ignored"));
|
||
}
|
||
}
|
||
|
||
/* Switch to subsection for handler data for exception region (x64). */
|
||
|
||
static void
|
||
obj_coff_seh_handlerdata (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
if (!verify_context_and_target (".seh_handlerdata", seh_kind_x64))
|
||
return;
|
||
demand_empty_rest_of_line ();
|
||
|
||
switch_xdata (seh_ctx_cur->subsection + 1, seh_ctx_cur->code_seg);
|
||
}
|
||
|
||
/* Mark end of current context. */
|
||
|
||
static void
|
||
do_seh_endproc (void)
|
||
{
|
||
seh_ctx_cur->end_addr = symbol_temp_new_now ();
|
||
|
||
write_function_xdata (seh_ctx_cur);
|
||
write_function_pdata (seh_ctx_cur);
|
||
seh_ctx_cur = NULL;
|
||
}
|
||
|
||
static void
|
||
obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
demand_empty_rest_of_line ();
|
||
if (seh_ctx_cur == NULL)
|
||
{
|
||
as_bad (_(".seh_endproc used without .seh_proc"));
|
||
return;
|
||
}
|
||
seh_validate_seg (".seh_endproc");
|
||
do_seh_endproc ();
|
||
}
|
||
|
||
/* Mark begin of new context. */
|
||
|
||
static void
|
||
obj_coff_seh_proc (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
char *symbol_name;
|
||
char name_end;
|
||
|
||
if (seh_ctx_cur != NULL)
|
||
{
|
||
as_bad (_("previous SEH entry not closed (missing .seh_endproc)"));
|
||
do_seh_endproc ();
|
||
}
|
||
|
||
if (*input_line_pointer == 0 || *input_line_pointer == '\n')
|
||
{
|
||
as_bad (_(".seh_proc requires function label name"));
|
||
demand_empty_rest_of_line ();
|
||
return;
|
||
}
|
||
|
||
seh_ctx_cur = XCNEW (seh_context);
|
||
|
||
seh_ctx_cur->code_seg = now_seg;
|
||
|
||
if (seh_get_target_kind () == seh_kind_x64)
|
||
{
|
||
x_segcur = seh_hash_find_or_make (seh_ctx_cur->code_seg, ".xdata");
|
||
seh_ctx_cur->subsection = x_segcur->subseg;
|
||
x_segcur->subseg += 2;
|
||
}
|
||
|
||
SKIP_WHITESPACE ();
|
||
|
||
symbol_name = input_line_pointer;
|
||
name_end = get_symbol_end ();
|
||
seh_ctx_cur->func_name = xstrdup (symbol_name);
|
||
*input_line_pointer = name_end;
|
||
|
||
demand_empty_rest_of_line ();
|
||
|
||
seh_ctx_cur->start_addr = symbol_temp_new_now ();
|
||
}
|
||
|
||
/* Mark end of prologue for current context. */
|
||
|
||
static void
|
||
obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
if (!verify_context (".seh_endprologue")
|
||
|| !seh_validate_seg (".seh_endprologue"))
|
||
return;
|
||
demand_empty_rest_of_line ();
|
||
|
||
if (seh_ctx_cur->endprologue_addr != NULL)
|
||
as_warn (_("duplicate .seh_endprologue in .seh_proc block"));
|
||
else
|
||
seh_ctx_cur->endprologue_addr = symbol_temp_new_now ();
|
||
}
|
||
|
||
/* End-of-file hook. */
|
||
|
||
void
|
||
obj_coff_seh_do_final (void)
|
||
{
|
||
if (seh_ctx_cur != NULL)
|
||
{
|
||
as_bad (_("open SEH entry at end of file (missing .cfi_endproc)"));
|
||
do_seh_endproc ();
|
||
}
|
||
}
|
||
|
||
/* Enter a prologue element into current context (x64). */
|
||
|
||
static void
|
||
seh_x64_make_prologue_element (int code, int info, offsetT off)
|
||
{
|
||
seh_prologue_element *n;
|
||
|
||
if (seh_ctx_cur == NULL)
|
||
return;
|
||
if (seh_ctx_cur->elems_count == seh_ctx_cur->elems_max)
|
||
{
|
||
seh_ctx_cur->elems_max += 8;
|
||
seh_ctx_cur->elems = XRESIZEVEC (seh_prologue_element,
|
||
seh_ctx_cur->elems,
|
||
seh_ctx_cur->elems_max);
|
||
}
|
||
|
||
n = &seh_ctx_cur->elems[seh_ctx_cur->elems_count++];
|
||
n->code = code;
|
||
n->info = info;
|
||
n->off = off;
|
||
n->pc_addr = symbol_temp_new_now ();
|
||
}
|
||
|
||
/* Helper to read a register name from input stream (x64). */
|
||
|
||
static int
|
||
seh_x64_read_reg (const char *directive, int kind)
|
||
{
|
||
static const char * const int_regs[16] =
|
||
{ "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
|
||
"r8","r9","r10","r11","r12","r13","r14","r15" };
|
||
static const char * const xmm_regs[16] =
|
||
{ "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
|
||
"xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" };
|
||
|
||
const char * const *regs = NULL;
|
||
char name_end;
|
||
char *symbol_name = NULL;
|
||
int i;
|
||
|
||
switch (kind)
|
||
{
|
||
case 0:
|
||
case 1:
|
||
regs = int_regs;
|
||
break;
|
||
case 2:
|
||
regs = xmm_regs;
|
||
break;
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
SKIP_WHITESPACE ();
|
||
if (*input_line_pointer == '%')
|
||
++input_line_pointer;
|
||
symbol_name = input_line_pointer;
|
||
name_end = get_symbol_end ();
|
||
|
||
for (i = 0; i < 16; i++)
|
||
if (! strcasecmp (regs[i], symbol_name))
|
||
break;
|
||
|
||
*input_line_pointer = name_end;
|
||
|
||
/* Error if register not found, or EAX used as a frame pointer. */
|
||
if (i == 16 || (kind == 0 && i == 0))
|
||
{
|
||
as_bad (_("invalid register for %s"), directive);
|
||
return -1;
|
||
}
|
||
|
||
return i;
|
||
}
|
||
|
||
/* Add a register push-unwind token to the current context. */
|
||
|
||
static void
|
||
obj_coff_seh_pushreg (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
int reg;
|
||
|
||
if (!verify_context_and_target (".seh_pushreg", seh_kind_x64)
|
||
|| !seh_validate_seg (".seh_pushreg"))
|
||
return;
|
||
|
||
reg = seh_x64_read_reg (".seh_pushreg", 1);
|
||
demand_empty_rest_of_line ();
|
||
|
||
if (reg < 0)
|
||
return;
|
||
|
||
seh_x64_make_prologue_element (UWOP_PUSH_NONVOL, reg, 0);
|
||
}
|
||
|
||
/* Add a register frame-unwind token to the current context. */
|
||
|
||
static void
|
||
obj_coff_seh_pushframe (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
if (!verify_context_and_target (".seh_pushframe", seh_kind_x64)
|
||
|| !seh_validate_seg (".seh_pushframe"))
|
||
return;
|
||
demand_empty_rest_of_line ();
|
||
|
||
seh_x64_make_prologue_element (UWOP_PUSH_MACHFRAME, 0, 0);
|
||
}
|
||
|
||
/* Add a register save-unwind token to current context. */
|
||
|
||
static void
|
||
obj_coff_seh_save (int what)
|
||
{
|
||
const char *directive = (what == 1 ? ".seh_savereg" : ".seh_savexmm");
|
||
int code, reg, scale;
|
||
offsetT off;
|
||
|
||
if (!verify_context_and_target (directive, seh_kind_x64)
|
||
|| !seh_validate_seg (directive))
|
||
return;
|
||
|
||
reg = seh_x64_read_reg (directive, what);
|
||
|
||
if (!skip_whitespace_and_comma (1))
|
||
return;
|
||
|
||
off = get_absolute_expression ();
|
||
demand_empty_rest_of_line ();
|
||
|
||
if (reg < 0)
|
||
return;
|
||
if (off < 0)
|
||
{
|
||
as_bad (_("%s offset is negative"), directive);
|
||
return;
|
||
}
|
||
|
||
scale = (what == 1 ? 8 : 16);
|
||
|
||
if ((off & (scale - 1)) == 0 && off <= (offsetT) (0xffff * scale))
|
||
{
|
||
code = (what == 1 ? UWOP_SAVE_NONVOL : UWOP_SAVE_XMM128);
|
||
off /= scale;
|
||
}
|
||
else if (off < (offsetT) 0xffffffff)
|
||
code = (what == 1 ? UWOP_SAVE_NONVOL_FAR : UWOP_SAVE_XMM128_FAR);
|
||
else
|
||
{
|
||
as_bad (_("%s offset out of range"), directive);
|
||
return;
|
||
}
|
||
|
||
seh_x64_make_prologue_element (code, reg, off);
|
||
}
|
||
|
||
/* Add a stack-allocation token to current context. */
|
||
|
||
static void
|
||
obj_coff_seh_stackalloc (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
offsetT off;
|
||
int code, info;
|
||
|
||
if (!verify_context_and_target (".seh_stackalloc", seh_kind_x64)
|
||
|| !seh_validate_seg (".seh_stackalloc"))
|
||
return;
|
||
|
||
off = get_absolute_expression ();
|
||
demand_empty_rest_of_line ();
|
||
|
||
if (off == 0)
|
||
return;
|
||
if (off < 0)
|
||
{
|
||
as_bad (_(".seh_stackalloc offset is negative"));
|
||
return;
|
||
}
|
||
|
||
if ((off & 7) == 0 && off <= 128)
|
||
code = UWOP_ALLOC_SMALL, info = (off - 8) >> 3, off = 0;
|
||
else if ((off & 7) == 0 && off <= (offsetT) (0xffff * 8))
|
||
code = UWOP_ALLOC_LARGE, info = 0, off >>= 3;
|
||
else if (off <= (offsetT) 0xffffffff)
|
||
code = UWOP_ALLOC_LARGE, info = 1;
|
||
else
|
||
{
|
||
as_bad (_(".seh_stackalloc offset out of range"));
|
||
return;
|
||
}
|
||
|
||
seh_x64_make_prologue_element (code, info, off);
|
||
}
|
||
|
||
/* Add a frame-pointer token to current context. */
|
||
|
||
static void
|
||
obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED)
|
||
{
|
||
offsetT off;
|
||
int reg;
|
||
|
||
if (!verify_context_and_target (".seh_setframe", seh_kind_x64)
|
||
|| !seh_validate_seg (".seh_setframe"))
|
||
return;
|
||
|
||
reg = seh_x64_read_reg (".seh_setframe", 0);
|
||
|
||
if (!skip_whitespace_and_comma (1))
|
||
return;
|
||
|
||
off = get_absolute_expression ();
|
||
demand_empty_rest_of_line ();
|
||
|
||
if (reg < 0)
|
||
return;
|
||
if (off < 0)
|
||
as_bad (_(".seh_setframe offset is negative"));
|
||
else if (off > 240)
|
||
as_bad (_(".seh_setframe offset out of range"));
|
||
else if (off & 15)
|
||
as_bad (_(".seh_setframe offset not a multiple of 16"));
|
||
else if (seh_ctx_cur->framereg != 0)
|
||
as_bad (_("duplicate .seh_setframe in current .seh_proc"));
|
||
else
|
||
{
|
||
seh_ctx_cur->framereg = reg;
|
||
seh_ctx_cur->frameoff = off;
|
||
seh_x64_make_prologue_element (UWOP_SET_FPREG, 0, 0);
|
||
}
|
||
}
|
||
|
||
/* Data writing routines. */
|
||
|
||
/* Output raw integers in 1, 2, or 4 bytes. */
|
||
|
||
static inline void
|
||
out_one (int byte)
|
||
{
|
||
FRAG_APPEND_1_CHAR (byte);
|
||
}
|
||
|
||
static inline void
|
||
out_two (int data)
|
||
{
|
||
md_number_to_chars (frag_more (2), data, 2);
|
||
}
|
||
|
||
static inline void
|
||
out_four (int data)
|
||
{
|
||
md_number_to_chars (frag_more (4), data, 4);
|
||
}
|
||
|
||
/* Write out prologue data for x64. */
|
||
|
||
static void
|
||
seh_x64_write_prologue_data (const seh_context *c)
|
||
{
|
||
int i;
|
||
|
||
/* We have to store in reverse order. */
|
||
for (i = c->elems_count - 1; i >= 0; --i)
|
||
{
|
||
const seh_prologue_element *e = c->elems + i;
|
||
expressionS exp;
|
||
|
||
/* First comes byte offset in code. */
|
||
exp.X_op = O_subtract;
|
||
exp.X_add_symbol = e->pc_addr;
|
||
exp.X_op_symbol = c->start_addr;
|
||
exp.X_add_number = 0;
|
||
emit_expr (&exp, 1);
|
||
|
||
/* Second comes code+info packed into a byte. */
|
||
out_one ((e->info << 4) | e->code);
|
||
|
||
switch (e->code)
|
||
{
|
||
case UWOP_PUSH_NONVOL:
|
||
case UWOP_ALLOC_SMALL:
|
||
case UWOP_SET_FPREG:
|
||
case UWOP_PUSH_MACHFRAME:
|
||
/* These have no extra data. */
|
||
break;
|
||
|
||
case UWOP_ALLOC_LARGE:
|
||
if (e->info)
|
||
{
|
||
case UWOP_SAVE_NONVOL_FAR:
|
||
case UWOP_SAVE_XMM128_FAR:
|
||
/* An unscaled 4 byte offset. */
|
||
out_four (e->off);
|
||
break;
|
||
}
|
||
/* FALLTHRU */
|
||
|
||
case UWOP_SAVE_NONVOL:
|
||
case UWOP_SAVE_XMM128:
|
||
/* A scaled 2 byte offset. */
|
||
out_two (e->off);
|
||
break;
|
||
|
||
default:
|
||
abort ();
|
||
}
|
||
}
|
||
}
|
||
|
||
static int
|
||
seh_x64_size_prologue_data (const seh_context *c)
|
||
{
|
||
int i, ret = 0;
|
||
|
||
for (i = c->elems_count - 1; i >= 0; --i)
|
||
switch (c->elems[i].code)
|
||
{
|
||
case UWOP_PUSH_NONVOL:
|
||
case UWOP_ALLOC_SMALL:
|
||
case UWOP_SET_FPREG:
|
||
case UWOP_PUSH_MACHFRAME:
|
||
ret += 1;
|
||
break;
|
||
|
||
case UWOP_SAVE_NONVOL:
|
||
case UWOP_SAVE_XMM128:
|
||
ret += 2;
|
||
break;
|
||
|
||
case UWOP_SAVE_NONVOL_FAR:
|
||
case UWOP_SAVE_XMM128_FAR:
|
||
ret += 3;
|
||
break;
|
||
|
||
case UWOP_ALLOC_LARGE:
|
||
ret += (c->elems[i].info ? 3 : 2);
|
||
break;
|
||
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
|
||
/* Write out the xdata information for one function (x64). */
|
||
|
||
static void
|
||
seh_x64_write_function_xdata (seh_context *c)
|
||
{
|
||
int flags, count_unwind_codes;
|
||
expressionS exp;
|
||
|
||
/* Set 4-byte alignment. */
|
||
frag_align (2, 0, 0);
|
||
|
||
c->xdata_addr = symbol_temp_new_now ();
|
||
flags = c->handler_flags;
|
||
count_unwind_codes = seh_x64_size_prologue_data (c);
|
||
|
||
/* ubyte:3 version, ubyte:5 flags. */
|
||
out_one ((flags << 3) | 1);
|
||
|
||
/* Size of prologue. */
|
||
if (c->endprologue_addr)
|
||
{
|
||
exp.X_op = O_subtract;
|
||
exp.X_add_symbol = c->endprologue_addr;
|
||
exp.X_op_symbol = c->start_addr;
|
||
exp.X_add_number = 0;
|
||
emit_expr (&exp, 1);
|
||
}
|
||
else
|
||
out_one (0);
|
||
|
||
/* Number of slots (i.e. shorts) in the unwind codes array. */
|
||
if (count_unwind_codes > 255)
|
||
as_fatal (_("too much unwind data in this .seh_proc"));
|
||
out_one (count_unwind_codes);
|
||
|
||
/* ubyte:4 frame-reg, ubyte:4 frame-reg-offset. */
|
||
/* Note that frameoff is already a multiple of 16, and therefore
|
||
the offset is already both scaled and shifted into place. */
|
||
out_one (c->frameoff | c->framereg);
|
||
|
||
seh_x64_write_prologue_data (c);
|
||
|
||
/* We need to align prologue data. */
|
||
if (count_unwind_codes & 1)
|
||
out_two (0);
|
||
|
||
if (flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER))
|
||
{
|
||
/* Force the use of segment-relative relocations instead of absolute
|
||
valued expressions. Don't adjust for constants (e.g. NULL). */
|
||
if (c->handler.X_op == O_symbol)
|
||
c->handler.X_op = O_symbol_rva;
|
||
emit_expr (&c->handler, 4);
|
||
}
|
||
|
||
/* Handler data will be tacked in here by subsections. */
|
||
}
|
||
|
||
/* Write out xdata for one function. */
|
||
|
||
static void
|
||
write_function_xdata (seh_context *c)
|
||
{
|
||
segT save_seg = now_seg;
|
||
int save_subseg = now_subseg;
|
||
|
||
/* MIPS, SH, ARM don't have xdata. */
|
||
if (seh_get_target_kind () != seh_kind_x64)
|
||
return;
|
||
|
||
switch_xdata (c->subsection, c->code_seg);
|
||
|
||
seh_x64_write_function_xdata (c);
|
||
|
||
subseg_set (save_seg, save_subseg);
|
||
}
|
||
|
||
/* Write pdata section data for one function (arm). */
|
||
|
||
static void
|
||
seh_arm_write_function_pdata (seh_context *c)
|
||
{
|
||
expressionS exp;
|
||
unsigned int prol_len = 0, func_len = 0;
|
||
unsigned int val;
|
||
|
||
/* Start address of the function. */
|
||
exp.X_op = O_symbol;
|
||
exp.X_add_symbol = c->start_addr;
|
||
exp.X_add_number = 0;
|
||
emit_expr (&exp, 4);
|
||
|
||
exp.X_op = O_subtract;
|
||
exp.X_add_symbol = c->end_addr;
|
||
exp.X_op_symbol = c->start_addr;
|
||
exp.X_add_number = 0;
|
||
if (resolve_expression (&exp) && exp.X_op == O_constant)
|
||
func_len = exp.X_add_number;
|
||
else
|
||
as_bad (_(".seh_endproc in a different section from .seh_proc"));
|
||
|
||
if (c->endprologue_addr)
|
||
{
|
||
exp.X_op = O_subtract;
|
||
exp.X_add_symbol = c->endprologue_addr;
|
||
exp.X_op_symbol = c->start_addr;
|
||
exp.X_add_number = 0;
|
||
|
||
if (resolve_expression (&exp) && exp.X_op == O_constant)
|
||
prol_len = exp.X_add_number;
|
||
else
|
||
as_bad (_(".seh_endprologue in a different section from .seh_proc"));
|
||
}
|
||
|
||
/* Both function and prologue are in units of instructions. */
|
||
func_len >>= (c->use_instruction_32 ? 2 : 1);
|
||
prol_len >>= (c->use_instruction_32 ? 2 : 1);
|
||
|
||
/* Assemble the second word of the pdata. */
|
||
val = prol_len & 0xff;
|
||
val |= (func_len & 0x3fffff) << 8;
|
||
if (c->use_instruction_32)
|
||
val |= 0x40000000U;
|
||
if (c->handler_written)
|
||
val |= 0x80000000U;
|
||
out_four (val);
|
||
}
|
||
|
||
/* Write out pdata for one function. */
|
||
|
||
static void
|
||
write_function_pdata (seh_context *c)
|
||
{
|
||
expressionS exp;
|
||
segT save_seg = now_seg;
|
||
int save_subseg = now_subseg;
|
||
memset (&exp, 0, sizeof (expressionS));
|
||
switch_pdata (c->code_seg);
|
||
|
||
switch (seh_get_target_kind ())
|
||
{
|
||
case seh_kind_x64:
|
||
exp.X_op = O_symbol_rva;
|
||
exp.X_add_number = 0;
|
||
|
||
exp.X_add_symbol = c->start_addr;
|
||
emit_expr (&exp, 4);
|
||
exp.X_op = O_symbol_rva;
|
||
exp.X_add_number = 0;
|
||
exp.X_add_symbol = c->end_addr;
|
||
emit_expr (&exp, 4);
|
||
exp.X_op = O_symbol_rva;
|
||
exp.X_add_number = 0;
|
||
exp.X_add_symbol = c->xdata_addr;
|
||
emit_expr (&exp, 4);
|
||
break;
|
||
|
||
case seh_kind_mips:
|
||
exp.X_op = O_symbol;
|
||
exp.X_add_number = 0;
|
||
|
||
exp.X_add_symbol = c->start_addr;
|
||
emit_expr (&exp, 4);
|
||
exp.X_add_symbol = c->end_addr;
|
||
emit_expr (&exp, 4);
|
||
|
||
emit_expr (&c->handler, 4);
|
||
emit_expr (&c->handler_data, 4);
|
||
|
||
exp.X_add_symbol = (c->endprologue_addr
|
||
? c->endprologue_addr
|
||
: c->start_addr);
|
||
emit_expr (&exp, 4);
|
||
break;
|
||
|
||
case seh_kind_arm:
|
||
seh_arm_write_function_pdata (c);
|
||
break;
|
||
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
subseg_set (save_seg, save_subseg);
|
||
}
|