#include "config.h"

#include <inttypes.h>

#include <stdbool.h>

#include <obstack.h>

#include <stdio.h>

#include <stdlib.h>

#include <error.h>

#include <dwarf.h>

#include <elfutils/libdw.h>

#include <elfutils/version.h>

#include <assert.h>

#include "loc2c.h"

#include "config.h"

#if ! _ELFUTILS_PREREQ(0, 153)

#define DW_OP_GNU_entry_value 0xf3

#define N_(x) x

#define STACK_TYPE "intptr_t" /* Must be the signed type. */

#define UTYPE "uintptr_t" /* Must be the unsigned type. */

#define SFORMAT "%" PRId64 "L"

#define UFORMAT "%" PRIu64 "UL"

#define AFORMAT "%#" PRIx64 "UL"

#define STACKFMT "s%u"

struct location_context

};

struct location

};

static const char *

stack_slot_type (struct location *context __attribute__ ((unused)), bool sign)

{

return sign ? STACK_TYPE : UTYPE;

}

static struct location *

alloc_location (struct location_context *ctx)

{

struct location *loc = obstack_alloc (ctx->pool, sizeof *loc);

loc->context = ctx;

loc->byte_size = 0;

loc->frame_base = NULL;

loc->ops = NULL;

loc->nops = 0;

return loc;

}

#define FAIL(loc, fmt, ...) \

(*(loc)->context->fail) ((loc)->context->fail_arg, fmt, ## __VA_ARGS__)

static void

default_emit_address (void *fail_arg __attribute__ ((unused)),

struct obstack *pool, Dwarf_Addr address)

{

obstack_printf (pool, AFORMAT, address);

}

static struct location_context *

new_context (struct obstack *pool,

Dwarf *dwarf)

{

struct location_context *ctx = obstack_alloc (pool, sizeof *ctx);

ctx->pool = pool;

ctx->fail = fail;

ctx->fail_arg = fail_arg;

ctx->emit_address = emit_address ?: &default_emit_address;

ctx->attr = attr;

ctx->dwbias = dwbias;

ctx->pc = pc_address;

ctx->fb_attr = fb_attr;

ctx->cfa_ops = cfa_ops;

ctx->dwarf = dwarf;

return ctx;

}

static struct location *

translate_constant (struct location_context *ctx, int indent,

Dwarf_Attribute *attr)

{

indent += 2;

struct location *loc = obstack_alloc (ctx->pool, sizeof *loc);

loc->context = ctx;

loc->next = NULL;

loc->byte_size = 0;

loc->frame_base = NULL;

loc->address.stack_depth = 0;

loc->address.declare = NULL;

loc->address.used_deref = false;

loc->ops = NULL;

loc->nops = 0;

switch (dwarf_whatform (attr))

{

case DW_FORM_addr:

{

Dwarf_Addr addr;

if (dwarf_formaddr (attr, &addr) != 0)

{

//TRANSLATORS: failure to find an address that was a constant literal number

FAIL (loc, N_("cannot get constant address: %s"),

dwarf_errmsg (-1));

return NULL;

}

loc->type = loc_value;

obstack_printf (ctx->pool, "%*saddr = ", indent * 2, "");

(*ctx->emit_address) (ctx->fail_arg, ctx->pool, ctx->dwbias + addr);

obstack_grow (ctx->pool, ";\n", 3);

loc->address.program = obstack_finish (ctx->pool);

break;

}

case DW_FORM_block:

case DW_FORM_block1:

case DW_FORM_block2:

case DW_FORM_block4:

{

Dwarf_Block block;

if (dwarf_formblock (attr, &block) != 0)

{

FAIL (loc, N_("cannot get constant block: %s"), dwarf_errmsg (-1));

return NULL;

}

loc->type = loc_constant;

loc->byte_size = block.length;

loc->constant_block = block.data;

break;

}

case DW_FORM_string:

case DW_FORM_strp:

{

const char *string = dwarf_formstring (attr);

if (string == NULL)

{

FAIL (loc, N_("cannot get string constant: %s"), dwarf_errmsg (-1));

return NULL;

}

loc->type = loc_constant;

loc->byte_size = strlen (string) + 1;

loc->constant_block = string;

break;

}

default:

{

Dwarf_Sword value;

if (dwarf_formsdata (attr, &value) != 0)

{

FAIL (loc, N_("cannot get constant value: %s"), dwarf_errmsg (-1));

return NULL;

}

loc->type = loc_value;

obstack_printf (ctx->pool, "%*saddr = (" UTYPE ")%#" PRIx64 "ULL;\n",

indent * 2, "", (uint64_t) value);

obstack_1grow (ctx->pool, '\0');

loc->address.program = obstack_finish (ctx->pool);

break;

}

}

return loc;

}

struct location *

c_translate_constant (struct obstack *pool,

Dwarf *dwarf)

{

return translate_constant (new_context (pool, fail, fail_arg, emit_address,

dwbias, 0, attr, NULL, NULL, dwarf),

indent, attr);

}

#if _ELFUTILS_PREREQ (0, 149)

static struct location *location_from_attr (struct location_context *ctx,

int indent, Dwarf_Attribute *attr);

static struct location *

new_synthetic_loc (struct location *origin, bool deref)

{

obstack_1grow (origin->context->pool, '\0');

char *program = obstack_finish (origin->context->pool);

struct location *loc = alloc_location (origin->context);

loc->next = NULL;

loc->byte_size = 0;

loc->type = loc_address;

loc->address.program = program;

loc->address.stack_depth = 0;

loc->address.declare = NULL;

loc->address.used_deref = deref;

if (origin->type == loc_register)

{

loc->ops = origin->ops;

loc->nops = origin->nops;

}

else

{

loc->ops = NULL;

loc->nops = 0;

}

return loc;

}

static struct location *

lose (struct location *loc, const Dwarf_Op *lexpr, size_t len,

const char *failure, size_t i)

{

if (lexpr == NULL || i >= len)

FAIL (loc, "%s", failure);

else if (i < len)

FAIL (loc, N_("%s in DWARF expression [%Zu] at %" PRIu64

" (%#x: %" PRIu64 ", %" PRIu64 ")"),

failure, i, lexpr[i].offset,

(unsigned) lexpr[i].atom, lexpr[i].number, lexpr[i].number2);

return NULL;

}

static const char *

translate (struct location_context *ctx, int indent,

const Dwarf_Op *expr, const size_t len,

struct location *input, bool *need_fb, size_t *loser,

struct location *loc)

{

loc->ops = expr;

loc->nops = len;

#define DIE(msg) return (*loser = i, N_(msg))

#define emit(fmt, ...) obstack_printf (ctx->pool, fmt, ## __VA_ARGS__)

unsigned int stack_depth;

unsigned int max_stack = 0;

inline void deepen (void)

{

if (stack_depth == max_stack)

++max_stack;

}

#define POP(var) \

if (stack_depth > 0) \

--stack_depth; \

else if (tos_register != -1) \

fetch_tos_register (); \

else \

goto underflow; \

int var = stack_depth

#define PUSH (deepen (), stack_depth++)

#define STACK(idx) ({int z = (stack_depth - 1 - (idx)); assert (z >= 0); z;})

/* Don't put stack operations in the arguments to this. */

#define push(fmt, ...) \

emit ("%*s" STACKFMT " = " fmt ";\n", indent * 2, "", PUSH, ## __VA_ARGS__)

int tos_register;

inline void fetch_tos_register (void)

{

deepen ();

emit ("%*s" STACKFMT " = fetch_register (%d);\n",

indent * 2, "", stack_depth, tos_register);

tos_register = -1;

}

bool tos_value;

Dwarf_Block implicit_value;

bool used_deref;

const Dwarf_Op *implicit_pointer;

/* Initialize our state for handling each new piece. */

inline void reset ()

{

stack_depth = 0;

tos_register = -1;

tos_value = false;

implicit_value.data = NULL;

implicit_pointer = NULL;

used_deref = false;

if (input != NULL)

switch (input->type)

{

case loc_address:

push ("addr");

break;

case loc_value:

push ("addr");

tos_value = true;

break;

case loc_register:

tos_register = input->reg.regno;

break;

default:

abort ();

break;

}

}

size_t i;

inline const char *finish (struct location *piece)

{

if (piece->nops == 0)

{

assert (stack_depth == 0);

assert (tos_register == -1);

assert (obstack_object_size (ctx->pool) == 0);

piece->type = loc_unavailable;

}

else if (stack_depth >= 1)

{

/* The top of stack has our value.

obstack_1grow (ctx->pool, '\0');

char *program = obstack_finish (ctx->pool);

if (implicit_pointer != NULL)

{

piece->type = loc_implicit_pointer;

piece->pointer.offset = implicit_pointer->number2;

#if !_ELFUTILS_PREREQ (0, 149)

/* Then how did we get here? */

abort ();

Dwarf_Attribute target;

if (dwarf_getlocation_implicit_pointer (ctx->attr,

implicit_pointer,

&target) != 0)

DIE ("invalid implicit pointer");

switch (dwarf_whatattr (&target))

{

case DW_AT_const_value:

piece->pointer.target = translate_constant (ctx, indent,

&target);

break;

case DW_AT_location:

piece->pointer.target = location_from_attr (ctx, indent,

&target);

break;

default:

DIE ("unexpected implicit pointer attribute!");

break;

}

}

else if (implicit_value.data == NULL)

{

piece->type = tos_value ? loc_value : loc_address;

piece->address.declare = NULL;

piece->address.program = program;

piece->address.stack_depth = max_stack;

piece->address.used_deref = used_deref;

}

else

{

piece->type = loc_constant;

piece->byte_size = implicit_value.length;

piece->constant_block = implicit_value.data;

}

}

else if (tos_register == -1)

DIE ("stack underflow");

else if (obstack_object_size (ctx->pool) != 0)

DIE ("register value must stand alone in location expression");

else

{

piece->type = loc_register;

piece->reg.regno = tos_register;

piece->reg.offset = 0;

}

return NULL;

}

reset ();

struct location *pieces = NULL, **tailpiece = &pieces;

size_t piece_expr_start = 0;

Dwarf_Word piece_total_bytes = 0;

for (i = 0; i < len; ++i)

{

unsigned int reg;

uint_fast8_t sp;

Dwarf_Word value;

inline bool more_ops (void)

{

return (expr[i].atom != DW_OP_nop

&& expr[i].atom != DW_OP_piece

&& expr[i].atom != DW_OP_bit_piece);

}

if (tos_value && more_ops ())

DIE ("operations follow DW_OP_stack_value");

if (implicit_value.data != NULL && more_ops ())

DIE ("operations follow DW_OP_implicit_value");

if (implicit_pointer != NULL && more_ops ())

DIE ("operations follow DW_OP_GNU_implicit_pointer");

switch (expr[i].atom)

{

/* Basic stack operations. */

case DW_OP_nop:

break;

case DW_OP_dup:

if (stack_depth < 1)

goto underflow;

else

{

unsigned int tos = STACK (0);

push (STACKFMT, tos);

}

break;

case DW_OP_drop:

{

POP (ignore);

emit ("%*s/* drop " STACKFMT "*/\n", indent * 2, "", (unsigned)ignore);

break;

}

case DW_OP_pick:

sp = expr[i].number;

op_pick:

if (sp >= stack_depth)

goto underflow;

sp = STACK (sp);

push (STACKFMT, (unsigned)sp);

break;

case DW_OP_over:

sp = 1;

goto op_pick;

case DW_OP_swap:

if (stack_depth < 2)

goto underflow;

deepen (); /* Use a temporary slot. */

emit ("%*s"

STACKFMT " = " STACKFMT ", "

STACKFMT " = " STACKFMT ", "

STACKFMT " = " STACKFMT ";\n",

indent * 2, "",

(unsigned)STACK (-1), (unsigned)STACK (0),

(unsigned)STACK (0), (unsigned)STACK (1),

(unsigned)STACK (1), (unsigned)STACK (-1));

break;

case DW_OP_rot:

if (stack_depth < 3)

goto underflow;

deepen (); /* Use a temporary slot. */

emit ("%*s"

STACKFMT " = " STACKFMT ", "

STACKFMT " = " STACKFMT ", "

STACKFMT " = " STACKFMT ", "

STACKFMT " = " STACKFMT ";\n",

indent * 2, "",

(unsigned)STACK (-1), (unsigned)STACK (0),

(unsigned)STACK (0), (unsigned)STACK (1),

(unsigned)STACK (1), (unsigned)STACK (2),

(unsigned)STACK (2), (unsigned)STACK (-1));

break;

/* Control flow operations. */

case DW_OP_skip:

{

Dwarf_Off target = expr[i].offset + 3 + expr[i].number;

while (i + 1 < len && expr[i + 1].offset < target)

++i;

if (expr[i + 1].offset != target)

DIE ("invalid skip target");

break;

}

case DW_OP_bra:

DIE ("conditional branches not supported");

break;

/* Memory access. */

case DW_OP_deref:

{

POP (addr);

push ("deref (sizeof (void *), " STACKFMT ")", (unsigned)addr);

used_deref = true;

}

break;

case DW_OP_deref_size:

{

POP (addr);

push ("deref (" UFORMAT ", " STACKFMT ")",

expr[i].number, (unsigned)addr);

used_deref = true;

}

break;

case DW_OP_xderef:

{

POP (addr);

POP (as);

push ("xderef (sizeof (void *), " STACKFMT ", " STACKFMT ")",

(unsigned)addr, (unsigned)as);

used_deref = true;

}

break;

case DW_OP_xderef_size:

{

POP (addr);

POP (as);

push ("xderef (" UFORMAT ", " STACKFMT ", " STACKFMT ")",

expr[i].number, (unsigned)addr, (unsigned)as);

used_deref = true;

}

break;

/* Constant-value operations. */

case DW_OP_addr:

emit ("%*s" STACKFMT " = ", indent * 2, "", PUSH);

(*ctx->emit_address) (ctx->fail_arg, ctx->pool,

ctx->dwbias + expr[i].number);

emit (";\n");

break;

case DW_OP_lit0 ... DW_OP_lit31:

value = expr[i].atom - DW_OP_lit0;

goto op_const;

case DW_OP_const1u:

case DW_OP_const1s:

case DW_OP_const2u:

case DW_OP_const2s:

case DW_OP_const4u:

case DW_OP_const4s:

case DW_OP_const8u:

case DW_OP_const8s:

case DW_OP_constu:

case DW_OP_consts:

value = expr[i].number;

op_const:

push (SFORMAT, (int64_t)value);

break;

/* Arithmetic operations. */

#define UNOP(dw_op, c_op) \

case DW_OP_##dw_op: \

{ \

POP (tos); \

push ("%s (" STACKFMT ")", #c_op, (unsigned)tos); \

} \

break

#define BINOP(dw_op, c_op) \

case DW_OP_##dw_op: \

{ \

POP (b); \

POP (a); \

push (STACKFMT " %s " STACKFMT, (unsigned)a, #c_op, (unsigned)b); \

} \

break

UNOP (abs, op_abs);

BINOP (and, &);

BINOP (minus, -);

BINOP (mul, *);

UNOP (neg, -);

UNOP (not, ~);

BINOP (or, |);

BINOP (plus, +);

BINOP (shl, <<);

BINOP (shr, >>);

BINOP (xor, ^);

/* Comparisons are binary operators too. */

BINOP (le, <=);

BINOP (ge, >=);

BINOP (eq, ==);

BINOP (lt, <);

BINOP (gt, >);

BINOP (ne, !=);

#undef UNOP

#undef BINOP

case DW_OP_shra:

{

POP (b);

POP (a);

push ("(%s) " STACKFMT " >> (%s)" STACKFMT,

stack_slot_type (loc, true), (unsigned)a,

stack_slot_type (loc, true), (unsigned)b);

break;

}

case DW_OP_div:

{

POP (b);

POP (a);

push ("dwarf_div_op((%s) " STACKFMT ", (%s) " STACKFMT ")",

stack_slot_type (loc, true), (unsigned)a,

stack_slot_type (loc, true), (unsigned)b);

used_deref = true;

break;

}

case DW_OP_mod:

{

POP (b);

POP (a);

push ("dwarf_mod_op((%s) " STACKFMT ", (%s) " STACKFMT ")",

stack_slot_type (loc, false), (unsigned)a,

stack_slot_type (loc, false), (unsigned)b);

used_deref = true;

break;

}

case DW_OP_plus_uconst:

{

POP (x);

push (STACKFMT " + " UFORMAT, (unsigned)x, expr[i].number);

}

break;

/* Register-relative addressing. */

case DW_OP_breg0 ... DW_OP_breg31:

reg = expr[i].atom - DW_OP_breg0;

value = expr[i].number;

goto op_breg;

case DW_OP_bregx:

reg = expr[i].number;

value = expr[i].number2;

op_breg:

push ("fetch_register (%u) + " SFORMAT, reg, (int64_t)value);

break;

case DW_OP_fbreg:

if (need_fb == NULL)

DIE ("DW_OP_fbreg from DW_AT_frame_base");

*need_fb = true;

push ("frame_base + " SFORMAT, (int64_t)expr[i].number);

break;

/* Direct register contents. */

case DW_OP_reg0 ... DW_OP_reg31:

reg = expr[i].atom - DW_OP_reg0;

goto op_reg;

case DW_OP_regx:

reg = expr[i].number;

op_reg:

tos_register = reg;

break;

/* Special magic. */

case DW_OP_piece:

if (stack_depth > 1)

/* If this ever happens we could copy the program. */

DIE ("DW_OP_piece left multiple values on stack");

else

{

/* The obstack has a pending program for loc_address,

struct location temp_piece =

{

.context = loc->context,

.frame_base = NULL,

.ops = &expr[piece_expr_start],

.nops = i - piece_expr_start,

};

const char *failure = finish (&temp_piece);

if (failure != NULL)

return failure;

struct location *piece = obstack_alloc (ctx->pool, sizeof *piece);

*piece = temp_piece;

piece_expr_start = i + 1;

piece_total_bytes += piece->byte_size = expr[i].number;

*tailpiece = piece;

tailpiece = &piece->next;

piece->next = NULL;

/* Reset default conditions for handling the next piece. */

reset ();

}

break;

case DW_OP_stack_value:

if (stack_depth > 1)

DIE ("DW_OP_stack_value left multiple values on stack");

else

{

/* Fetch a register to top of stack, or check for underflow.

POP (tos);

assert (tos == 0);

PUSH;

tos_value = true;

}

break;

case DW_OP_implicit_value:

if (ctx->attr == NULL)

DIE ("DW_OP_implicit_value used in invalid context"

" (no DWARF attribute, ABI return value location?)");

/* It's supposed to appear by itself, except for DW_OP_piece. */

if (stack_depth != 0)

DIE ("DW_OP_implicit_value follows stack operations");

#if _ELFUTILS_PREREQ (0, 143)

if (dwarf_getlocation_implicit_value (ctx->attr,

(Dwarf_Op *) &expr[i],

&implicit_value) != 0)

DIE ("dwarf_getlocation_implicit_value failed");

/* Fake top of stack: implicit_value being set marks it. */

PUSH;

break;

DIE ("DW_OP_implicit_value not supported");

break;

#if _ELFUTILS_PREREQ (0, 149)

case DW_OP_GNU_implicit_pointer:

implicit_pointer = &expr[i];

/* Fake top of stack: implicit_pointer being set marks it. */

PUSH;

break;

case DW_OP_call_frame_cfa:

// We pick this out when processing DW_AT_frame_base in

// so it really shouldn't turn up here.

if (need_fb == NULL)

DIE ("DW_OP_call_frame_cfa while processing frame base");

else

DIE ("DW_OP_call_frame_cfa not expected outside DW_AT_frame_base");

break;

case DW_OP_push_object_address:

DIE ("unhandled DW_OP_push_object_address");

break;

case DW_OP_GNU_entry_value:

DIE ("unhandled DW_OP_GNU_entry_value");

break;

default:

DIE ("unrecognized operation");

break;

}

}

if (pieces == NULL)

return finish (loc);

if (piece_expr_start != i)

DIE ("extra operations after last DW_OP_piece");

loc->type = loc_noncontiguous;

loc->pieces = pieces;

loc->byte_size = piece_total_bytes;

return NULL;

underflow:

DIE ("stack underflow");

#undef emit

#undef push

#undef PUSH

#undef POP

#undef STACK

#undef DIE

}

static struct location *

location_from_address (struct location_context *ctx, int indent,

const Dwarf_Op *expr, size_t len,

struct location **input)

{

struct location *loc = obstack_alloc (ctx->pool, sizeof *loc);

loc->context = ctx;

loc->byte_size = 0;

loc->frame_base = NULL;

loc->ops = NULL;

loc->nops = 0;

bool need_fb = false;

size_t loser;

const char *failure = translate (ctx, indent + 1, expr, len,

*input, &need_fb, &loser, loc);

if (failure != NULL)

return lose (loc, expr, len, failure, loser);

loc->next = NULL;

if (need_fb)

{

/* The main expression uses DW_OP_fbreg, so we need to compute

if (ctx->fb_attr == NULL)

FAIL (loc, N_("required DW_AT_frame_base attribute not supplied"));

Dwarf_Op *fb_expr;

size_t fb_len;

switch (dwarf_getlocation_addr (ctx->fb_attr, ctx->pc,

&fb_expr, &fb_len, 1))

{

case 1: /* Should always happen. */

if (fb_len == 0)

goto fb_inaccessible;

break;

default: /* Shouldn't happen. */

case -1:

FAIL (loc, N_("dwarf_getlocation_addr (form %#x): %s"),

dwarf_whatform (ctx->fb_attr), dwarf_errmsg (-1));

return NULL;

case 0: /* Shouldn't happen. */

fb_inaccessible:

FAIL (loc, N_("DW_AT_frame_base not accessible at this address"));

return NULL;

}

// If it is DW_OP_call_frame_cfa then get cfi cfa ops.

const Dwarf_Op * fb_ops;

if (fb_len == 1 && fb_expr[0].atom == DW_OP_call_frame_cfa)

{

if (ctx->cfa_ops == NULL)

FAIL (loc, N_("No cfa_ops supplied, but needed by DW_OP_call_frame_cfa"));

fb_ops = ctx->cfa_ops;

}

else

fb_ops = fb_expr;

loc->frame_base = alloc_location (ctx);

failure = translate (ctx, indent + 1, fb_ops, fb_len, NULL,

NULL, &loser, loc->frame_base);

if (failure != NULL)

return lose (loc, fb_ops, fb_len, failure, loser);

}

if (*input != NULL)

(*input)->next = loc;

*input = loc;

return loc;

}

#if _ELFUTILS_PREREQ (0, 149)

static struct location *

location_from_attr (struct location_context *ctx, int indent,

Dwarf_Attribute *attr)

{

Dwarf_Op *expr;

size_t len;

switch (dwarf_getlocation_addr (attr, ctx->pc, &expr, &len, 1))

{

case 1: /* Should always happen. */

if (len > 0)

break;

/* Fall through. */

case 0: /* Shouldn't happen. */

(*ctx->fail) (ctx->fail_arg, N_("not accessible at this address (%#" PRIx64 ")"), ctx->pc);

return NULL;

default: /* Shouldn't happen. */

case -1:

(*ctx->fail) (ctx->fail_arg, "dwarf_getlocation_addr: %s",