| /* Return location expression list. |
| Copyright (C) 2000, 2001, 2002 Red Hat, Inc. |
| Written by Ulrich Drepper <drepper@redhat.com>, 2000. |
| |
| This program is Open Source software; you can redistribute it and/or |
| modify it under the terms of the Open Software License version 1.0 as |
| published by the Open Source Initiative. |
| |
| You should have received a copy of the Open Software License along |
| with this program; if not, you may obtain a copy of the Open Software |
| License version 1.0 from http://www.opensource.org/licenses/osl.php or |
| by writing the Open Source Initiative c/o Lawrence Rosen, Esq., |
| 3001 King Ranch Road, Ukiah, CA 95482. */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include <config.h> |
| #endif |
| |
| #include <dwarf.h> |
| #include <stdlib.h> |
| |
| #include <libdwarfP.h> |
| |
| |
| struct loclist |
| { |
| Dwarf_Small atom; |
| Dwarf_Unsigned number; |
| Dwarf_Unsigned number2; |
| Dwarf_Unsigned offset; |
| struct loclist *next; |
| }; |
| |
| struct locdesclist |
| { |
| Dwarf_Addr lopc; |
| Dwarf_Addr hipc; |
| Dwarf_Half cents; |
| struct loclist *s; |
| struct locdesclist *next; |
| }; |
| |
| |
| int |
| dwarf_loclist (attr, llbuf, listlen, error) |
| Dwarf_Attribute attr; |
| Dwarf_Locdesc **llbuf; |
| Dwarf_Signed *listlen; |
| Dwarf_Error *error; |
| { |
| Dwarf_CU_Info cu = attr->cu; |
| Dwarf_Debug dbg = cu->dbg; |
| Dwarf_Unsigned offset; |
| Dwarf_Unsigned offset_end; |
| Dwarf_Small *locp; |
| struct locdesclist *locdesclist; |
| Dwarf_Locdesc *result; |
| unsigned int n; |
| |
| /* Must by one of the attribute listed below. */ |
| if (attr->code != DW_AT_location |
| && attr->code != DW_AT_data_member_location |
| && attr->code != DW_AT_vtable_elem_location |
| && attr->code != DW_AT_string_length |
| && attr->code != DW_AT_use_location |
| && attr->code != DW_AT_return_addr) |
| { |
| __libdwarf_error (dbg, error, DW_E_WRONG_ATTR); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Must have the form data4 or data8 which act as an offset. */ |
| if (attr->form == DW_FORM_data4) |
| offset = read_4ubyte_unaligned (dbg, attr->valp); |
| else if (likely (attr->form == DW_FORM_data8)) |
| offset = read_8ubyte_unaligned (dbg, attr->valp); |
| else |
| { |
| __libdwarf_error (dbg, error, DW_E_NO_DATA); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Check whether the .debug_loc section is available. */ |
| if (unlikely (dbg->sections[IDX_debug_loc].addr == NULL)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| /* This is the part of the .debug_loc section we can read. */ |
| locp = (Dwarf_Small *) dbg->sections[IDX_debug_loc].addr + offset; |
| offset_end = offset + dbg->sections[IDX_debug_loc].size; |
| |
| locdesclist = NULL; |
| n = 0; |
| while (1) |
| { |
| Dwarf_Addr lopc; |
| Dwarf_Addr hipc; |
| Dwarf_Ptr data; |
| Dwarf_Unsigned len2; |
| struct locdesclist *newdesc; |
| Dwarf_Small *locp; |
| Dwarf_Small *blkendp; |
| Dwarf_Small *blkstartp; |
| |
| if (unlikely (dwarf_get_loclist_entry (dbg, offset, &hipc, &lopc, &data, |
| &len2, &offset, error) |
| != DW_DLV_OK)) |
| return DW_DLV_ERROR; |
| |
| /* Does this signal the end? */ |
| if (lopc == 0 && hipc == 0) |
| break; |
| |
| locp = data; |
| blkstartp = locp; |
| blkendp = locp + len2; |
| |
| /* Create a new Locdesc entry. */ |
| newdesc = (struct locdesclist *) alloca (sizeof (struct locdesclist)); |
| newdesc->lopc = lopc; |
| newdesc->hipc = hipc; |
| newdesc->cents = 0; |
| newdesc->s = NULL; |
| newdesc->next = locdesclist; |
| locdesclist = newdesc; |
| ++n; |
| |
| /* Decode the opcodes. It is possible in some situations to |
| have a block of size zero. */ |
| while (locp < blkendp) |
| { |
| struct loclist *newloc; |
| |
| newloc = (struct loclist *) alloca (sizeof (struct loclist)); |
| newloc->number = 0; |
| newloc->number2 = 0; |
| newloc->offset = locp - blkstartp; |
| newloc->next = newdesc->s; |
| newdesc->s = newloc; |
| ++newdesc->cents; |
| |
| newloc->atom = *locp; |
| switch (*locp++) |
| { |
| case DW_OP_addr: |
| /* Address, depends on address size of CU. */ |
| if (cu->address_size == 4) |
| { |
| if (unlikely (locp + 4 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_4ubyte_unaligned (dbg, locp); |
| locp += 4; |
| } |
| else |
| { |
| if (unlikely (locp + 8 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_8ubyte_unaligned (dbg, locp); |
| locp += 8; |
| } |
| break; |
| |
| case DW_OP_deref: |
| case DW_OP_dup: |
| case DW_OP_drop: |
| case DW_OP_over: |
| case DW_OP_swap: |
| case DW_OP_rot: |
| case DW_OP_xderef: |
| case DW_OP_abs: |
| case DW_OP_and: |
| case DW_OP_div: |
| case DW_OP_minus: |
| case DW_OP_mod: |
| case DW_OP_mul: |
| case DW_OP_neg: |
| case DW_OP_not: |
| case DW_OP_or: |
| case DW_OP_plus: |
| case DW_OP_shl: |
| case DW_OP_shr: |
| case DW_OP_shra: |
| case DW_OP_xor: |
| case DW_OP_eq: |
| case DW_OP_ge: |
| case DW_OP_gt: |
| case DW_OP_le: |
| case DW_OP_lt: |
| case DW_OP_ne: |
| case DW_OP_lit0: |
| case DW_OP_lit1: |
| case DW_OP_lit2: |
| case DW_OP_lit3: |
| case DW_OP_lit4: |
| case DW_OP_lit5: |
| case DW_OP_lit6: |
| case DW_OP_lit7: |
| case DW_OP_lit8: |
| case DW_OP_lit9: |
| case DW_OP_lit10: |
| case DW_OP_lit11: |
| case DW_OP_lit12: |
| case DW_OP_lit13: |
| case DW_OP_lit14: |
| case DW_OP_lit15: |
| case DW_OP_lit16: |
| case DW_OP_lit17: |
| case DW_OP_lit18: |
| case DW_OP_lit19: |
| case DW_OP_lit20: |
| case DW_OP_lit21: |
| case DW_OP_lit22: |
| case DW_OP_lit23: |
| case DW_OP_lit24: |
| case DW_OP_lit25: |
| case DW_OP_lit26: |
| case DW_OP_lit27: |
| case DW_OP_lit28: |
| case DW_OP_lit29: |
| case DW_OP_lit30: |
| case DW_OP_lit31: |
| case DW_OP_reg0: |
| case DW_OP_reg1: |
| case DW_OP_reg2: |
| case DW_OP_reg3: |
| case DW_OP_reg4: |
| case DW_OP_reg5: |
| case DW_OP_reg6: |
| case DW_OP_reg7: |
| case DW_OP_reg8: |
| case DW_OP_reg9: |
| case DW_OP_reg10: |
| case DW_OP_reg11: |
| case DW_OP_reg12: |
| case DW_OP_reg13: |
| case DW_OP_reg14: |
| case DW_OP_reg15: |
| case DW_OP_reg16: |
| case DW_OP_reg17: |
| case DW_OP_reg18: |
| case DW_OP_reg19: |
| case DW_OP_reg20: |
| case DW_OP_reg21: |
| case DW_OP_reg22: |
| case DW_OP_reg23: |
| case DW_OP_reg24: |
| case DW_OP_reg25: |
| case DW_OP_reg26: |
| case DW_OP_reg27: |
| case DW_OP_reg28: |
| case DW_OP_reg29: |
| case DW_OP_reg30: |
| case DW_OP_reg31: |
| case DW_OP_nop: |
| case DW_OP_push_object_address: |
| case DW_OP_call_ref: |
| /* No operand. */ |
| break; |
| |
| case DW_OP_const1u: |
| case DW_OP_pick: |
| case DW_OP_deref_size: |
| case DW_OP_xderef_size: |
| if (unlikely (locp >= blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = *((uint8_t *) locp)++; |
| break; |
| |
| case DW_OP_const1s: |
| if (unlikely (locp >= blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = *((int8_t *) locp)++; |
| break; |
| |
| case DW_OP_const2u: |
| if (unlikely (locp + 2 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_2ubyte_unaligned (dbg, locp); |
| locp += 2; |
| break; |
| |
| case DW_OP_const2s: |
| case DW_OP_skip: |
| case DW_OP_bra: |
| case DW_OP_call2: |
| if (unlikely (locp + 2 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_2sbyte_unaligned (dbg, locp); |
| locp += 2; |
| break; |
| |
| case DW_OP_const4u: |
| if (unlikely (locp + 4 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_4ubyte_unaligned (dbg, locp); |
| locp += 4; |
| break; |
| |
| case DW_OP_const4s: |
| case DW_OP_call4: |
| if (unlikely (locp + 4 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_4sbyte_unaligned (dbg, locp); |
| locp += 4; |
| break; |
| |
| case DW_OP_const8u: |
| if (unlikely (locp + 8 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_8ubyte_unaligned (dbg, locp); |
| locp += 8; |
| break; |
| |
| case DW_OP_const8s: |
| if (unlikely (locp + 8 > blkendp)) |
| { |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| newloc->number = read_8sbyte_unaligned (dbg, locp); |
| locp += 8; |
| break; |
| |
| case DW_OP_constu: |
| case DW_OP_plus_uconst: |
| case DW_OP_regx: |
| case DW_OP_piece: |
| /* XXX Check size. */ |
| get_uleb128 (newloc->number, locp); |
| break; |
| |
| case DW_OP_consts: |
| case DW_OP_breg0: |
| case DW_OP_breg1: |
| case DW_OP_breg2: |
| case DW_OP_breg3: |
| case DW_OP_breg4: |
| case DW_OP_breg5: |
| case DW_OP_breg6: |
| case DW_OP_breg7: |
| case DW_OP_breg8: |
| case DW_OP_breg9: |
| case DW_OP_breg10: |
| case DW_OP_breg11: |
| case DW_OP_breg12: |
| case DW_OP_breg13: |
| case DW_OP_breg14: |
| case DW_OP_breg15: |
| case DW_OP_breg16: |
| case DW_OP_breg17: |
| case DW_OP_breg18: |
| case DW_OP_breg19: |
| case DW_OP_breg20: |
| case DW_OP_breg21: |
| case DW_OP_breg22: |
| case DW_OP_breg23: |
| case DW_OP_breg24: |
| case DW_OP_breg25: |
| case DW_OP_breg26: |
| case DW_OP_breg27: |
| case DW_OP_breg28: |
| case DW_OP_breg29: |
| case DW_OP_breg30: |
| case DW_OP_breg31: |
| case DW_OP_fbreg: |
| /* XXX Check size. */ |
| get_sleb128 (newloc->number, locp); |
| break; |
| |
| case DW_OP_bregx: |
| /* XXX Check size. */ |
| get_uleb128 (newloc->number, locp); |
| get_sleb128 (newloc->number2, locp); |
| break; |
| |
| default: |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| } |
| } |
| |
| if (unlikely (n == 0)) |
| { |
| /* This is not allowed. |
| |
| XXX Is it? */ |
| __libdwarf_error (dbg, error, DW_E_INVALID_DWARF); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Allocate the array. */ |
| result = (Dwarf_Locdesc *) malloc (n * sizeof (Dwarf_Locdesc)); |
| if (result == NULL) |
| { |
| __libdwarf_error (dbg, error, DW_E_NOMEM); |
| return DW_DLV_ERROR; |
| } |
| |
| /* Store the result. */ |
| *llbuf = result; |
| *listlen = n; |
| |
| do |
| { |
| unsigned int cents; |
| struct loclist *s; |
| |
| /* We populate the array from the back since the list is |
| backwards. */ |
| --n; |
| |
| result[n].ld_lopc = locdesclist->lopc; |
| result[n].ld_hipc = locdesclist->hipc; |
| result[n].ld_cents = cents = locdesclist->cents; |
| result[n].ld_s = (Dwarf_Loc *) malloc (cents * sizeof (Dwarf_Loc)); |
| if (result == NULL) |
| { |
| /* XXX Should be bother freeing memory? */ |
| __libdwarf_error (dbg, error, DW_E_NOMEM); |
| return DW_DLV_ERROR; |
| } |
| |
| s = locdesclist->s; |
| while (cents-- > 0) |
| { |
| /* This list is also backwards. */ |
| result[n].ld_s[cents].lr_atom = s->atom; |
| result[n].ld_s[cents].lr_number = s->number; |
| result[n].ld_s[cents].lr_number2 = s->number2; |
| result[n].ld_s[cents].lr_offset = s->offset; |
| s = s->next; |
| } |
| |
| locdesclist = locdesclist->next; |
| } |
| while (n > 0); |
| |
| /* We did it. */ |
| return DW_DLV_OK; |
| } |