arti/irix-657m-src
1
0
Fork 0
Code Activity
Files
main
irix-657m-src/irix/cmd/icrash_old/lib/libeval/eval.c
calmsacibis995 8fc8fa8089 Source code upload
2022-09-29 17:59:04 +03:00

3798 lines
78 KiB
C
Raw Permalink Blame History

#ident "$Header: /proj/irix6.5.7m/isms/irix/cmd/icrash_old/lib/libeval/RCS/eval.c,v 1.1 1999/05/25 19:19:20 tjm Exp $"
#define _KERNEL 1
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/param.h>
#include <libelf.h>
#include <dwarf.h>
#include <libdwarf.h>
#include <syms.h>
#include <sym.h>
#include "icrash.h"
#include "extern.h"
#include "eval.h"
#include "variable.h"
#include "dwarflib.h"
/* Global variables
*/
static int logical_flag;
/* The base_type[] array is necessary because base types are not
* directly accessible from the Dwarf database. Three of the entries
* have to be modified at startup if the vmcore image is from a
* 32-bit system. They are the entries for "long", "signed long",
* and "unsigned long". On a 32-bit core dump, these types take up
* four bytes. On a 64-bit system, they take up eight bytes.
*/
base_t base_type[] = {
/*---------------------------------------------------------*/
/* NAME ACTUAL_NAME BYTE_SIZE ENCODING */
/*---------------------------------------------------------*/
{ "char", (char *)0, 1, 6 },
{ "signed char", "char", 1, 6 },
{ "unsigned char", (char *)0, 1, 8 },
{ "short", (char *)0, 2, 5 },
{ "signed short", "short", 2, 5 },
{ "unsigned short", (char *)0, 2, 7 },
{ "int", (char *)0, 4, 5 },
{ "signed int", "int", 4, 5 },
{ "signed", "int", 4, 5 },
{ "unsigned int", (char *)0, 4, 7 },
{ "unsigned", "unsigned int", 4, 7 },
{ "long", (char *)0, 8, 5 },
{ "signed long", "long", 8, 5 },
{ "unsigned long", (char *)0, 8, 7 },
{ "long long", (char *)0, 8, 5 },
{ "signed long long", "long long", 8, 5 },
{ "unsigned long long", (char *)0, 8, 7 },
{ (char *)0, (char *)0, 0, 0 }
};
/*
* get_base_type()
*/
base_t *
get_base_type(char *s)
{
int i, count, blank_count = 0, len, gap = 0;
char *ptr, *first, *last, *gapp = 0, *cp, typename[128] = "";
strcat (typename, s);
ptr = typename;
len = strlen(typename);
/* Strip off any leading "white space" (spaces and tabs)
*/
while ((*ptr == ' ') || (*ptr == '\t')) {
blank_count++;
ptr++;
}
len -= blank_count;
bcopy (ptr, typename, len);
typename[len] = 0;
/* Compress any "white space" between words.
*/
ptr = typename;
blank_count = 0;
while (*ptr && (*ptr != '*')) {
if ((*ptr == ' ') || (*ptr == '\t')) {
cp = ptr + 1;
blank_count = 0;
while ((*cp == ' ') || (*cp == '\t')) {
blank_count++;
cp++;
}
if ((cp - ptr) > 1) {
bcopy(cp, ptr + 1, len - (cp - typename));
len -= blank_count;
}
}
ptr++;
}
*ptr = 0;
for (i = 0; base_type[i].name; i++) {
if (!strcmp(typename, base_type[i].name)) {
break;
}
}
if (base_type[i].name) {
return(&base_type[i]);
}
else {
return((base_t*)NULL);
}
}
/*
* base_typestr()
*/
char *
base_typestr(type_t *tp, int flags)
{
int i, len = 0, ptrcnt = 0;
type_t *t;
base_t *btp;
char *tsp, *c;
t = tp;
while (t->flag == POINTER_FLAG) {
ptrcnt++;
t = t->t_next;
}
btp = (base_t *)t->t_ptr;
if (btp->actual_name) {
len = strlen(btp->actual_name) + ptrcnt + 3;
}
else {
len = strlen(btp->name) + ptrcnt + 3;
}
tsp = (char *)ALLOC_BLOCK(len, flags);
c = tsp;
*c++ = '(';
if (btp->actual_name) {
strcat(c, btp->actual_name);
c += strlen(btp->actual_name);
}
else {
strcat(c, btp->name);
c += strlen(btp->name);
}
for (i = 0; i < ptrcnt; i++) {
*c++ = '*';
}
*c++ = ')';
*c = 0;
return(tsp);
}
/*
* get_type() -- Convert a typecast string into a type.
*
* Returns a pointer to a struct containing type information (dwarf,
* base, etc.) The type of struct returned is indicated by the
* contents of type. If the typecast contains an asterisk, set
* ptr_type equal to one, otherwise set it equal to zero.
*/
type_t *
get_type(char *s, int flags)
{
static int symtable_type = -1;
int len, type = 0;
char *cp, typename[128];
base_t *bp;
type_t *t, *head, *last;
dw_type_t *dtp;
dw_type_info_t *dti;
head = last = (type_t *)NULL;
if (symtable_type < 0) {
symtable_type = DWARF_TYPE_FLAG;
}
if (!strncmp(s, "struct", 6)) {
if (cp = strpbrk(s + 7, " \t*")) {
len = cp - (s + 7);
}
else {
len = strlen(s + 7);
}
bcopy (s + 7, typename, len);
typename[len] = 0;
if (symtable_type == DWARF_TYPE_FLAG) {
if (!(dtp = dw_lkup(stp, typename, DW_TAG_structure_type))) {
return ((type_t *)NULL);
}
type = DWARF_TYPE_FLAG;
}
}
else if (!strncmp(s, "union", 5)) {
if (cp = strpbrk(s + 6, " \t*")) {
len = cp - (s + 6);
}
else {
len = strlen(s + 6);
}
bcopy (s + 6, typename, len);
typename[len] = 0;
if (symtable_type == DWARF_TYPE_FLAG) {
if (!(dtp = dw_lkup(stp, typename, DW_TAG_union_type))) {
return ((type_t *)NULL);
}
type = DWARF_TYPE_FLAG;
}
}
else if (bp = get_base_type(s)) {
type = BASE_TYPE_FLAG;
}
else {
/* Check to see if this is a typedef
*/
if (cp = strpbrk(s, " \t*)")) {
len = cp - s;
}
else {
len = strlen(s);
}
bcopy (s, typename, len);
typename[len] = 0;
if (symtable_type == DWARF_TYPE_FLAG) {
if (!(dtp = dw_lkup(stp, typename, DW_TAG_typedef))) {
return ((type_t *)NULL);
}
type = DWARF_TYPE_FLAG;
}
}
/* check to see if this cast is a pointer to a type (or a pointer
* to a pointer to a type, etc.)
*/
cp = s;
while (cp = strpbrk(cp, "*")) {
t = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
t->flag = POINTER_FLAG;
if (last) {
last->t_next = t;
last = t;
}
else {
head = last = t;
}
cp++;
}
/* Allocate a type block that will point to the type specific
* (BASE or DWARF) record
*/
t = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
t->flag = type;
switch (t->flag) {
case BASE_TYPE_FLAG :
t->t_ptr = (void *)bp;
break;
case DWARF_TYPE_FLAG :
dti = (dw_type_info_t *)ALLOC_BLOCK(sizeof(*dti), flags);
if (!dw_type_info(dtp->dt_off, dti, flags)) {
return((type_t*)NULL);
}
t->t_ptr = (void *)dti;
break;
default :
free_type(head);
return((type_t*)NULL);
}
if (last) {
last->t_next = t;
}
else {
head = t;
}
return(head);
}
/*
* free_type()
*/
void
free_type(type_t *head)
{
type_t *t0, *t1;
t0 = head;
while(t0) {
if (t0->flag == POINTER_FLAG) {
t1 = t0->t_next;
free_block((k_ptr_t)t0);
t0 = t1;
}
else {
if (is_temp_block(t0->t_ptr)) {
if (t0->flag == DWARF_TYPE_FLAG) {
dw_free_type_info((dw_type_info_t*)t0->t_ptr);
}
else {
free_block((k_ptr_t)t0->t_ptr);
}
}
free_block((k_ptr_t)t0);
t0 = (type_t *)NULL;
}
}
}
/*
* member_to_type() -- Converts a struct/union member to a type
*
* With dwarf members, all DW_TAG_pointer dies are converted to
* type_t structs with POINTER_FLAG set. The original dw_type_info_t
* struct pointer is linked to the t_link field -- since it contains
* information necessary for the dowhatis() command.
*/
type_t *
member_to_type(void *x, int ntype, int flags)
{
dw_die_t *dp;
dw_type_info_t *t, *dti;
type_t *tp, *head = (type_t *)NULL, *last = (type_t *)NULL;
if (ntype == DWARF_TYPE_FLAG) {
t = (dw_type_info_t *)x;
/* Make sure this is a DW_TAG_member
*/
if (t->t_tag != DW_TAG_member) {
return((type_t *)NULL);
}
dp = t->t_actual_type;
while (dp && dp->d_tag == DW_TAG_pointer_type) {
tp = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
tp->flag = POINTER_FLAG;
if (last) {
last->t_next = tp;
last = tp;
}
else {
head = last = tp;
}
dp = dp->d_next;
}
/* If We step past all the pointer dies and don't point at anything,
* this must be a void pointer. Setup a VOID type struct so that we
* can maintain a pointer to the type info in dw_type_info_t struct.
*/
if (!dp) {
tp = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
tp->flag = VOID_FLAG;
tp->t_ptr = t;
if (last) {
last->t_next = tp;
last = tp;
}
else {
head = last = tp;
}
return(head);
}
dti = (dw_type_info_t *)ALLOC_BLOCK(sizeof(*dti), flags);
switch (dp->d_tag) {
case DW_TAG_structure_type :
/* Check to see if this die points to the struct
* members. If not, we need to search for the actual
* struct definition.
*/
if (!dp->d_sibling_off) {
dw_type_t *dtp;
if (!(dtp = dw_lkup(stp, dp->d_name,
DW_TAG_structure_type))) {
/* Information is not available for this
* struct. Make the actual type be dp. It's
* better to have something rather than
* nothing.
*/
t->t_actual_type = t->t_type;
tp = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
tp->flag = DWARF_TYPE_FLAG;
tp->t_ptr = (void *)t;
if (last) {
last->t_next = tp;
}
else {
head = tp;
}
return(head);
}
if (!dw_type_info(dtp->dt_off, dti, flags)) {
return((type_t *)NULL);
}
}
else {
if (!dw_type_info(dp->d_off, dti, flags)) {
return((type_t *)NULL);
}
}
break;
case DW_TAG_union_type :
/* Check to see if this die points to the union
* members. If not, we need to search for the actual
* union definition.
*/
if (!dp->d_sibling_off) {
dw_type_t *dtp;
if (!(dtp = dw_lkup(stp,
dp->d_name, DW_TAG_union_type))) {
/* Information is not available for this
* union. Make the actual type be dp. It's
* better to have something rather than
* nothing.
*/
t->t_actual_type = t->t_type;
tp = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
tp->flag = DWARF_TYPE_FLAG;
tp->t_ptr = (void *)t;
if (last) {
last->t_next = tp;
}
else {
head = tp;
}
return(head);
}
if (!dw_type_info(dtp->dt_off, dti, flags)) {
return((type_t *)NULL);
}
}
else {
if (!dw_type_info(dp->d_off, dti, flags)) {
return((type_t *)NULL);
}
}
break;
default :
if (!dw_type_info(dp->d_off, dti, flags)) {
return((type_t *)NULL);
}
break;
}
/* Check to see if the real type is a DW_TAG_base_type. If it is,
* then check to see if t_bit_offset and/or t_bit_size are set in
* the original dw_type_info_s struct. If they are, copy the values
* over to dti.
*/
if (dti->t_tag == DW_TAG_base_type) {
if (t->t_bit_offset) {
dti->t_bit_offset = t->t_bit_offset;
}
if (t->t_bit_size) {
dti->t_bit_size = t->t_bit_size;
}
dti->t_byte_size = t->t_byte_size;
}
/* Save the pointer to the info about the actual member (for
* use by dowhatis() )
*/
dti->t_link = t;
tp = (type_t *)ALLOC_BLOCK(sizeof(type_t), flags);
tp->flag = DWARF_TYPE_FLAG;
tp->t_ptr = (void *)dti;
if (last) {
last->t_next = tp;
}
else {
head = tp;
}
return(head);
}
return((type_t *)NULL);
}
/*
* is_keyword()
*/
int
is_keyword(char *c, int len)
{
/* This is temporary. Really need to lookup string to see if
* it is a type or typedef.
*/
if (!strncmp(c, "struct", len)) {
return(1);
}
else if (!strncmp(c, "union", len)) {
return(1);
}
else if (!strncmp(c, "char", len)) {
return(1);
}
else if (!strncmp(c, "short", len)) {
return(1);
}
else if (!strncmp(c, "int", len)) {
return(1);
}
else if (!strncmp(c, "long", len)) {
return(1);
}
else if (!strncmp(c, "unsigned", len)) {
return(1);
}
else if (!strncmp(c, "signed", len)) {
return(1);
}
else {
char *c1;
c1 = (char*)alloc_block(len+1, B_TEMP);
strncat(c1, c, len);
c1[len] = 0;
switch (symbol_table) {
case DWARF_TYPE_FLAG:
if (dw_lkup(stp, c1, DW_TAG_typedef)) {
free_block((k_ptr_t)c1);
return(1);
}
break;
}
free_block((k_ptr_t)c1);
}
return(0);
}
/*
* expand_variables()
*/
char *
expand_variables(char *exp, int flags)
{
int len;
char vname[64], *s, *e, *v, *newexp;
variable_t *vp;
newexp = (char *)ALLOC_BLOCK(256, flags);
e = exp;
v = strchr(e, '$');
while (v) {
vname[0] = 0;
strncat(newexp, e, (v - e));
if (s = strpbrk((v + 1), " .\t+-*/()[]|~!$&%^<>?:&=^\"\'")) {
len = (uint)s - (uint)v + 1;
}
else {
len = strlen(v) + 1;
}
strncpy(vname, v, len);
vname[len -1] = 0;
vp = find_variable(vtab, vname, V_TYPEDEF|V_STRING);
if (!vp) {
return((char *)NULL);
}
/* If this is a typedef, then make sure the typestr is between
* an open and close parenthesis. Otherwise, just include the
* string.
*/
if (vp->v_flags & V_TYPEDEF) {
strcat(newexp, "(");
strcat(newexp, vp->v_typestr);
strcat(newexp, ")");
}
else {
strcat(newexp, vp->v_exp);
}
if (e = s) {
v = strchr(e, '$');;
}
else {
v = (char *)NULL;
}
}
if (e) {
strcat(newexp, e);
}
return(newexp);
}
/*
* get_token_list()
*/
token_t *
get_token_list(char *str, int *error)
{
int i, paren_count = 0;
char *cp;
token_t *tok, *tok_head = (token_t*)NULL, *tok_last = (token_t*)NULL;
cp = str;
*error = 0;
while (*cp) {
/* Skip past any "white space" (spaces and tabs).
*/
switch (*cp) {
case ' ' :
case '\t' :
case '`' :
cp++;
continue;
case '\'' :
break;
case '\"' :
break;
default :
break;
}
/* Allocate space for the next token
*/
tok = (token_t *)alloc_block(sizeof(token_t), B_TEMP);
tok->ptr = cp;
switch(*cp) {
/* Check for operators
*/
case '+' :
if (*((char*)cp + 1) == '+') {
/* We aren't doing asignment here, so the ++ operator
* is not considered valid.
*/
*error = E_BAD_OPERATOR;
return (tok_last);
}
else if (!tok_last ||
(tok_last->operator && (tok_last->operator != CLOSE_PAREN))) {
tok->operator = UNARY_PLUS;
}
else {
tok->operator = ADD;
}
break;
case '-' :
if (*((char*)cp + 1) == '-') {
/* We aren't doing asignment here, so the -- operator
* is not considered valid.
*/
*error = E_BAD_OPERATOR;
return (tok_last);
}
else if (*((char*)cp + 1) == '>') {
tok->operator = RIGHT_ARROW;
cp++;
}
else if (!tok_last ||
(tok_last->operator && (tok_last->operator != CLOSE_PAREN))) {
tok->operator = UNARY_MINUS;
}
else {
tok->operator = SUBTRACT;
}
break;
case '.' :
/* XXX - need to check to see if this is a decimal point
* in the middle fo a floating point value.
*/
tok->operator = DOT;
break;
case '*' :
/* XXX - need a better way to tell if this is an INDIRECTION.
* perhaps check the next token?
*/
if (!tok_last ||
(tok_last->operator && ((tok_last->operator != CLOSE_PAREN) &&
(tok_last->operator != CAST)))) {
tok->operator = INDIRECTION;
}
else {
tok->operator = MULTIPLY;
}
break;
case '/' :
tok->operator = DIVIDE;
break;
case '%' :
tok->operator = MODULUS;
break;
case '(' : {
char *s;
int len;
/* Make sure the previous token is an operator
*/
if (tok_last && !tok_last->operator) {
*error = E_SYNTAX_ERROR;
return (tok_last);
}
if (tok_last && ((tok_last->operator == RIGHT_ARROW) ||
(tok_last->operator == DOT))) {
*error = E_SYNTAX_ERROR;
return (tok_last);
}
/* Check here to see if following tokens constitute a cast.
*/
/* Skip past any "white space" (spaces and tabs)
*/
while ((*(cp+1) == ' ') || (*(cp+1) == '\t')) {
cp++;
}
if ((*(cp+1) == '(') || (*(cp+1) == '*') || (*(cp+1) == ')')){
tok->operator = OPEN_PAREN;
paren_count++;
break;
}
if (s = strpbrk(cp+1, " *)")) {
len = (uint)s - (uint)(cp+1);
if (is_keyword((char*)((uint)(cp+1)), len)) {
if (!(s = strpbrk((cp+1), ")"))) {
*error = E_OPEN_PAREN;
return (tok);
}
len = (uint)s - (uint)(cp+1);
tok->string = (char *)alloc_block(len + 1, B_TEMP);
bcopy((cp+1), tok->string, len);
tok->string[len] = 0;
tok->operator = CAST;
cp = (char *)((uint)(cp+1) + len);
break;
}
}
tok->operator = OPEN_PAREN;
paren_count++;
break;
}
case ')' :
if (tok_last && ((tok_last->operator == RIGHT_ARROW) ||
(tok_last->operator == DOT))) {
*error = E_SYNTAX_ERROR;
return (tok_last);
}
tok->operator = CLOSE_PAREN;
paren_count--;
break;
case '&' :
if (*((char*)cp + 1) == '&') {
tok->operator = LOGICAL_AND;
cp++;
}
else if (!tok_last || (tok_last &&
(tok_last->operator &&
tok_last->operator != CLOSE_PAREN))) {
tok->operator = ADDRESS;
}
else {
tok->operator = BITWISE_AND;
}
break;
case '|' :
if (*((char*)cp + 1) == '|') {
tok->operator = LOGICAL_OR;
cp++;
}
else {
tok->operator = BITWISE_OR;
}
break;
case '=' :
if (*((char*)cp + 1) == '=') {
tok->operator = EQUAL;
cp++;
}
else {
/* ASIGNMENT -- NOT IMPLEMENTED
*/
tok->operator = NOT_YET;
}
break;
case '<' :
if (*((char*)cp + 1) == '<') {
tok->operator = LEFT_SHIFT;
cp++;
}
else if (*((char*)cp + 1) == '=') {
tok->operator = LESS_THAN_OR_EQUAL;
cp++;
}
else {
tok->operator = LESS_THAN;
}
break;
case '>' :
if (*((char*)(cp + 1)) == '>') {
tok->operator = RIGHT_SHIFT;
cp++;
}
else if (*((char*)cp + 1) == '=') {
tok->operator = GREATER_THAN_OR_EQUAL;
cp++;
}
else {
tok->operator = GREATER_THAN;
}
break;
case '!' :
if (*((char*)cp + 1) == '=') {
tok->operator = NOT_EQUAL;
cp++;
}
else {
tok->operator = LOGICAL_NEGATION;
}
break;
case '$' : {
int e, len;
char *s, *vname;
variable_t *vp;
token_t *t;
if (s = strpbrk((cp + 1), " .\t+-*/()[]|~!$&%^<>?:&=^\"\'")) {
len = (uint)s - (uint)cp + 1;
}
else {
len = strlen(cp) + 1;
}
vname = (char *)alloc_block(len, B_TEMP);
memcpy(vname, cp, (len -1));
vname[len - 1] = 0;
vp = find_variable(vtab, vname, 0);
if (!vp || (vp->v_flags & V_COMMAND)) {
*error = E_BAD_EVAR;
free_block((k_ptr_t)vname);
return(tok);
}
if (vp->v_flags & V_TYPEDEF) {
free_block((k_ptr_t)vname);
free_tokens(tok);
t = get_token_list(vp->v_typestr, &e);
if (!tok_head) {
tok_head = tok_last = t;
}
else {
tok_last->next = t;
while (t->next) {
t = t->next;
}
tok_last = t;
}
if (cp = s) {
continue;
}
else {
return(tok_head);
}
}
else if (vp->v_flags & V_STRING) {
if (tok_head) {
*error = E_END_EXPECTED;
return(tok);
}
/* Skip ahead to the first non-blank character
*/
while (s && (*s == ' ')) {
s++;
}
if (s && (*s != 0)) {
*error = E_END_EXPECTED;
tok->ptr = s;
return(tok);
}
tok->string =
(char *)alloc_block(strlen(vp->v_exp) + 1, B_TEMP);
/* We have to copy the string so that it doesn't
* get freed when the token is freed.
*/
strcpy(tok->string, vp->v_exp);
tok->type = TEXT;
return(tok);
}
}
case '~' :
tok->operator = ONES_COMPLEMENT;
break;
case '^' :
tok->operator = BITWISE_EXCLUSIVE_OR;
break;
case '?' :
tok->operator = CONDITIONAL;
break;
case ':' :
tok->operator = CONDITIONAL_ELSE;
break;
case '[' :
tok->operator = OPEN_SQUARE_BRACKET;;
break;
case ']' :
tok->operator = CLOSE_SQUARE_BRACKET;;
break;
default: {
char *s;
int len;
/* Check and see if this token is a STRING or CHARACTER
* type (begins with a single or double quote).
*/
if ((*cp == '\'') || (*cp == '\"')) {
/* Make sure we don't already have any tokens.
*/
if (tok_head) {
*error = E_END_EXPECTED;
return(tok);
}
switch (*cp) {
case '\'' :
s = strpbrk((cp + 1), "\'");
if (!s) {
*error = E_BAD_STRING;
return(tok);
}
len = (uint)s - (uint)cp;
if (len == 2) {
tok->type = CHARACTER;
}
else {
tok->type = TEXT;
}
break;
case '\"' :
s = strpbrk((cp + 1), "\"");
if (!s) {
*error = E_BAD_STRING;
return(tok);
}
len = (uint)s - (uint)cp;
tok->type = TEXT;
break;
}
if (strlen(cp) > (len + 1)) {
/* Check to see if there is a colon or
* semi-colon directly following the
* string. If there is, then the string
* is OK (the following characters are part
* of the next expression). Also, it's OK
* to have trailing blanks as long as that's
* all threre is.
*/
char *c;
c = s + 1;
while (*c) {
if ((*c == ',') || (*c == ';')) {
break;
}
else if (*c != ' ') {
*error = E_END_EXPECTED;
tok->ptr = c;
return(tok);
}
c++;
}
/* Truncate the trailing blanks (they are not part
* of the string).
*/
if (c != (s + 1)) {
*(s + 1) = 0;
}
}
tok->string = (char *)alloc_block(len, B_TEMP);
bcopy((cp + 1), tok->string, len - 1);
tok->string[len - 1] = 0;
return(tok);
}
if (s = strpbrk(cp, " .\t+-*/()[]|~!$&%^<>?:&=^\"\'")) {
len = (uint)s - (uint)cp + 1;
}
else {
len = strlen(cp) + 1;
}
tok->string = (char *)alloc_block(len, B_TEMP);
bcopy(cp, tok->string, len - 1);
tok->string[len - 1] = 0;
cp = (char *)((uint)cp + len - 2);
/* Check to see if this is the keyword "sizeof." If not,
* then check to see if the string is a member name.
*/
if (!strcmp(tok->string, "sizeof")) {
tok->operator = SIZEOF;
free_block((k_ptr_t)tok->string);
tok->string = 0;
}
else if (tok_last && ((tok_last->operator == RIGHT_ARROW) ||
(tok_last->operator == DOT))) {
tok->type = MEMBER;
}
else {
tok->type = STRING;
}
break;
}
}
if (!(tok->type)) {
tok->type = OPERATOR;
}
if (!tok_head) {
tok_head = tok_last = tok;
}
else {
tok_last->next = tok;
tok_last = tok;
}
cp++;
}
if (paren_count < 0) {
*error = E_CLOSE_PAREN;
return(tok);
}
else if (paren_count > 0) {
*error = E_OPEN_PAREN;
return(tok);
}
if (DEBUG(DC_EVAL, 1)) {
token_t *t;
fprintf(KL_ERRORFP, " TOKEN OPERATOR PTR "
"STRING NEXT\n");
fprintf(KL_ERRORFP, "--------------------------------------------------"
"----------------\n");
t = tok_head;
while(t) {
fprintf(KL_ERRORFP, "%8x %8d %8x %26s %8x\n",
t, t->operator, t->ptr, t->string, t->next);
t = t->next;
}
fprintf(KL_ERRORFP, "--------------------------------------------------"
"----------------\n");
}
return(tok_head);
}
/*
* is_unary()
*/
int
is_unary(int op)
{
switch (op) {
case LOGICAL_NEGATION :
case ADDRESS :
case INDIRECTION :
case UNARY_MINUS :
case UNARY_PLUS :
case ONES_COMPLEMENT :
case CAST :
return(1);
default :
return(0);
}
}
/*
* is_binary()
*/
int
is_binary(int op)
{
switch (op) {
case BITWISE_OR :
case BITWISE_EXCLUSIVE_OR :
case BITWISE_AND :
case RIGHT_SHIFT :
case LEFT_SHIFT :
case ADD :
case SUBTRACT :
case MULTIPLY :
case DIVIDE :
case MODULUS :
case LOGICAL_OR :
case LOGICAL_AND :
case EQUAL :
case NOT_EQUAL :
case LESS_THAN :
case GREATER_THAN :
case LESS_THAN_OR_EQUAL :
case GREATER_THAN_OR_EQUAL :
case RIGHT_ARROW :
case DOT :
return(1);
default :
return(0);
}
}
/*
* precedence()
*/
int
precedence(int a)
{
if ((a >= CONDITIONAL) && (a <= CONDITIONAL_ELSE)) {
return(1);
}
else if (a == LOGICAL_OR) {
return(2);
}
else if (a == LOGICAL_AND) {
return(3);
}
else if (a == BITWISE_OR) {
return(4);
}
else if (a == BITWISE_EXCLUSIVE_OR) {
return(5);
}
else if (a == BITWISE_AND) {
return(6);
}
else if ((a >= EQUAL) && (a <= NOT_EQUAL)) {
return(7);
}
else if ((a >= LESS_THAN) && (a <= GREATER_THAN_OR_EQUAL)) {
return(8);
}
else if ((a >= RIGHT_SHIFT) && (a <= LEFT_SHIFT)) {
return(9);
}
else if ((a >= ADD) && (a <= SUBTRACT)) {
return(10);
}
else if ((a >= MULTIPLY) && (a <= MODULUS)) {
return(11);
}
else if ((a >= LOGICAL_NEGATION) && (a <= SIZEOF)) {
return(12);
}
else if ((a >= RIGHT_ARROW) && (a <= DOT)) {
return(13);
}
else {
return(0);
}
}
/*
* make_node()
*/
node_t *
make_node(token_t *t, int flags)
{
node_t *np;
struct syment *sp;
symdef_t *sdp;
np = (node_t*)ALLOC_BLOCK(sizeof(*np), flags);
if (t->type == OPERATOR) {
/* Check to see if this token represents a typecast
*/
if (t->operator == CAST) {
type_t *tp;
if (!(np->type = get_type(t->string, flags))) {
free_nodes(np);
return((node_t*)NULL);
}
np->node_type = OPERATOR;
np->operator = CAST;
/* Determin whether or not this is a pointer to a type
* and the type class (base or dwarf).
*/
tp = np->type;
if (tp->flag == POINTER_FLAG) {
np->flags = POINTER_FLAG;
tp = tp->t_next;
while (tp->flag == POINTER_FLAG) {
tp = tp->t_next;
}
}
switch(tp->flag) {
case BASE_TYPE_FLAG:
np->flags |= BASE_TYPE_FLAG;
break;
case DWARF_TYPE_FLAG:
np->flags |= DWARF_TYPE_FLAG;
break;
default:
free_nodes(np);
return((node_t*)NULL);
}
}
else {
np->node_type = OPERATOR;
np->operator = t->operator;
}
}
else if (t->type == MEMBER) {
np->name = (char *)dup_block((k_ptr_t)t->string, B_TEMP);
np->node_type = MEMBER;
}
else if (t->type == STRING) {
if ((sp = get_sym(t->string, B_TEMP)) && !(flags & C_NOVARS)) {
np->address = sp->n_value;
np->flags |= ADDRESS_FLAG;
np->name = t->string;
t->string = (char*)NULL;
np->node_type = VARIABLE;
/* Need to make a call to sym_lkup() to see if there
* is type information available for this variable.
*
* XXX - The symdef_s struct actually overlays dw_type_s
* struct. In that struct is the die offset of the variable.
* If type information is available for this variable, then
* we need to follow this path (check the variable die, then
* the type, etc.) Not sure if there are any functions that
* will do this right now (get_type() takes a type name --
* something that we don't have yet).
*/
sdp = sym_lkup(stp, np->name);
free_sym(sp);
/* XXX - For now, addtach a type struct for type long (it will
* be the size of a kernel pointer). That will at least let us
* do something and will prevent the scenario where we have a
* type node with out a pointer to a type struct! This needs
* to be replaced with code to handle actual variable types.
*/
np->type = alloc_block(sizeof(type_t), flags);
np->type->flag = POINTER_FLAG;
np->type->t_ptr = get_type("long", flags);
np->node_type = TYPE_DEF;
np->flags |= POINTER_FLAG;
kl_get_block(K, np->address, K_NBPW(K),
&np->value, "pointer value");
if (!PTRSZ64(K)) {
np->value >>= 32;
}
}
else if (flags & (C_WHATIS|C_SIZEOF)) {
switch (symbol_table) {
case DWARF_TYPE_FLAG : {
dw_type_t *dtp;
/* Check and see if this is a struct name
*/
dtp = dw_lkup(stp, t->string, DW_TAG_structure_type);
if (!dtp) {
/* Check to see if this is a union name
*/
dtp = dw_lkup(stp, t->string, DW_TAG_union_type);
}
if (!dtp) {
/* Check to see if this is a typedef name
*/
dtp = dw_lkup(stp, t->string, DW_TAG_typedef);
}
if (dtp) {
/* If struct, union or typedef
*/
dw_type_info_t *dti;
dti =
(dw_type_info_t*)ALLOC_BLOCK(sizeof(*dti), flags);
dw_type_info(dtp->dt_off, dti, flags);
np->node_type = TYPE_DEF;
np->flags = DWARF_TYPE_FLAG;
np->type = (type_t*)alloc_block(sizeof(type_t), B_TEMP);
np->type->flag = DWARF_TYPE_FLAG;
np->type->t_ptr = dti;
}
else if (sp) {
np->address = sp->n_value;
np->flags |= ADDRESS_FLAG;
np->name = t->string;
t->string = (char*)NULL;
np->node_type = VARIABLE;
free_sym(sp);
}
else {
if (GET_VALUE(t->string, &np->value)) {
free_nodes(np);
return((node_t*)NULL);
}
np->node_type = NUMBER;
}
return(np);
}
}
}
else {
if (GET_VALUE(t->string, &np->value)) {
free_nodes(np);
return((node_t*)NULL);
}
np->node_type = NUMBER;
}
}
else if ((t->type == TEXT) || (t->type == CHARACTER)) {
np->node_type = t->type;
np->name = t->string;
t->string = (char*)NULL; /* So the block doesn't get freed twice */
}
else {
/* ERROR! */
}
np->tok_ptr = t->ptr;
return(np);
}
/*
* get_node()
*/
node_t *
get_node(token_t **tpp, int flags)
{
node_t *n;
n = make_node(*tpp, flags);
*tpp = (*tpp)->next;
return(n);
}
/*
* add_node()
*/
int
add_node(node_t *root, node_t *new_node)
{
node_t *n = root;
/* Find the most lower-right node
*/
while (n->right) {
n = n->right;
}
/* If the node we found is a leaf node, return an error (we will
* have to insert the node instead).
*/
if (n->node_type == NUMBER) {
return(-1);
}
else {
n->right = new_node;
}
return(0);
}
/*
* add_rchild()
*/
int
add_rchild(node_t *root, node_t *new_node)
{
if (add_node(root, new_node) == -1) {
return(-1);
}
return(0);
}
/*
* add_lchild()
*/
int
add_lchild(node_t *root, node_t *new_node)
{
node_t *n = root;
/* Find the most lower-left node and make sure it is not a leaf
* (child) node.
*/
while (n->left) {
n = n->left;
}
/* If the node we found is a leaf node, return an error.
*/
if (n->node_type == NUMBER) {
return(-1);
}
else {
n->left = new_node;
}
return(0);
}
/*
* node_to_typestr()
*
* Return a type string based on contents of node. The string is
* allocated as B_TEMP or B_PERM depending on the contents of flags.
*
*/
char *
node_to_typestr(node_t *np, int flags)
{
char *tsp = (char *)NULL;
type_t *t;
/* Determine if this is a Dwarf type or base type. Determine this
* by walking pointer chain until we get to the type-specific struct.
* However, pass a pointer to the entire chain on to the typestr
* routine.
*/
if (np->flags & DWARF_TYPE_FLAG) {
tsp = dw_typestr(np->type, flags);
}
else if (np->flags & BASE_TYPE_FLAG) {
tsp = base_typestr(np->type, flags);
}
else {
/* Assume the value is an int.
*/
tsp = (char *)ALLOC_BLOCK(6, flags);
strcpy(tsp, "(int)");
}
return(tsp);
}
/*
* free_tokens()
*/
void
free_tokens(token_t *tp)
{
token_t *t, *tnext;
t = tp;
while (t) {
tnext = t->next;
if (t->string) {
free_block((k_ptr_t)t->string);
}
free_block((k_ptr_t)t);
t = tnext;
}
}
/*
* free_nodes()
*/
void
free_nodes(node_t *np)
{
type_t *tp, *tnext;
node_t *q;
/* If there is nothing to free, just return.
*/
if (!np) {
return;
}
if (q = np->left) {
free_nodes(q);
}
if (q = np->right) {
free_nodes(q);
}
if (np->name) {
free_block((k_ptr_t)np->name);
}
free_type(np->type);
free_block((k_ptr_t)np);
}
/*
* get_sizeof()
*/
node_t *
get_sizeof(token_t **tpp, int *error)
{
int size;
node_t *n0;
/* The next token should be either a CAST or an OPEN_PAREN. If it's
* something else, then return with an error.
*/
if ((*tpp)->type == OPERATOR) {
if ((*tpp)->operator == OPEN_PAREN) {
n0 = do_eval(tpp, C_SIZEOF, error);
if (*error) {
return(n0);
}
}
else if ((*tpp)->operator == CAST) {
if (!(n0 = get_node(tpp, C_SIZEOF))) {
*error = E_SYNTAX_ERROR;
return((node_t*)NULL);
}
}
else {
*error = E_BAD_TYPE;
return(n0);
}
if (!n0->type) {
*error = E_NOTYPE;
return(n0);
}
if (n0->type->flag & POINTER_TYPE) {
n0->value = K_NBPW(K);
}
else if (n0->type->flag & DWARF_TYPE_FLAG) {
dw_type_info_t *dp = n0->type->t_ptr;
n0->value = dp->t_byte_size;
}
else if (n0->type->flag & BASE_TYPE_FLAG) {
base_t *bp = n0->type->t_ptr;
n0->value = bp->byte_size;
}
else {
*error = E_BAD_TYPE;
return(n0);
}
n0->node_type = NUMBER;
n0->flags = 0;
n0->operator = 0;
n0->byte_size = 0;
n0->address = 0;
if (n0->type) {
free_type(n0->type);
n0->type = 0;
}
}
return(n0);
}
/*
* do_eval() -- Reduces an equation to a single value.
*
* Any parenthesis (and nested parenthesis) within the equation will
* be solved first via a recursive call to do_eval().
*/
node_t *
do_eval(token_t **tpp, int flags, int *error)
{
node_t *root = (node_t*)NULL, *n0, *n1;
/* Loop through the tokens until we run out of tokens or we hit
* a CLOSE_PAREN. If we hit an OPEN_PAREN, make a recursive call
* to do_eval().
*/
while (*tpp) {
n0 = n1 = (node_t *)NULL;
/* Check for an OPEN_PAREN token
*/
if ((*tpp)->operator == OPEN_PAREN) {
/* skip over the OPEN_PAREN token
*/
*tpp = (*tpp)->next;
/* Get the value contained within the parenthesis. If there
* was an error, just return.
*/
n0 = do_eval(tpp, flags, error);
if (*error) {
free_nodes(root);
return(n0);
}
/* If CLOSE_PAREN was the last token, we are at the end of
* the token list. In that case, just return n0 (which should
* contain the result). Otherwise, just fall through and see
* what the next operator is (so that we can determine the
* proper location for this operand in the parse tree).
*
* Or, if do_eval() was called from get_sizeof(), then we
* need to return also (even if there are aditional tokens.
*/
if (!*tpp || (flags & C_SIZEOF)) {
if (root) {
add_rchild(root, n0);
}
else {
root = n0;
}
return(root);
}
}
else if ((*tpp)->operator == SIZEOF) {
/* skip over the SIZEOF token
*/
*tpp = (*tpp)->next;
n0 = get_sizeof(tpp, error);
if (*error) {
free_nodes(root);
return(n0);
}
}
else if (((*tpp)->operator == CLOSE_PAREN) ||
((*tpp)->operator == CLOSE_SQUARE_BRACKET)) {
/* Reduce the resulting tree to a single value
*/
replace(root, error, flags);
/* Advance the token pointer past the CLOSE_PAREN or
* CLOSE_SQUARE_BRACKET and then return.
*/
*tpp = (*tpp)->next;
return(root);
}
/* If we don't already have a token loaded into n0, get one
* now.
*/
if (!n0) {
if (!(n0 = get_node(tpp, flags))) {
*error = E_SYNTAX_ERROR;
return((node_t*)NULL);
}
}
if (n0->node_type == OPERATOR) {
if (is_unary(n0->operator)) {
int do_eval_call = 0;
if (n0->operator == INDIRECTION) {
/* Make a recursive call to do_eval() and then
* take the resulting value and link it in as
* the right child node (after making sure that
* no error occurred).
*/
do_eval_call++;
n1 = do_eval(tpp, flags, error);
if (*error) {
/* Free nodes, if there are any
*/
free_nodes(root);
free_nodes(n0);
return(n1);
}
}
else if (n0->operator == CAST) {
if (!*tpp) {
*error = E_SYNTAX_ERROR;
}
else if (((*tpp)->type == TYPE_DEF) ||
((*tpp)->type == OPERATOR) ||
((*tpp)->type == VARIABLE)) {
if ((*tpp)->operator == CLOSE_PAREN) {
/* Step over the CLOSE_PAREN and return
*/
*tpp = (*tpp)->next;
return(n0);
}
do_eval_call++;
n1 = do_eval(tpp, flags, error);
}
else if (!(n1 = get_node(tpp, flags))) {
*error = E_SYNTAX_ERROR;
}
if (*error) {
free_nodes(root);
return(n0);
}
}
else if (n0->operator == ADDRESS) {
if (!*tpp) {
*error = E_SYNTAX_ERROR;
}
else if (((*tpp)->operator == OPEN_PAREN) ||
((*tpp)->next &&
(((*tpp)->next->operator == RIGHT_ARROW) ||
((*tpp)->next->operator == DOT)))) {
do_eval_call++;
n1 = do_eval(tpp, flags, error);
}
else if (!(n1 = get_node(tpp, flags))) {
*error = E_SYNTAX_ERROR;
}
if (*error) {
free_nodes(root);
return(n0);
}
}
else if (*tpp && ((*tpp)->operator == OPEN_PAREN)) {
/* skip over the OPEN_PAREN token
*/
*tpp = (*tpp)->next;
/* Get the value contained within the parenthesis. If
* there was an error, just return.
*/
n1 = do_eval(tpp, flags, error);
if (*error) {
free_nodes(root);
free_nodes(n0);
return(n1);
}
}
else {
if ((*tpp == (token_t*)NULL) ||
!(n1 = get_node(tpp, flags))){
*error = E_SYNTAX_ERROR;
free_nodes(root);
return(n0);
}
}
n0->right = n1;
/* Check for nested unary operators
*/
while (is_unary(n1->operator)) {
node_t *n2 = (node_t *)NULL;
/* If there aren't any more tokens, return an
* error (there are none to match up with the
* unary operator).
*/
if (!(*tpp) || !(n2 = get_node(tpp, flags))) {
*error = E_SYNTAX_ERROR;
return(n1);
}
n1->right = n2;
n1 = n2;
}
if (replace_unary(n0, error, flags) == -1) {
if (n0->right) {
free_block((k_ptr_t)n0->right);
n0->right = (node_t *)NULL;
}
if (*error == 0) {
*error = E_SYNTAX_ERROR;
}
return(n0);
}
if (do_eval_call) {
if (!root) {
root = n0;
}
else {
add_rchild(root, n0);
}
if (!replace(root, error, flags)) {
if (!(*error)) {
*error = E_SYNTAX_ERROR;
}
}
return(root);
}
}
else {
/* ERROR? */
}
}
/* n0 should now contain a non-operator node. Check to see if
* there is a next token. If there isn't, just add the last
* rchild and return.
*/
if (!*tpp) {
if (!root) {
root = n0;
}
else {
add_rchild(root, n0);
}
if (!replace(root, error, flags)) {
if (!(*error)) {
*error = E_SYNTAX_ERROR;
}
}
return(root);
}
/* Make sure the next token is an operator.
*/
if (!(*tpp)->operator) {
free_nodes(root);
free_nodes(n0);
n1 = get_node(tpp, flags);
*error = E_SYNTAX_ERROR;
return(n1);
}
else if (((*tpp)->operator == CLOSE_PAREN) ||
((*tpp)->operator == CLOSE_SQUARE_BRACKET)) {
if (root) {
add_rchild(root, n0);
}
else {
root = n0;
}
/* Reduce the resulting tree to a single value
*/
if (!replace(root, error, flags)) {
if (!(*error)) {
*error = E_SYNTAX_ERROR;
}
return(root);
}
/* Advance the token pointer past the CLOSE_PAREN and then
* return.
*/
*tpp = (*tpp)->next;
return(root);
}
else if ((*tpp)->operator == OPEN_SQUARE_BRACKET) {
/* skip over the OPEN_SQUARE_BRACKET token
*/
*tpp = (*tpp)->next;
/* Get the value contained within the brackets. This
* value must represent an array index.
*/
n1 = get_array_index(tpp, error);
if (*error) {
free_nodes(root);
free_nodes(n0);
return(n1);
}
/* Convert the array (or pointer type) to an element type
* using the index value obtained above. Make sure that
* n0 contains some sort of type definition first, however.
*/
if (n0->node_type != TYPE_DEF) {
*error = E_BAD_TYPE;
free_nodes(n1);
return(n0);
}
array_to_element(n0, n1, error);
if (*error) {
free_nodes(n0);
return(n1);
}
free_nodes(n1);
/* If there aren't any more tokens, just
* return.
*/
if (!(*tpp)) {
return(n0);
}
}
else if (!is_binary((*tpp)->operator)) {
free_nodes(root);
n1 = get_node(tpp, flags);
*error = E_SYNTAX_ERROR;
return(n1);
}
/* Now get the operator node
*/
if (!(n1 = get_node(tpp, flags))) {
*error = E_SYNTAX_ERROR;
return((node_t*)NULL);
}
/* Check to see if this binary operator is RIGHT_ARROW or DOT.
* If it is, we need to reduce it to a single value node now.
*/
while ((n1->operator == RIGHT_ARROW) || (n1->operator == DOT)) {
/* The next node must contain the name of the struct|union
* member.
*/
if (!*tpp || ((*tpp)->type != MEMBER)) {
if (root) {
free_nodes(root);
}
free_nodes(n0);
*error = E_BAD_MEMBER;
return(n1);
}
n1->left = n0;
/* Now get the next node and link it as the right child.
*/
if (!(n0 = get_node(tpp, flags))) {
*error = E_SYNTAX_ERROR;
return((node_t*)NULL);
}
n1->right = n0;
if (!(n0 = replace(n1, error, flags))) {
if (!(*error)) {
*error = E_SYNTAX_ERROR;
}
return(n1);
};
/* Check to see if there is a next token. If there is, check
* to see if it is the operator CLOSE_PAREN. If it is, then
* return (skipping over the CLOSE_PAREN first).
*/
if ((*tpp && (*tpp)->operator == CLOSE_PAREN) ||
(*tpp && (*tpp)->operator == CLOSE_SQUARE_BRACKET)) {
if (root) {
add_rchild(root, n0);
}
else {
root = n0;
}
/* Reduce the resulting tree to a single value
*/
replace(root, error, flags);
/* Advance the token pointer past the CLOSE_PAREN and then
* return.
*/
*tpp = (*tpp)->next;
return(root);
}
/* Check to see if the next node is an OPEN_SQUARE_BRACKET.
* If it is, then we have to reduce the contents of the square
* brackets to an index array.
*/
if (*tpp && (*tpp)->operator == OPEN_SQUARE_BRACKET) {
/* Advance the token pointer and call do_eval() again.
*/
*tpp = (*tpp)->next;
n1 = get_array_index(tpp, error);
if (*error) {
free_nodes(root);
free_nodes(n0);
return(n1);
}
/* Convert the array (or pointer type) to an element type
* using the index value obtained above. Make sure that
* n0 contains some sort of type definition first, however.
*/
if (n0->node_type != TYPE_DEF) {
*error = E_BAD_TYPE;
free_nodes(n1);
return(n0);
}
array_to_element(n0, n1, error);
if (*error) {
free_nodes(n0);
return(n1);
}
free_nodes(n1);
}
/* Now get the next operator node (if there is one).
*/
if (!*tpp || !(n1 = get_node(tpp, flags))) {
if (root) {
add_rchild(root, n0);
}
else {
root = n0;
}
return(root);
}
}
if (!root) {
root = n1;
n1->left = n0;
}
else if (precedence(root->operator) >= precedence(n1->operator)) {
add_rchild(root, n0);
n1->left = root;
root = n1;
}
else {
if (!root->right) {
n1->left = n0;
root->right = n1;
}
else {
add_rchild(root, n0);
n1->left = root->right;
root->right = n1;
}
}
} /* while(*tpp) */
return(root);
}
/*
* get_array_index()
*
*/
node_t *
get_array_index(token_t **tpp, int *error)
{
int size, shft;
k_uint_t index;
node_t *n0;
dw_type_info_t *dp;
n0 = do_eval(tpp, 0, error);
if (*error) {
return(n0);
}
if (n0->node_type != NUMBER) {
if (n0->node_type == TYPE_DEF) {
if (n0->type->flag != DWARF_TYPE_FLAG) {
*error = E_BAD_INDEX;
}
else {
dp = n0->type->t_ptr;
if (dp->t_tag == DW_TAG_base_type) {
size = dp->t_byte_size;
kl_get_block(K, n0->address, size, &index, "index");
if (shft = (8 - size)) {
index = index >> (shft * 8);
}
n0->value = index;
n0->address = 0;
free_type(n0->type);
n0->type = 0;
n0->flags = 0;
}
else {
*error = E_BAD_INDEX;
}
}
}
else {
*error = E_BAD_INDEX;
}
}
n0->node_type = INDEX;
return(n0);
}
/*
* replace_cast()
*/
int
replace_cast(node_t *n, int *error, int flags)
{
int type;
k_uint_t value;
type_t *t;
if (!n || !n->right) {
*error = E_SYNTAX_ERROR;
return(-1);
}
if (n->flags & POINTER_FLAG) {
if (n->right->node_type == VADDR) {
if (n->right->flags & ADDRESS_FLAG) {
n->value = n->right->address;
}
else {
*error = E_SYNTAX_ERROR;
return(-1);
}
}
else if (n->right->node_type == VARIABLE) {
/* Replace a VARIABLE node with a TYPE_DEF node if possible.
* Return if there was an error.
*/
replace_variable(n->right, error, flags);
if (*error) {
return(-1);
}
/* Check and see if the attempt to determine this variable's
* type failed. We know that's the case when the NOTYPE_FLAG
* is set. If the ADDRESS_FLAG is also set, we can continue
* (using the address value in the cast). Otherwise, we have
* to return an error.
*/
if (n->right->flags & NOTYPE_FLAG) {
if (n->right->flags & ADDRESS_FLAG) {
n->value = n->right->address;
}
else {
*error = E_SYNTAX_ERROR;
return(-1);
}
}
else {
n->value = n->right->value;
}
}
else {
n->value = n->right->value;
}
n->node_type = TYPE_DEF;
n->operator = 0;
free_nodes(n->right);
n->right = (node_t *)NULL;
return(0);
}
if (!(t = eval_type(n))) {
*error = E_BAD_TYPE;
return(-1);
}
/* If we don't have a pointer and we're a dwarf type AND
* we don't point to a base type, return error.
*/
if (!(n->flags & POINTER_FLAG)) {
if (n->flags & DWARF_TYPE_FLAG) {
dw_type_info_t *atp = (dw_type_info_t*)n->type->t_ptr;
if (atp->t_actual_type->d_tag != DW_TAG_base_type) {
*error = E_BAD_TYPE;
return(-1);
}
}
else if (!(n->flags & BASE_TYPE_FLAG)) {
*error = E_BAD_TYPE;
return(-1);
}
}
if (t->flag & DWARF_TYPE_FLAG) {
if (n->right->node_type == TYPE_DEF) {
n->value = n->right->value;
}
else if (n->right->node_type == VARIABLE) {
/* XXX not working...
*/
n->value = n->right->address;
}
else if (n->right->node_type == NUMBER) {
n->value = n->right->value;
}
else {
*error = E_BAD_TYPE;
return(-1);
}
}
else if (t->flag & BASE_TYPE_FLAG) {
n->byte_size = ((base_t*)t->t_ptr)->byte_size;
value = n->right->value;
switch (((base_t*)t->t_ptr)->byte_size) {
case 1 :
if (((base_t*)(t->t_ptr))->encoding == 8) {
n->value = (unsigned char)value;
n->flags |= UNSIGNED_FLAG;
}
else {
n->value = (char)value;
}
break;
case 2 :
if (((base_t*)(t->t_ptr))->encoding == 7) {
n->value = (unsigned short)value;
n->flags |= UNSIGNED_FLAG;
}
else {
n->value = (short)value;
}
break;
case 4 :
if (((base_t*)(t->t_ptr))->encoding == 7) {
n->value = (unsigned int)value;
n->flags |= UNSIGNED_FLAG;
}
else {
n->value = (int)value;
}
break;
case 8 :
if (((base_t*)(t->t_ptr))->encoding == 7) {
n->value = (unsigned long long)value;
n->flags |= UNSIGNED_FLAG;
}
else {
n->value = (long long)value;
}
break;
default :
*error = E_BAD_TYPE;
return(-1);
}
}
n->node_type = TYPE_DEF;
n->operator = 0;
n->type = t;
free_block((k_ptr_t)n->right);
n->right = (node_t *)NULL;
return(0);
}
/*
* apply_unary()
*/
int
apply_unary(node_t *n, k_uint_t *value, int *error)
{
if (!n || !n->right) {
return(-1);
}
switch (n->operator) {
case UNARY_MINUS :
*value = (0 - n->right->value);
break;
case UNARY_PLUS :
*value = (n->right->value);
break;
case ONES_COMPLEMENT :
*value = ~(n->right->value);
break;
case LOGICAL_NEGATION :
if (n->right->value) {
*value = 0;
}
else {
*value = 1;
}
logical_flag++;
break;
default :
break;
}
return(0);
}
/*
* replace_unary() --
*
* Convert a unary operator node that contains a pointer to a value
* with a node containing the numerical result. Free the node that
* originally contained the value.
*/
int
replace_unary(node_t *n, int *error, int flags)
{
kaddr_t addr;
k_uint_t value;
if (!n->right) {
*error = E_SYNTAX_ERROR;
return(-1);
}
if (is_unary(n->right->operator)) {
replace_unary(n->right, error, flags);
}
if (n->operator == CAST) {
return(replace_cast(n, error, flags));
}
else if (n->operator == INDIRECTION) {
type_t *tp;
dw_die_t *d;
dw_type_info_t *dtp;
/* Replace a VARIABLE node with a TYPE_DEF node if possible.
* If it's not possible, return an error.
*/
if (n->right->node_type == VARIABLE) {
if (replace_variable(n->right, error, flags)) {
if (!(*error)) {
*error = E_NOTYPE;
}
return(-1);
}
}
/* Make sure we have a pointer
*/
if (!(n->right->flags & POINTER_FLAG)) {
*error = E_BAD_POINTER;
return(-1);
}
/* Get the pointer to the type_s struct
*/
if (!(tp = n->right->type)) {
*error = E_BAD_TYPE;
return(-1);
}
/* Make sure the right child is a TYPE_DEF.
*/
if (n->right->node_type != TYPE_DEF) {
*error = E_BAD_TYPE;
return(-1);
}
/* Make sure we have a pointer to a base or dwarf type
* structure.
*/
if (n->right->flags & BASE_TYPE_FLAG) {
n->flags = BASE_TYPE_FLAG;
}
else if (n->right->flags & DWARF_TYPE_FLAG) {
n->flags = DWARF_TYPE_FLAG;
}
else {
*error = E_BAD_TYPE;
return(-1);
}
n->node_type = TYPE_DEF;
n->operator = 0;
/* The first type_t struct MUST be a pointer to a type (BASE or
* DWARF). If it points to a DWARF type, strip off the
* pointer block and procede. If it points to a BASE type, we need
* to check if it points to type char. If it does, we have to set
* the STRING_FLAG before stripping off the pointer block.
*/
if (tp->flag == POINTER_FLAG) {
type_t *t;
if (!(t = eval_type(n->right))) {
*error = E_BAD_TYPE;
return(-1);
}
/* Zero out the type field in the right child so it wont
* accidently be freed when the right child is freed
* (upon success).
*/
n->right->type = (type_t*)NULL;
if (!strcmp(((base_t*)t->t_ptr)->name, "char")) {
n->flags |= STRING_FLAG;
}
n->type = tp->t_next;
/* Free the pointer block
*/
free_block((k_ptr_t)tp);
/* Get the pointer address
*/
addr = n->address = n->right->value;
n->flags |= (INDIRECTION_FLAG|ADDRESS_FLAG);
/* If this is a pointer to a pointer, just get the next
* pointer value and return.
*/
if (n->type->flag == POINTER_FLAG) {
kl_get_block(K, addr, K_NBPW(K), &n->value, "pointer value");
if (!PTRSZ64(K)) {
n->value >>= 32;
}
/* Set the appropriate node flag values
*/
n->flags |= POINTER_FLAG;
free_nodes(n->right);
n->left = n->right = (node_t *)NULL;
return(0);
}
n->value = addr;
/* Turn off the pointer flag
*/
n->flags &= (~POINTER_FLAG);
}
else {
*error = E_SYNTAX_ERROR;
return(-1);
}
/* Zero out the type field in the right child so it wont
* accidently be freed when the right child is freed
* (upon success).
*/
n->right->type = (type_t*)NULL;
free_nodes(n->right);
n->left = n->right = (node_t *)NULL;
return(0);
}
else if (n->operator == ADDRESS) {
type_t *t;
if (n->right->node_type == TYPE_DEF) {
t = n->right->type;
}
else if (n->right->node_type == VARIABLE) {
int ret;
ret = replace_variable(n->right, error, flags);
if (*error) {
return(-1);
}
/* If we can't find type information for this variable, we
* should convert the node to a VADDR node (with no type
* reference). That way pointer math will still work.
*/
if (ret == 1) {
n->node_type = VADDR;
n->flags = ADDRESS_FLAG;
n->operator = 0;
n->address = n->right->address;
n->name = n->right->name = 0;
n->type = n->right->type = 0;
n->value = 0;
free_nodes(n->right);
n->left = n->right = (node_t *)NULL;
return(0);
}
t = n->right->type;
}
else {
*error = E_BAD_TYPE;
return(-1);
}
n->type = (type_t*)ALLOC_BLOCK(sizeof(type_t), flags);
n->type->flag = POINTER_FLAG;
n->type->t_next = t;
n->node_type = TYPE_DEF;
n->operator = 0;
n->value = n->right->address;
n->flags = POINTER_FLAG;
if (!(t = eval_type(n))) {
*error = E_BAD_TYPE;
return(-1);
}
n->flags |= t->flag;
n->right->type = 0;
free_nodes(n->right);
n->left = n->right = (node_t *)NULL;
return(0);
}
else if (apply_unary(n, &value, error) == -1) {
return(-1);
}
free_nodes(n->right);
n->node_type = NUMBER;
n->operator = 0;
n->left = n->right = (node_t *)NULL;
bcopy(&value, &n->value, sizeof(k_uint_t));
return(0);
}
/*
* apply()
*/
int
apply(node_t *np, k_uint_t *value, int *error, int flags)
{
int do_signed = 0;
/* Each operator node must have two operands
*/
if (!np->right || !np->left) {
*error = E_SYNTAX_ERROR;
return(-1);
}
if (np->right->node_type == OPERATOR) {
replace(np->right, error, flags);
}
if (!(np->flags & UNSIGNED_FLAG)) {
do_signed++;
}
if ((np->left->node_type == TYPE_DEF) ||
(np->left->node_type == VARIABLE) ||
(np->left->node_type == VADDR)) {
int size;
k_uint_t lvalue;
/* If the left or right nodes are base types (either Dwarf or
* BAES_TYPE), convert them to proper numeric values. Otherwise,
* use the address/pointer value to perform pointer math.
*/
if (!type_to_number(np->left, error)) {
if (np->left->flags & ADDRESS_FLAG) {
size = K_NBPW(K);
lvalue = np->left->address;
}
else {
type_t *tp;
/* Since we only allow pointer math, anything other than
* a pointer causes failure.
*/
tp = (type_t*)np->left->type;
if (tp->flag != POINTER_FLAG) {
*error = E_SYNTAX_ERROR;
return(-1);
}
tp = tp->t_next;
switch (tp->flag) {
case POINTER_FLAG :
size = K_NBPW(K);
break;
case DWARF_TYPE_FLAG :
size = ((dw_type_info_t*)tp->t_ptr)->t_byte_size;
break;
default :
*error = E_SYNTAX_ERROR;
return(-1);
}
lvalue = np->left->value;
}
switch (np->operator) {
case ADD :
*value = lvalue + (np->right->value * size);
break;
case SUBTRACT :
*value = lvalue - (np->right->value * size);
break;
default :
*error = E_BAD_OPERATOR;
return(-1);
}
return(0);
}
}
if (do_signed) {
switch (np->operator) {
case ADD :
*value = (k_int_t)np->left->value + (k_int_t)np->right->value;
break;
case SUBTRACT :
*value = (k_int_t)np->left->value - (k_int_t)np->right->value;
break;
case MULTIPLY :
*value = (k_int_t)np->left->value * (k_int_t)np->right->value;
break;
case DIVIDE :
*value = (k_int_t)np->left->value / (k_int_t)np->right->value;
break;
case BITWISE_OR :
*value = (k_int_t)np->left->value | (k_int_t)np->right->value;
break;
case BITWISE_AND :
*value = (k_int_t)np->left->value & (k_int_t)np->right->value;
break;
case MODULUS :
*value = (k_int_t)np->left->value % (k_int_t)np->right->value;
break;
case RIGHT_SHIFT :
*value =
(k_int_t)np->left->value >> (k_int_t)np->right->value;
break;
case LEFT_SHIFT :
*value =
(k_int_t)np->left->value << (k_int_t)np->right->value;
break;
case LOGICAL_OR :
if ((k_int_t)np->left->value || (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case LOGICAL_AND :
if ((k_int_t)np->left->value && (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case EQUAL :
if ((k_int_t)np->left->value == (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case NOT_EQUAL :
if ((k_int_t)np->left->value != (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case LESS_THAN :
if ((k_int_t)np->left->value < (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case GREATER_THAN :
if ((k_int_t)np->left->value > (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case LESS_THAN_OR_EQUAL :
if ((k_int_t)np->left->value <= (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case GREATER_THAN_OR_EQUAL :
if ((k_int_t)np->left->value >= (k_int_t)np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
default :
break;
}
}
else {
switch (np->operator) {
case ADD :
*value = np->left->value + np->right->value;
break;
case SUBTRACT :
*value = np->left->value - np->right->value;
break;
case MULTIPLY :
*value = np->left->value * np->right->value;
break;
case DIVIDE :
*value = np->left->value / np->right->value;
break;
case BITWISE_OR :
*value = np->left->value | np->right->value;
break;
case BITWISE_AND :
*value = np->left->value & np->right->value;
break;
case MODULUS :
*value = np->left->value % np->right->value;
break;
case RIGHT_SHIFT :
*value = np->left->value >> np->right->value;
break;
case LEFT_SHIFT :
*value = np->left->value << np->right->value;
break;
case LOGICAL_OR :
if (np->left->value || np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case LOGICAL_AND :
if (np->left->value && np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case EQUAL :
if (np->left->value == np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case NOT_EQUAL :
if (np->left->value != np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case LESS_THAN :
if (np->left->value < np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case GREATER_THAN :
if (np->left->value > np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case LESS_THAN_OR_EQUAL :
if (np->left->value <= np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
case GREATER_THAN_OR_EQUAL :
if (np->left->value >= np->right->value) {
*value = 1;
}
else {
*value = 0;
}
logical_flag++;
break;
default :
break;
}
}
if ((np->flags & UNSIGNED_FLAG) && (np->byte_size < sizeof(k_uint_t))) {
k_uint_t mask;
mask = ((k_uint_t)1 << (np->byte_size * 8)) - 1;
*value &= mask;
}
return(0);
}
/*
* replace() --
*
* Replace the tree with a node containing the numerical result of
* the equation.
*/
node_t *
replace(node_t *np, int *error, int flags)
{
k_uint_t value;
node_t *q, *r;
if (!np) {
return((node_t *)NULL);
}
if (np->node_type == OPERATOR) {
if (!(q = np->left)) {
return((node_t *)NULL);
}
while (q) {
if (!replace(q, error, flags)) {
return((node_t *)NULL);
}
q = q->right;
}
/* If the left node is a VARIABLE, convert it to TYPE_DEF here.
*/
if (np->left->node_type == VARIABLE) {
/* Replace the VARIABLE node with a TYPE_DEF node. If
* there was an error, or if there wasn't any dwarf type
* info available, return an error.
*/
if (replace_variable(np->left, error, flags)) {
if (*error == 0) {
*error = E_NOTYPE;
}
return((node_t *)NULL);
}
}
if ((np->operator == RIGHT_ARROW) || (np->operator == DOT)) {
int i;
kaddr_t addr = 0;
type_t *tp, *mp;
/* The left node must point to a TYPE_DEF
*/
if (np->left->node_type != TYPE_DEF) {
if (np->left->flags & NOTYPE_FLAG) {
*error = E_NOTYPE;
}
else {
*error = E_BAD_TYPE;
}
return((node_t *)NULL);
}
/* Get the type information. Check to see if we have a
* pointer to a type. If we do, we need to strip off the
* pointer and get the type info.
*/
if (np->left->type->flag == POINTER_FLAG) {
tp = np->left->type->t_next;
free_block((k_ptr_t)np->left->type);
}
else {
tp = np->left->type;
}
/* We need to zero out the left child's type pointer
* to prevent the type structs from being prematurely
* freed (upon success). We have to remember, however, to
* the free the type information before we return.
*/
np->left->type = (type_t*)NULL;
/* tp should now point at a dwarf type_t struct. If it
* points to anything else, return failure.
*/
if (tp->flag != DWARF_TYPE_FLAG) {
*error = E_BAD_TYPE;
free_type(tp);
return((node_t *)NULL);
}
switch (tp->flag) {
case DWARF_TYPE_FLAG: {
dw_die_t *dp;
dw_type_info_t *dti;
/* Get the type die information entry. It should be
* one of the following:
*
* DW_TAG_structure_type
* DW_TAG_union_type
* DW_TAG_pointer_type
*
* If it's a DW_TAG_pointer_type, it must reference a
* DW_TAG_structure_type or DW_TAG_union_type. Otherwise
* return failure.
*/
dti = (dw_type_info_t *)tp->t_ptr;
/*
* XXX: Hack for the curnmlist musical
* chairs. Do a lookup on the name again.
*/
if(dti && dti->t_name)
dw_lkup(stp,dti->t_name,dti->t_tag);
dp = dti->t_actual_type;
/* If dp points to a DW_TAG_pointer_type, get the next
* die record (which should contain struct/union
* information).
*/
if (dp->d_tag == DW_TAG_pointer_type) {
dp = dp->d_next;
}
/* Make sure dp points to a DW_TAG_structure_type or
* DW_TAG_union_type. If it doesn't, return failure.
*/
if ((dp->d_tag != DW_TAG_structure_type) &&
(dp->d_tag != DW_TAG_union_type)) {
*error = E_BAD_TYPE;
free_type(tp);
return((node_t *)NULL);
}
/* Get type information for member. If member is a
* pointer to a type, get the pointer address and load
* it into value. Otherwise, load the struct/union
* address plus loc offset into address.
*/
if (!(mp = dw_lkup_member(stp,
tp->t_ptr, np->right->name, flags))) {
*error = E_BAD_MEMBER;
free_type(tp);
return((node_t *)NULL);
}
/* Now free the struct type information
*/
free_type(tp);
np->node_type = TYPE_DEF;
np->operator = 0;
addr = np->left->value +
((dw_type_info_t *)mp->t_ptr)->t_loc;
np->address = addr;
np->flags |= (DWARF_TYPE_FLAG|ADDRESS_FLAG);
if (!(np->type = member_to_type(mp->t_ptr,
DWARF_TYPE_FLAG, flags))) {
free_type(mp);
*error = E_BAD_MEMBER;
return((node_t *)NULL);
}
/* We have to free up the memory block that mp points
* to. We can't call free_type(), since it will free
* up the type information that np->type points to. So,
* we have to free the block manually...
*/
free_block((k_ptr_t)mp);
if (np->type->flag == POINTER_FLAG) {
np->flags |= POINTER_FLAG;
kl_get_block(K, addr, K_NBPW(K),
&np->value, "pointer value");
if (!PTRSZ64(K)) {
np->value >>= 32;
}
}
else {
np->value = addr;
}
break;
}
}
free_nodes(np->left);
free_nodes(np->right);
np->left = np->right = (node_t*)NULL;
return(np);
}
else {
if (np->left->byte_size && np->right->byte_size) {
if (np->left->byte_size > np->right->byte_size) {
/* Left byte_size is greater than right
*/
np->byte_size = np->left->byte_size;
np->type = np->left->type;
np->flags = np->left->flags;
free_type(np->right->type);
}
else if (np->left->byte_size < np->right->byte_size) {
/* Right byte_size is greater than left
*/
np->byte_size = np->right->byte_size;
np->type = np->right->type;
np->flags = np->right->flags;
free_type(np->left->type);
}
else {
/* Left and right byte_size is equal
*/
if (np->left->flags & UNSIGNED_FLAG) {
np->byte_size = np->left->byte_size;
np->type = np->left->type;
np->flags = np->left->flags;
free_type(np->right->type);
}
else if (np->right->flags & UNSIGNED_FLAG) {
np->byte_size = np->right->byte_size;
np->type = np->right->type;
np->flags = np->right->flags;
free_type(np->left->type);
}
else {
np->byte_size = np->left->byte_size;
np->type = np->left->type;
np->flags = np->left->flags;
free_type(np->right->type);
}
}
}
else if (np->left->byte_size) {
np->byte_size = np->left->byte_size;
np->type = np->left->type;
np->flags = np->left->flags;
free_type(np->right->type);
}
else if (np->right->byte_size) {
np->byte_size = np->right->byte_size;
np->type = np->right->type;
np->flags = np->right->flags;
}
else {
/* XXX - No byte sizes
*/
}
if (apply(np, &value, error, flags)) {
return((node_t *)NULL);
}
}
np->right->type = np->left->type = (type_t*)NULL;
/* Flesh out the rest of the node struct.
*/
np->node_type = NUMBER;
np->flags &= ~(DWARF_TYPE_FLAG|BASE_TYPE_FLAG);
np->operator = 0;
np->value = value;
free_block((k_ptr_t)np->left);
free_block((k_ptr_t)np->right);
np->left = np->right = (node_t*)NULL;
}
return(np);
}
/*
* replace_variable()
*/
int
replace_variable(node_t *n, int *error, int flags)
{
dw_type_t *dtp;
type_t *t;
dw_type_info_t *dti;
/* Check to see if this is a dwarf kernel
*/
if (!stp) {
/* Lookup the variable type by name
*/
if (!(dtp = dw_lkup(stp, n->name, DW_TAG_variable))) {
*error = E_BAD_VARIABLE;
return(-1);
}
/* Allocate some space for the dw_type_info_s struct and then
* get the struct referenced by d_off.
*/
dti = (dw_type_info_t*)ALLOC_BLOCK(sizeof(*dti), flags);
if (!dw_type_info(dtp->dt_off, dti, flags)) {
dw_free_type_info(dti);
*error = E_BAD_TYPE;
return(-1);
}
if (!(n->type = dw_var_to_type(dti, flags))) {
/* If we can't find type information for this variable, we
* set a flag (NOTYPE_FLAG) and return one (1). We don't,
* set *error, however. We may be able to get by with just
* the address of the variable.
*/
n->flags |= NOTYPE_FLAG;
dw_free_type_info(dti);
return(1);
}
n->node_type = TYPE_DEF;
n->operator = 0;
if (n->type->flag == POINTER_FLAG) {
n->flags = POINTER_FLAG;
kl_get_block(K, n->address, 8, &n->value, "pointer value (DWARF)");
}
else {
n->value = n->address;
}
if (!(t = eval_type(n))) {
*error = E_BAD_TYPE;
return(-1);
}
n->flags |= t->flag;
}
return(0);
}
/*
* array_to_element()
*/
void
array_to_element(node_t *n0, node_t *n1, int *error)
{
int size;
type_t *t;
base_t *btp;
dw_type_info_t *dtp;
dw_die_t *dp;
/* Take the array index and determine the proper pointer
* value for the type pointer or array data type.
*/
t = n0->type;
if (n0->node_type == TYPE_DEF) {
if (t->flag == POINTER_FLAG) {
if (t->t_next->flag == DWARF_TYPE_FLAG) {
dtp = (dw_type_info_t*)t->t_next->t_ptr;
t = t->t_next;
free_block((k_ptr_t)n0->type);
n0->type = t;
size = dtp->t_byte_size;
}
else if (t->t_next->flag == BASE_TYPE_FLAG) {
btp = (base_t*)t->t_next->t_ptr;
t = t->t_next;
free_block((k_ptr_t)n0->type);
n0->type = t;
size = btp->byte_size;
}
else {
*error = E_BAD_INDEX;
}
}
else if (t->flag == DWARF_TYPE_FLAG) {
dtp = (dw_type_info_t*)t->t_ptr;
if (dtp->t_tag == DW_TAG_array_type) {
dtp->t_tag = dtp->t_type->d_next->d_tag;
dtp->t_off = dtp->t_type->d_next->d_off;
dtp->t_name = dtp->t_type->d_next->d_name;
dp = dtp->t_type;
while (dp->d_next) {
dp = dp->d_next;
}
size = dp->d_byte_size;
dtp->t_type = dtp->t_type->d_next;
dtp->t_actual_type = dp;
dtp->t_byte_size = size;
}
else {
*error = E_BAD_INDEX;
}
}
else {
*error = E_BAD_INDEX;
}
if (!(*error)) {
n0->address = n0->value + (n1->value * size);
n0->value = n0->address;
n0->flags &= (~POINTER_FLAG);
n0->flags |= (ADDRESS_FLAG|INDIRECTION_FLAG);
}
}
else {
*error = E_BAD_INDEX;
}
}
/*
* type_to_number()
*
* Convert a base type (Dwarf or BASE_TYPE) to a numeric value. Return
* 1 on successful conversion, 0 if nothing was done.
*/
int
type_to_number(node_t *np, int *error)
{
int byte_size, bit_offset, bit_size, encoding, j, k;
k_uint_t value, value1;
dw_type_info_t *dti;
/* Make sure we point to a type
*/
if (!np->type) {
return(0);
}
if (np->type->flag == POINTER_FLAG) {
return(0);
}
dti = (dw_type_info_t*)np->type->t_ptr;
if (np->flags & BASE_TYPE_FLAG) {
/* Nothing needs to be done. It's already a base value
* (we still need to return a 1).
*/
return(1);
}
else if (np->flags & DWARF_TYPE_FLAG) {
if (dti->t_tag == DW_TAG_base_type) {
byte_size = dti->t_byte_size;
bit_offset = dti->t_bit_offset;
if (!(bit_size = dti->t_bit_size)) {
bit_size = (byte_size * 8);
}
encoding = dti->t_encoding;
}
else {
return(0);
}
}
kl_get_block(K, np->address, byte_size, &value1, "value");
value = kl_get_bit_value(&value1, byte_size, bit_size, bit_offset);
switch (byte_size) {
case 1 :
if (encoding == 8) {
np->value = (unsigned char)value;
np->flags |= UNSIGNED_FLAG;
}
else {
np->value = (char)value;
}
break;
case 2 :
if (encoding == 7) {
np->value = (unsigned short)value;
np->flags |= UNSIGNED_FLAG;
}
else {
np->value = (short)value;
}
break;
case 4 :
if (encoding == 7) {
np->value = (unsigned int)value;
np->flags |= UNSIGNED_FLAG;
}
else {
np->value = (int)value;
}
break;
case 8 :
if (encoding == 7) {
np->value = (unsigned long long)value;
np->flags |= UNSIGNED_FLAG;
}
else {
np->value = (long long)value;
}
break;
default :
*error = E_BAD_TYPE;
return(0);
}
np->node_type = NUMBER;
return(1);
}
/*
* eval_type()
*/
type_t *
eval_type(node_t *n)
{
type_t *t;
t = n->type;
while (t->flag == POINTER_FLAG) {
t = t->t_next;
/* If for some reason, there is no type pointer (this shouldn't
* happen but...), we have to make sure that we don't try to
* reference a NULL pointer and get a SEGV. Return an error if
* 't' is NULL.
*/
if (!t) {
return((type_t*)NULL);
}
}
if ((t->flag == BASE_TYPE_FLAG) || (t->flag == DWARF_TYPE_FLAG)) {
return (t);
}
return((type_t*)NULL);
}
/*
* eval()
*/
node_t *
eval(char **exp, int flags, int *error)
{
int i;
token_t *tok, *t;
node_t *n;
char *e, *s;
*error = 0;
logical_flag = 0;
/* Make sure we actually have a command line to evaluate
*/
if (!(*exp)) {
return ((node_t*)NULL);
}
/* Expand any variables that are in the expression string. Free
* the original string and change s so that it points to the new
* expression string (so that the new string will be freed up when
* we are done).
*/
if (e = expand_variables(*exp, 0)) {
free_block((k_ptr_t)*exp);
*exp = e;
s = *exp;
}
else {
*error = E_BAD_VARIABLE;
tok = (token_t *)alloc_block(sizeof(token_t), B_TEMP);
tok->ptr = *exp;
}
if (!(*error)) {
tok = get_token_list(s, error);
}
if (*error) {
n = (node_t *)ALLOC_BLOCK(sizeof(node_t), flags);
n->tok_ptr = tok->ptr;
}
else {
t = tok;
n = do_eval(&t, flags, error);
if (!*error) {
if (!(n = replace(n, error, flags))) {
n = (node_t *)ALLOC_BLOCK(sizeof (node_t), flags);
n->tok_ptr = s + strlen(s) -1;
*error = E_SYNTAX_ERROR;
}
else {
/* Check to see if the the result should be interpreted
* as 'true' or 'false'
*/
if (logical_flag && ((n->value == 0) || (n->value == 1))) {
n->flags |= BOOLIAN_FLAG;
}
}
}
}
if (!(*error) && (n->node_type == VARIABLE)) {
if (n->flags & NOTYPE_FLAG) {
if (!(n->flags & ADDRESS_FLAG)) {
*error = E_NOTYPE;
}
}
else {
if (replace_variable(n, error, flags) == 1) {
*error = E_NOTYPE;
}
}
}
free_tokens(tok);
return(n);
}
/*
* print_number()
*
* If we get here it means the type is BASE_TYPE. If there isn't
* a type_s struct linked in, then make type the default (int).
* Then, depending on the contents of flags, display the value
* in HEX, OCTAL, or DECIMAL form. There is a special case for
* type char (display as a character).
*/
void
print_number(node_t *np, FILE *ofp, int flags)
{
base_t *bt;
k_uint_t value;
/* Check to make sure we have a base_type pointer. This is kind
* of a hack since we can get to this routine from a number of
* different ways and it's not always clear that a type will have
* been designated along the way. Check the upper word and see if
* any bits are set. If they are, treat the value as a "long long"
* type (64-bit) value. Otherwise, treat it as an "int" value.
*/
if (!np->type) {
if (np->value & 0xffffffff00000000) {
np->type = get_type("long long", 0);
}
else {
np->type = get_type("int", 0);
}
np->byte_size = ((base_t *)np->type->t_ptr)->byte_size;
}
if (flags & C_HEX) {
if (np->byte_size && (np->byte_size != sizeof(k_uint_t))) {
np->value = np->value &
(((k_uint_t)1<<(k_uint_t)(np->byte_size*8))-1);
}
fprintf(ofp, "0x%llx", np->value);
}
else if (flags & C_OCTAL) {
fprintf(ofp, "0%llo", np->value);
}
else {
if (np->flags & UNSIGNED_FLAG) {
fprintf(ofp, "%llu", np->value);
}
else {
bt = (base_t *)np->type->t_ptr;
value = np->value << ((8 - np->byte_size) * 8);
print_base(&value, bt->byte_size, bt->encoding, flags, ofp);
}
}
}
/*
* print_eval_results()
*/
int
print_eval_results(node_t *np, FILE *ofp, int flags)
{
int size;
kaddr_t addr;
dw_type_info_t *t;
dw_die_t *d;
/* Print the results
*/
switch (np->node_type) {
case NUMBER:
print_number(np, ofp, flags);
break;
case TYPE_DEF: {
type_t *tp;
k_ptr_t ptr;
/* If this is a pointer just print out the address.
*/
if (np->flags & POINTER_FLAG) {
fprintf(ofp, "0x%llx", np->value);
break;
}
if (np->flags & DWARF_TYPE_FLAG) {
/* Get the type information
*/
t = (dw_type_info_t *)np->type->t_ptr;
/*
* XXX: Hack for the curnmlist musical chairs.
* Do a lookup on that name again.
*/
if(t && t->t_name)
dw_lkup(stp,t->t_name,t->t_tag);
if (t->t_type->d_tag == DW_TAG_typedef) {
d = t->t_actual_type;
}
else {
d = t->t_type;
}
size = t->t_byte_size;
ptr = alloc_block(size, B_TEMP);
if ((d->d_tag == DW_TAG_base_type) &&
!(np->flags & ADDRESS_FLAG)) {
switch (size) {
case 1:
*(unsigned char *)ptr = np->value;
break;
case 2:
*(unsigned short *)ptr = np->value;
break;
case 4:
*(unsigned int *)ptr = np->value;
break;
case 8:
*(unsigned long long *)ptr = np->value;
break;
}
dw_print_type(ptr, t, 0, flags|SUPPRESS_NAME, ofp);
free_block(ptr);
return(1);;
}
addr = np->value;
kl_get_block(K, addr, size, ptr, "type");
if (KL_ERROR) {
kl_print_error(K);
free_block(ptr);
return(1);
}
/* Print out the actual type
*/
switch (d->d_tag) {
case DW_TAG_structure_type:
case DW_TAG_union_type:
dw_print_type(ptr, t, 0, flags, ofp);
break;
default:
dw_print_type(ptr, t, 0,
(flags|SUPPRESS_NAME|SUPPRESS_NL), ofp);
break;
}
free_block(ptr);
}
else if (np->flags & BASE_TYPE_FLAG) {
base_t *b;
if (!(flags & ADDRESS_FLAG)) {
print_number(np, ofp, flags);
}
else {
/* Get the type information
*/
b = (base_t *)np->type->t_ptr;
size = b->byte_size;
ptr = alloc_block(size, B_TEMP);
addr = np->value;
kl_get_block(K, addr, size, ptr, "type");
if (KL_ERROR) {
free_block(ptr);
return(1);
}
print_base(ptr, size, b->encoding, flags, ofp);
}
}
break;
}
case VADDR:
case VARIABLE:
/* If we get here, there was no type info available.
* The ADDRESS_FLAG should be set (otherwise we would have
* returned an error). So, print out the address.
*/
fprintf(ofp, "0x%llx", np->address);
break;
default:
if (np->node_type == TEXT) {
print_string(np->name, ofp);
if (KL_ERROR) {
kl_print_error(K);
return(1);
}
}
else if (np->node_type == CHARACTER) {
fprintf(ofp, "\'%c\'", np->name[0]);
}
break;
}
return(0);
}
/*
* print_eval_error()
*/
void
print_eval_error(char *cmdname, char *s, char *bad_ptr, int error, int flags)
{
int i, cmd_len;
if ((cmdname[0] == 'p') || !strcmp(cmdname, "eval")) {
fprintf(KL_ERRORFP, "print");
if ((cmdname[1] == 'x') || (cmdname[1] == 'o')) {
fprintf(KL_ERRORFP, "%c %s\n", cmdname[1], s);
cmd_len = 6;
}
else {
fprintf(KL_ERRORFP, " %s\n", s);
cmd_len = 5;
}
}
else {
if (flags & CMD_STRING) {
fprintf(KL_ERRORFP, "%s%s\n", cmdname, s);
}
else {
fprintf(KL_ERRORFP, "%s %s\n", cmdname, s);
}
cmd_len = strlen(cmdname);
}
if (!bad_ptr) {
for (i = 0; i < (strlen(s) + cmd_len); i++) {
fprintf(KL_ERRORFP, " ");
}
}
else {
for (i = 0; i < (bad_ptr - s + 1 + cmd_len); i++) {
fprintf(KL_ERRORFP, " ");
}
}
fprintf(KL_ERRORFP, "^ ");
switch (error) {
case E_OPEN_PAREN :
fprintf(KL_ERRORFP, "Too many open parenthesis\n");
break;
case E_CLOSE_PAREN :
fprintf(KL_ERRORFP, "Too many close parenthesis\n");
break;
case E_BAD_MEMBER :
fprintf(KL_ERRORFP, "No such member\n");
break;
case E_BAD_OPERATOR :
fprintf(KL_ERRORFP, "Bad operator\n");
break;
case E_BAD_TYPE :
fprintf(KL_ERRORFP, "Bad type\n");
break;
case E_NOTYPE :
fprintf(KL_ERRORFP, "Could not find type information\n");
break;
case E_BAD_POINTER :
fprintf(KL_ERRORFP, "Bad pointer\n");
break;
case E_BAD_VARIABLE :
fprintf(KL_ERRORFP, "Not a variable\n");
break;
case E_BAD_INDEX :
fprintf(KL_ERRORFP, "Bad array index\n");
break;
case E_BAD_STRING :
fprintf(KL_ERRORFP, "Non-termining string\n");
break;
case E_END_EXPECTED :
fprintf(KL_ERRORFP, "Expected end of print statement\n");
break;
case E_BAD_EVAR :
fprintf(KL_ERRORFP, "Bad eval variable\n");
break;
default :
fprintf(KL_ERRORFP, "Syntax error\n");
break;
}
}
View Git Blame Copy Permalink