/*
Copyright (C) 2000,2004 Silicon Graphics, Inc. All Rights Reserved.
Portions Copyright 2011-2020 David Anderson. All Rights Reserved.
This program is free software; you can redistribute it
and/or modify it under the terms of version 2.1 of the
GNU Lesser General Public License as published by the Free
Software Foundation.
This program is distributed in the hope that it would be
useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.
Further, this software is distributed without any warranty
that it is free of the rightful claim of any third person
regarding infringement or the like. Any license provided
herein, whether implied or otherwise, applies only to this
software file. Patent licenses, if any, provided herein
do not apply to combinations of this program with other
software, or any other product whatsoever.
You should have received a copy of the GNU Lesser General
Public License along with this program; if not, write the
Free Software Foundation, Inc., 51 Franklin Street - Fifth
Floor, Boston MA 02110-1301, USA.
*/
#include <config.h>
#include <stddef.h> /* NULL size_t */
#include <string.h> /* memcpy() strlen() */
#include "dwarf.h"
#include "libdwarf.h"
#include "dwarf_base_types.h"
#include "libdwarfp.h"
#include "dwarf_pro_incl.h"
#include "dwarf_pro_opaque.h"
#include "dwarf_pro_error.h"
#include "dwarf_pro_alloc.h"
#include "dwarf_pro_section.h"
#include "dwarf_pro_macinfo.h"
/* I don't much like the error strings this generates, since
like the rest of libdwarf they are simple strings with
no useful numbers in them. But that's not something I can
fix without more work than I have time for
right now. davea Nov 94.
*/
/* these are gross overestimates of the number of
** bytes needed to store a number in LEB form.
** Just estimates, and since blocks are reasonable size,
** the end-block waste is small.
** Of course the waste is NOT present on disk.
*/
#define COMMAND_LEN ENCODE_SPACE_NEEDED
#define LINE_LEN ENCODE_SPACE_NEEDED
#define BASE_MACINFO_MALLOC_LEN 2048
static int
libdwarf_compose_begin(Dwarf_P_Debug dbg, int code,
size_t maxlen, int *compose_error_type)
{
unsigned char *nextchar;
struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;
if (curblk == 0) {
struct dw_macinfo_block_s *newb;
size_t len;
/* initial allocation */
size_t blen = BASE_MACINFO_MALLOC_LEN;
if (blen < maxlen) {
blen = 2 * maxlen;
}
len = sizeof(struct dw_macinfo_block_s) + blen;
newb = (struct dw_macinfo_block_s *)
_dwarf_p_get_alloc(dbg, len);
if (!newb) {
*compose_error_type = DW_DLE_MACINFO_MALLOC_FAIL;
return DW_DLV_ERROR;
}
newb->mb_data =
(char *) newb + sizeof(struct dw_macinfo_block_s);
newb->mb_avail_len = blen;
newb->mb_used_len = 0;
newb->mb_macinfo_data_space_len = blen;
dbg->de_first_macinfo = newb;
dbg->de_current_macinfo = newb;
curblk = newb;
} else if (curblk->mb_avail_len < maxlen) {
struct dw_macinfo_block_s *newb;
size_t len;
/* no space left in block: allocate a new block */
size_t blen =
dbg->de_current_macinfo->mb_macinfo_data_space_len * 2;
if (blen < maxlen) {
blen = 2 * maxlen;
}
len = sizeof(struct dw_macinfo_block_s) + blen;
newb = (struct dw_macinfo_block_s *)
_dwarf_p_get_alloc(dbg, len);
if (!newb) {
*compose_error_type = DW_DLE_MACINFO_MALLOC_FAIL;
return DW_DLV_ERROR;
}
newb->mb_data =
(char *) newb + sizeof(struct dw_macinfo_block_s);
newb->mb_avail_len = blen;
newb->mb_used_len = 0;
newb->mb_macinfo_data_space_len = blen;
dbg->de_first_macinfo->mb_next = newb;
dbg->de_current_macinfo = newb;
curblk = newb;
}
/* now curblk has enough room */
dbg->de_compose_avail = curblk->mb_avail_len;
dbg->de_compose_used_len = curblk->mb_used_len;
nextchar = (unsigned char *)
(curblk->mb_data + dbg->de_compose_used_len);
*nextchar = code;
dbg->de_compose_avail--;
++dbg->de_compose_used_len;
return DW_DLV_OK;
}
static void
libdwarf_compose_add_string(Dwarf_P_Debug dbg,
const char *string,
size_t len)
{
struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;
unsigned char *nextchar;
nextchar = (unsigned char *)
(curblk->mb_data + dbg->de_compose_used_len);
len += 1; /* count the null terminator */
memcpy(nextchar, string, len);
dbg->de_compose_avail -= len;
dbg->de_compose_used_len += len;
return;
}
static int
libdwarf_compose_add_line(Dwarf_P_Debug dbg,
Dwarf_Unsigned line, int *compose_error_type)
{
struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;
unsigned char *nextchar;
int res;
int nbytes;
nextchar = (unsigned char *)
(curblk->mb_data + dbg->de_compose_used_len);
/* Put the created leb number directly into the macro buffer If
dbg->de_compose_avail is > INT_MAX this will not work as the
'int' will look negative to dwarf_encode_leb128! */
res = dwarf_encode_leb128(line, &nbytes,
(char *) nextchar,
(int) dbg->de_compose_avail);
if (res != DW_DLV_OK) {
*compose_error_type = DW_DLE_MACINFO_INTERNAL_ERROR_SPACE;
return DW_DLV_ERROR;
}
dbg->de_compose_avail -= nbytes;
dbg->de_compose_used_len += nbytes;
return DW_DLV_OK;
}
/* This function actually 'commits' the space used by the
preceeding calls. */
static int
libdwarf_compose_complete(Dwarf_P_Debug dbg, int *compose_error_type)
{
struct dw_macinfo_block_s *curblk = dbg->de_current_macinfo;
if (dbg->de_compose_used_len >
curblk->mb_macinfo_data_space_len) {
*compose_error_type = DW_DLE_MACINFO_INTERNAL_ERROR_SPACE;
return DW_DLV_ERROR;
}
curblk->mb_avail_len = dbg->de_compose_avail;
curblk->mb_used_len = dbg->de_compose_used_len;
return DW_DLV_OK;
}
int
dwarf_def_macro(Dwarf_P_Debug dbg,
Dwarf_Unsigned line,
char *macname, char *macvalue, Dwarf_Error * error)
{
size_t len;
size_t len2;
size_t length_est;
int res;
int compose_error_type;
if (dbg == NULL) {
_dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
return DW_DLV_ERROR;
}
if (macname == 0) {
_dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_NULL);
return DW_DLV_ERROR;
}
len = strlen(macname) + 1;
if (len == 0) {
_dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_EMPTY);
return DW_DLV_ERROR;
}
if (macvalue) {
len2 = strlen(macvalue) + 1;
} else {
len2 = 0;
}
/* 1 for space character we add */
length_est = COMMAND_LEN + LINE_LEN + len + len2 + 1;
res = libdwarf_compose_begin(dbg, DW_MACINFO_define, length_est,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
res = libdwarf_compose_add_line(dbg, line, &compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
libdwarf_compose_add_string(dbg, macname, len);
libdwarf_compose_add_string(dbg, " ", 1);
if (macvalue) {
libdwarf_compose_add_string(dbg, " ", 1);
libdwarf_compose_add_string(dbg, macvalue, len2);
}
res = libdwarf_compose_complete(dbg, &compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
return DW_DLV_OK;
}
int
dwarf_undef_macro(Dwarf_P_Debug dbg,
Dwarf_Unsigned line,
char *macname, Dwarf_Error * error)
{
size_t len;
size_t length_est;
int res;
int compose_error_type;
if (dbg == NULL) {
_dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
return DW_DLV_ERROR;
}
if (macname == 0) {
_dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_NULL);
return DW_DLV_ERROR;
}
len = strlen(macname) + 1;
if (len == 0) {
_dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_EMPTY);
return DW_DLV_ERROR;
}
length_est = COMMAND_LEN + LINE_LEN + len;
res = libdwarf_compose_begin(dbg, DW_MACINFO_undef, length_est,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
res = libdwarf_compose_add_line(dbg, line, &compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
libdwarf_compose_add_string(dbg, macname, len);
res = libdwarf_compose_complete(dbg, &compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
return DW_DLV_OK;
}
int
dwarf_start_macro_file(Dwarf_P_Debug dbg,
Dwarf_Unsigned fileindex,
Dwarf_Unsigned linenumber, Dwarf_Error * error)
{
size_t length_est;
int res;
int compose_error_type;
if (dbg == NULL) {
_dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
return DW_DLV_ERROR;
}
length_est = COMMAND_LEN + LINE_LEN + LINE_LEN;
res = libdwarf_compose_begin(dbg, DW_MACINFO_start_file,
length_est,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
res = libdwarf_compose_add_line(dbg, fileindex,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
res = libdwarf_compose_add_line(dbg, linenumber,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
return DW_DLV_OK;
}
int
dwarf_end_macro_file(Dwarf_P_Debug dbg, Dwarf_Error * error)
{
size_t length_est;
int res;
int compose_error_type;
if (dbg == NULL) {
_dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
return DW_DLV_ERROR;
}
length_est = COMMAND_LEN;
res = libdwarf_compose_begin(dbg, DW_MACINFO_end_file, length_est,
&compose_error_type);
if (res == DW_DLV_ERROR) {
_dwarf_p_error(dbg, error, compose_error_type);
return DW_DLV_ERROR;
}
res = libdwarf_compose_complete(dbg, &compose_error_type);
if (res == DW_DLV_ERROR) {
_dwarf_p_error(dbg, error, compose_error_type);
return res;
}
return res;
}
int
dwarf_vendor_ext(Dwarf_P_Debug dbg,
Dwarf_Unsigned constant,
char *string, Dwarf_Error * error)
{
size_t len;
size_t length_est;
int res;
int compose_error_type;
if (dbg == NULL) {
_dwarf_p_error(NULL, error, DW_DLE_DBG_NULL);
return DW_DLV_ERROR;
}
if (string == 0) {
_dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_NULL);
return DW_DLV_ERROR;
}
len = strlen(string) + 1;
if (len == 0) {
_dwarf_p_error(NULL, error, DW_DLE_MACINFO_STRING_EMPTY);
return DW_DLV_ERROR;
}
length_est = COMMAND_LEN + LINE_LEN + len;
res = libdwarf_compose_begin(dbg, DW_MACINFO_vendor_ext,
length_est,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
res = libdwarf_compose_add_line(dbg, constant,
&compose_error_type);
if (res != DW_DLV_OK) {
_dwarf_p_error(NULL, error, compose_error_type);
return DW_DLV_ERROR;
}
libdwarf_compose_add_string(dbg, string, len);
libdwarf_compose_complete(dbg, &compose_error_type);
return DW_DLV_OK;
}
int
_dwarf_pro_transform_macro_info_to_disk(Dwarf_P_Debug dbg,
Dwarf_Unsigned *nbufs,
Dwarf_Error * error)
{
/* Total num of bytes in .debug_macinfo section. */
Dwarf_Unsigned mac_num_bytes;
/* Points to first byte of .debug_macinfo buffer. */
Dwarf_Small *macinfo;
/* Fills in the .debug_macinfo buffer. */
Dwarf_Small *macinfo_ptr;
/* Used to scan the section data buffers. */
struct dw_macinfo_block_s *m_prev;
struct dw_macinfo_block_s *m_sect;
/* Get the size of the debug_macinfo data */
mac_num_bytes = 0;
for (m_sect = dbg->de_first_macinfo; m_sect != NULL;
m_sect = m_sect->mb_next) {
mac_num_bytes += m_sect->mb_used_len;
}
/* The final entry has a type code of 0 to indicate It is final
for this CU Takes just 1 byte. */
mac_num_bytes += 1;
GET_CHUNK(dbg, dbg->de_elf_sects[DEBUG_MACINFO],
macinfo, (unsigned long) mac_num_bytes, error);
macinfo_ptr = macinfo;
m_prev = 0;
for (m_sect = dbg->de_first_macinfo; m_sect != NULL;
m_sect = m_sect->mb_next) {
memcpy(macinfo_ptr, m_sect->mb_data, m_sect->mb_used_len);
macinfo_ptr += m_sect->mb_used_len;
if (m_prev) {
_dwarf_p_dealloc((Dwarf_Small *) m_prev);
}
m_prev = m_sect;
}
*macinfo_ptr = 0; /* the type code of 0 as last entry */
if (m_prev) {
_dwarf_p_dealloc((Dwarf_Small *) m_prev);
m_prev = 0;
}
dbg->de_first_macinfo = NULL;
dbg->de_current_macinfo = NULL;
*nbufs = dbg->de_n_debug_sect;
return DW_DLV_OK;
}