/* 

  Copyright (C) 2000,2004,2005,2006 Silicon Graphics, Inc.  All Rights Reserved.

  Portions Copyright 2007 Sun Microsystems, Inc. All rights reserved.

  Portions Copyright 2007 David Anderson. All rights reserved.

  This program is free software; you can redistribute it and/or modify it

  under the terms of version 2 of the GNU 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 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.

  Contact information:  Silicon Graphics, Inc., 1500 Crittenden Lane,

  Mountain View, CA 94043, or:

  http://www.sgi.com

  For further information regarding this notice, see:

  http://oss.sgi.com/projects/GenInfo/NoticeExplan

$ Header: /plroot/cmplrs.src/v7.4.5m/.RCS/PL/dwarfdump/RCS/print_die.c,v 1.51 2006/04/01 16:20:21 davea Exp $ */

#include "globals.h"

#include "dwarf_names.h"

#include "esb.h"		/* For flexible string buffer. */

#include "makename.h"		/* Non-duplicating string table. */

static void get_attr_value(Dwarf_Debug dbg, Dwarf_Half tag,

			   Dwarf_Attribute attrib, 

                           char **srcfiles,

			   Dwarf_Signed cnt, struct esb_s *esbp);

static void print_attribute(Dwarf_Debug dbg, Dwarf_Die die,

			    Dwarf_Half attr,

			    Dwarf_Attribute actual_addr,

			    boolean print_information, char **srcfiles,

			    Dwarf_Signed cnt);

static void get_location_list(Dwarf_Debug dbg, Dwarf_Die die,

			      Dwarf_Attribute attr, struct esb_s *esbp);

static int tag_attr_combination(Dwarf_Half tag, Dwarf_Half attr);

static int _dwarf_print_one_expr_op(Dwarf_Debug dbg,Dwarf_Loc* expr,int index, struct esb_s *string_out);

/* esb_base is static so gets initialized to zeros.  

   It is not thread-safe or

   safe for multiple open producer instances for

   but that does not matter here in dwarfdump.

   The memory used by esb_base is never freed.

*/

static struct esb_s esb_base;	

static int indent_level = 0;

static boolean local_symbols_already_began = FALSE;

typedef string(*encoding_type_func) (Dwarf_Debug dbg, Dwarf_Half val);

Dwarf_Off fde_offset_for_cu_low = DW_DLV_BADOFFSET;

Dwarf_Off fde_offset_for_cu_high = DW_DLV_BADOFFSET;

/* Dwarf_Half list_of_attrs[] */

/*#include "at_list.i" unreferenced */

#define DIE_STACK_SIZE 300

static Dwarf_Die die_stack[DIE_STACK_SIZE];

#define PUSH_DIE_STACK(x) { die_stack[indent_level] = x; }

#define POP_DIE_STACK { die_stack[indent_level] = 0; }

#include "_tag_tree_table.c"

/*

   Look only at valid table entries

   The check here must match the building-logic in

   tag_tree.c

   And must match the tags defined in dwarf.h

*/

#define MAX_CHECKED_TAG_ID 0x35

static int

tag_tree_combination(Dwarf_Half tag_parent, Dwarf_Half tag_child)

{

    if (tag_parent > 0 && tag_parent <= MAX_CHECKED_TAG_ID

	&& tag_child > 0 && tag_child <= MAX_CHECKED_TAG_ID) {

	return ((tag_tree_combination_table[tag_parent]

		 [tag_child / 0x20]

		 & (1 << (tag_child % 0x20))) > 0 ? TRUE : FALSE);

    } else

	return (FALSE);

}

/* recursively follow the die tree */

extern void

print_die_and_children(Dwarf_Debug dbg, Dwarf_Die in_die_in,

		       char **srcfiles, Dwarf_Signed cnt)

{

    Dwarf_Die child;

    Dwarf_Die sibling;

    Dwarf_Error err;

    int tres;

    int cdres;

    Dwarf_Die in_die = in_die_in;

    for (;;) {

	PUSH_DIE_STACK(in_die);

	if (check_tag_tree) {

	    tag_tree_result.checks++;

	    if (indent_level == 0) {

		Dwarf_Half tag;

		tres = dwarf_tag(in_die, &tag, &err);

		if (tres != DW_DLV_OK) {

		    tag_tree_result.errors++;

		    DWARF_CHECK_ERROR

			("Tag-tree root is not DW_TAG_compile_unit")

		} else if (tag == DW_TAG_compile_unit) {

		    /* OK */

		} else {

		    tag_tree_result.errors++;

		    DWARF_CHECK_ERROR

			("tag-tree root is not DW_TAG_compile_unit")

		}

	    } else {

		Dwarf_Half tag_parent, tag_child;

		int pres;

		int cres;

		char *ctagname = "<child tag invalid>";

		char *ptagname = "<parent tag invalid>";

		pres =

		    dwarf_tag(die_stack[indent_level - 1], &tag_parent,

			      &err);

		cres = dwarf_tag(in_die, &tag_child, &err);

		if (pres != DW_DLV_OK)

		    tag_parent = 0;

		if (cres != DW_DLV_OK)

		    tag_child = 0;

		if (cres != DW_DLV_OK || pres != DW_DLV_OK) {

		    if (cres == DW_DLV_OK) {

			ctagname = get_TAG_name(dbg, tag_child);

		    }

		    if (pres == DW_DLV_OK) {

			ptagname = get_TAG_name(dbg, tag_parent);

		    }

		    DWARF_CHECK_ERROR3(ptagname,

				       ctagname,

				       "Tag-tree relation is not standard..");

		} else if (tag_tree_combination(tag_parent, tag_child)) {

		    /* OK */

		} else {

		    DWARF_CHECK_ERROR3(get_TAG_name(dbg, tag_parent),

				       get_TAG_name(dbg, tag_child),

				       "tag-tree relation is not standard.");

		}

	    }

	}

	/* here to pre-descent processing of the die */

	print_one_die(dbg, in_die, info_flag, srcfiles, cnt);

	cdres = dwarf_child(in_die, &child, &err);

	/* child first: we are doing depth-first walk */

	if (cdres == DW_DLV_OK) {

	    indent_level++;

	    if(indent_level >= DIE_STACK_SIZE ) {

	        print_error(dbg,

                  "compiled in DIE_STACK_SIZE limit exceeded",

                  DW_DLV_OK,err);

	    }

	    print_die_and_children(dbg, child, srcfiles, cnt);

	    indent_level--;

	    if (indent_level == 0)

		local_symbols_already_began = FALSE;

	    dwarf_dealloc(dbg, child, DW_DLA_DIE);

	} else if (cdres == DW_DLV_ERROR) {

	    print_error(dbg, "dwarf_child", cdres, err);

	}

	cdres = dwarf_siblingof(dbg, in_die, &sibling, &err);

	if (cdres == DW_DLV_OK) {

	    /* print_die_and_children(dbg, sibling, srcfiles, cnt); We

	       loop around to actually print this, rather than

	       recursing. Recursing is horribly wasteful of stack

	       space. */

	} else if (cdres == DW_DLV_ERROR) {

	    print_error(dbg, "dwarf_siblingof", cdres, err);

	}

	/* Here do any post-descent (ie post-dwarf_child) processing of 

	   the in_die. */

	POP_DIE_STACK;

	if (in_die != in_die_in) {

	    /* Dealloc our in_die, but not the argument die, it belongs 

	       to our caller. Whether the siblingof call worked or not. 

	     */

	    dwarf_dealloc(dbg, in_die, DW_DLA_DIE);

	}

	if (cdres == DW_DLV_OK) {

	    /* Set to process the sibling, loop again. */

	    in_die = sibling;

	} else {

	    /* We are done, no more siblings at this level. */

	    break;

	}

    }				/* end for loop on siblings */

    return;

}

#define SPACE(x) { register int i; for (i=0;i<x;i++) putchar(' '); }

/* print info about die */

void

print_one_die(Dwarf_Debug dbg, Dwarf_Die die, boolean print_information,

	      char **srcfiles, Dwarf_Signed cnt)

{

    Dwarf_Signed i;

    Dwarf_Off offset, overall_offset;

    string tagname;

    Dwarf_Half tag;

    Dwarf_Signed atcnt;

    Dwarf_Attribute *atlist;

    int tres;

    int ores;

    int atres;

    tres = dwarf_tag(die, &tag, &err);

    if (tres != DW_DLV_OK) {

	print_error(dbg, "accessing tag of die!", tres, err);

    }

    tagname = get_TAG_name(dbg, tag);

    ores = dwarf_dieoffset(die, &overall_offset, &err);

    if (ores != DW_DLV_OK) {

	print_error(dbg, "dwarf_dieoffset", ores, err);

    }

    ores = dwarf_die_CU_offset(die, &offset, &err);

    if (ores != DW_DLV_OK) {

	print_error(dbg, "dwarf_die_CU_offset", ores, err);

    }

    if (!dst_format && print_information) {

	if (indent_level == 0) {

	    if (dense)

		printf("\n");

	    else {

		printf

		    ("\nCOMPILE_UNIT<header overall offset = %llu>:\n",

		     overall_offset - offset);

	    }

	} else if (local_symbols_already_began == FALSE &&

		   indent_level == 1 && !dense) {

	    printf("\nLOCAL_SYMBOLS:\n");

	    local_symbols_already_began = TRUE;

	}

	if (dense) {

            if (show_global_offsets) {

	        if (indent_level == 0) {

		    printf("<%d><%llu+%llu GOFF=%llu><%s>", indent_level,

		       overall_offset - offset, offset,

                       overall_offset, tagname);

	        } else {

		    printf("<%d><%llu GOFF=%llu><%s>", indent_level, 

                       offset, overall_offset, tagname);

	        }

            } else {

	        if (indent_level == 0) {

		    printf("<%d><%llu+%llu><%s>", indent_level,

		       overall_offset - offset, offset, tagname);

	        } else {

		    printf("<%d><%llu><%s>", indent_level, offset, tagname);

	        }

	    }

	} else {

            if (show_global_offsets) {

	        printf("<%d><%5llu GOFF=%llu>\t%s\n", indent_level, offset,

                    overall_offset, tagname);

            } else {

	        printf("<%d><%5llu>\t%s\n", indent_level, offset, tagname);

	    }

	}

    }

    atres = dwarf_attrlist(die, &atlist, &atcnt, &err);

    if (atres == DW_DLV_ERROR) {

	print_error(dbg, "dwarf_attrlist", atres, err);

    } else if (atres == DW_DLV_NO_ENTRY) {

	/* indicates there are no attrs.  It is not an error. */

	atcnt = 0;

    }

    for (i = 0; i < atcnt; i++) {

	Dwarf_Half attr;

	int ares;

	ares = dwarf_whatattr(atlist[i], &attr, &err);

	if (ares == DW_DLV_OK) {

	    print_attribute(dbg, die, attr,

			    atlist[i],

			    print_information, srcfiles, cnt);

	} else {

	    print_error(dbg, "dwarf_whatattr entry missing", ares, err);

	}

    }

    for (i = 0; i < atcnt; i++) {

	dwarf_dealloc(dbg, atlist[i], DW_DLA_ATTR);

    }

    if (atres == DW_DLV_OK) {

	dwarf_dealloc(dbg, atlist, DW_DLA_LIST);

    }

    if (dense && print_information) {

	printf("\n\n");

    }

    return;

}

/* Encodings have undefined signedness. Accept either

   signedness.  The values are small (they are defined

   in the DWARF specification), so the

   form the compiler uses (as long as it is

   a constant value) is a non-issue.

   If string_out is non-NULL, construct a string output, either

   an error message or the name of the encoding.

   The function pointer passed in is to code generated

   by a script at dwarfdump build time. The code for

   the val_as_string function is generated

   from dwarf.h.  See <build dir>/dwarf_names.c

   If string_out is non-NULL then attr_name and val_as_string

   must also be non-NULL.

*/

int

get_small_encoding_integer_and_name(Dwarf_Debug dbg,

				    Dwarf_Attribute attrib,

				    Dwarf_Unsigned * uval_out,

				    char *attr_name,

				    string * string_out,

				    encoding_type_func val_as_string,

				    Dwarf_Error * err)

{

    Dwarf_Unsigned uval = 0;

    char buf[100];		/* The strings are small. */

    int vres = dwarf_formudata(attrib, &uval, err);

    if (vres != DW_DLV_OK) {

	Dwarf_Signed sval = 0;

	vres = dwarf_formsdata(attrib, &sval, err);

	if (vres != DW_DLV_OK) {

	    if (string_out != 0) {

		snprintf(buf, sizeof(buf),

			 "%s has a bad form.", attr_name);

		*string_out = makename(buf);

	    }

	    return vres;

	}

	*uval_out = (Dwarf_Unsigned) sval;

    } else {

	*uval_out = uval;

    }

    if (string_out)

	*string_out = val_as_string(dbg, (Dwarf_Half) uval);

    return DW_DLV_OK;

}

/*

 * We need a 32-bit signed number here, but there's no portable

 * way of getting that.  So use __uint32_t instead.  It's supplied

 * in a reliable way by the autoconf infrastructure.

 */

static void

get_FLAG_BLOCK_string(Dwarf_Debug dbg, Dwarf_Attribute attrib)

{

    int fres = 0;

    Dwarf_Block *tempb = 0;

    __uint32_t * array = 0;

    Dwarf_Unsigned array_len = 0;

    __uint32_t * array_ptr;

    Dwarf_Unsigned array_remain = 0;

    char linebuf[100];

    esb_empty_string(&esb_base);

    esb_append(&esb_base, "\n");

    /* first get compressed block data */

    fres = dwarf_formblock (attrib,&tempb, &err);

    if (fres != DW_DLV_OK) {

	print_error(dbg,"DW_FORM_blockn cannot get block\n",fres,err);

	return;

    }

    /* uncompress block into int array */

    array = dwarf_uncompress_integer_block(dbg,

			   1, /* 'true' (meaning signed ints)*/

			   32, /* bits per unit */

			   tempb->bl_data,

			   tempb->bl_len,

			   &array_len, /* len of out array */

			   &err);

    if (array == (void*) DW_DLV_BADOFFSET) {

	print_error(dbg,"DW_AT_SUN_func_offsets cannot uncompress data\n",0,err);

	return;

    }

    if (array_len == 0) {

	print_error(dbg,"DW_AT_SUN_func_offsets has no data\n",0,err);

	return;

    }

    /* fill in string buffer */

    array_remain = array_len;

    array_ptr = array;

    while (array_remain > 8) {

	/* print a full line */

	/* if you touch this string, update the magic number 78 below! */

	snprintf(linebuf, sizeof(linebuf), 

		"\n  %8x %8x %8x %8x %8x %8x %8x %8x",

		array_ptr[0],		array_ptr[1],

		array_ptr[2],		array_ptr[3],

		array_ptr[4],		array_ptr[5],

		array_ptr[6],		array_ptr[7]);

	array_ptr += 8;

	array_remain -= 8;

	esb_append(&esb_base, linebuf);

    }

    /* now do the last line */

    if (array_remain > 0) {

	esb_append(&esb_base, "\n ");

	while (array_remain > 0) {

	    snprintf(linebuf, sizeof(linebuf), " %8x", *array_ptr);

	    array_remain--;

	    array_ptr++;

	    esb_append(&esb_base, linebuf);

	}

    }

    /* free array buffer */

    dwarf_dealloc_uncompressed_block(dbg, array);

}

static void

print_attribute(Dwarf_Debug dbg, Dwarf_Die die, Dwarf_Half attr,

		Dwarf_Attribute attr_in,

		boolean print_information,

		char **srcfiles, Dwarf_Signed cnt)

{

    Dwarf_Attribute attrib = 0;

    Dwarf_Unsigned uval = 0;

    string atname = 0;

    string valname = 0;

    int tres = 0;

    Dwarf_Half tag = 0;

    atname = get_AT_name(dbg, attr);

    /* the following gets the real attribute, even in the face of an 

       incorrect doubling, or worse, of attributes */

    attrib = attr_in;

    /* do not get attr via dwarf_attr: if there are (erroneously) 

       multiple of an attr in a DIE, dwarf_attr will not get the

       second, erroneous one and dwarfdump will print the first one

       multiple times. Oops. */

    tres = dwarf_tag(die, &tag, &err);

    if (tres == DW_DLV_ERROR) {

	tag = 0;

    } else if (tres == DW_DLV_NO_ENTRY) {

	tag = 0;

    } else {

	/* ok */

    }

    if (check_attr_tag) {

	char *tagname = "<tag invalid>";

	attr_tag_result.checks++;

	if (tres == DW_DLV_ERROR) {

	    attr_tag_result.errors++;

	    DWARF_CHECK_ERROR3(tagname,

			       get_AT_name(dbg, attr),

			       "check the tag-attr combination.");

	} else if (tres == DW_DLV_NO_ENTRY) {

	    attr_tag_result.errors++;

	    DWARF_CHECK_ERROR3(tagname,

			       get_AT_name(dbg, attr),

			       "check the tag-attr combination..")

	} else if (tag_attr_combination(tag, attr)) {

	    /* OK */

	} else {

	    attr_tag_result.errors++;

	    tagname = get_TAG_name(dbg, tag);

	    DWARF_CHECK_ERROR3(tagname,

			       get_AT_name(dbg, attr),

			       "check the tag-attr combination")

	}

    }

    switch (attr) {

    case DW_AT_language:

	get_small_encoding_integer_and_name(dbg, attrib, &uval,

					    "DW_AT_language", &valname,

					    get_LANG_name, &err);

	break;

    case DW_AT_accessibility: