From: KE <eiselekd@xxxxxx>
---
Makefile | 6 +-
allocate.c | 8 ++-
allocate.h | 10 ++-
attr.c | 67 ++++++++++++
attr.h | 18 +++
depend.c | 329 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
depend.h | 91 ++++++++++++++++
expand.c | 1 +
expression.c | 60 +++++-----
expression.h | 8 ++
inline.c | 10 ++
lib.c | 8 ++
parse.c | 73 +++++++++----
parse.h | 1 +
pre-process.c | 104 ++++++++++++------
shrink.c | 102 ++++++++++++++++++
sparse.c | 3 +
symbol.h | 9 ++
token.h | 10 ++
19 files changed, 826 insertions(+), 92 deletions(-)
create mode 100644 attr.c
create mode 100644 attr.h
create mode 100644 depend.c
create mode 100644 depend.h
create mode 100644 shrink.c
diff --git a/Makefile b/Makefile
index 79cadb0..833ec70 100644
--- a/Makefile
+++ b/Makefile
@@ -39,7 +39,8 @@ INCLUDEDIR=$(PREFIX)/include
PKGCONFIGDIR=$(LIBDIR)/pkgconfig
PROGRAMS=test-lexing test-parsing obfuscate compile graph sparse \
- test-linearize example test-unssa test-dissect ctags
+ test-linearize example test-unssa test-dissect ctags \
+ shrink
INST_PROGRAMS=sparse cgcc
INST_MAN1=sparse.1 cgcc.1
@@ -70,7 +71,8 @@ LIB_H= token.h parse.h lib.h symbol.h scope.h expression.h target.h \
LIB_OBJS= target.o parse.o tokenize.o pre-process.o symbol.o lib.o scope.o \
expression.o show-parse.o evaluate.o expand.o inline.o linearize.o \
sort.o allocate.o compat-$(OS).o ptrlist.o \
- flow.o cse.o simplify.o memops.o liveness.o storage.o unssa.o dissect.o
+ flow.o cse.o simplify.o memops.o liveness.o storage.o unssa.o dissect.o \
+ depend.o attr.o
LIB_FILE= libsparse.a
SLIB_FILE= libsparse.so
diff --git a/allocate.c b/allocate.c
index 5cc52a9..30378d3 100644
--- a/allocate.c
+++ b/allocate.c
@@ -26,6 +26,7 @@
#include "scope.h"
#include "expression.h"
#include "linearize.h"
+#include "depend.h"
void protect_allocations(struct allocator_struct *desc)
{
@@ -125,5 +126,10 @@ ALLOCATOR(entrypoint, "entrypoint");
ALLOCATOR(instruction, "instruction");
ALLOCATOR(multijmp, "multijmp");
ALLOCATOR(pseudo, "pseudo");
+ALLOCATOR(macro_dep, "macro dependency");
+ALLOCATOR(macro_expansion, "macro expansion");
-
+void token_allocator_nofree(void)
+{
+ token_allocator.nofree = 1;
+}
diff --git a/allocate.h b/allocate.h
index 9f1dc8c..de85320 100644
--- a/allocate.h
+++ b/allocate.h
@@ -12,6 +12,7 @@ struct allocator_struct {
struct allocation_blob *blobs;
unsigned int alignment;
unsigned int chunking;
+ unsigned int nofree;
void *freelist;
/* statistics */
unsigned int allocations, total_bytes, useful_bytes;
@@ -22,6 +23,7 @@ extern void drop_all_allocations(struct allocator_struct *desc);
extern void *allocate(struct allocator_struct *desc, unsigned int size);
extern void free_one_entry(struct allocator_struct *desc, void *entry);
extern void show_allocations(struct allocator_struct *);
+extern void token_allocator_nofree(void);
#define __DECLARE_ALLOCATOR(type, x) \
extern type *__alloc_##x(int); \
@@ -42,7 +44,8 @@ extern void show_allocations(struct allocator_struct *);
} \
void __free_##x(type *entry) \
{ \
- free_one_entry(&x##_allocator, entry); \
+ if (!x##_allocator.nofree) \
+ free_one_entry(&x##_allocator, entry); \
} \
void show_##x##_alloc(void) \
{ \
@@ -50,7 +53,8 @@ extern void show_allocations(struct allocator_struct *);
} \
void clear_##x##_alloc(void) \
{ \
- drop_all_allocations(&x##_allocator); \
+ if (!x##_allocator.nofree) \
+ drop_all_allocations(&x##_allocator); \
} \
void protect_##x##_alloc(void) \
{ \
@@ -77,5 +81,7 @@ DECLARE_ALLOCATOR(instruction);
DECLARE_ALLOCATOR(multijmp);
DECLARE_ALLOCATOR(phi);
DECLARE_ALLOCATOR(pseudo);
+DECLARE_ALLOCATOR(macro_dep);
+DECLARE_ALLOCATOR(macro_expansion);
#endif
diff --git a/attr.c b/attr.c
new file mode 100644
index 0000000..54c4c21
--- /dev/null
+++ b/attr.c
@@ -0,0 +1,67 @@
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "allocate.h"
+#include "compat.h"
+#include "attr.h"
+
+struct hash_v {
+ struct hash_v *n;
+ void *key;
+ enum attr_tags tag;
+ void *v;
+};
+
+__DECLARE_ALLOCATOR(struct hash_v, hash_v);
+__ALLOCATOR(struct hash_v, "hash value", hash_v);
+
+#define HASH_LEN (1024*4)
+struct hash {
+ struct hash_v *f;
+} h[HASH_LEN];
+
+void init_attr(void) {
+ memset(h, 0, sizeof(h));
+}
+
+static int hash_func(void *key, enum attr_tags tag) {
+ unsigned int k = ((unsigned int)key) >> 4;
+ return ((k) ^ (k >> 16) ^ (k >> 24) ^ tag) & (HASH_LEN-1);
+}
+
+void **lookup_attr(void *key, enum attr_tags tag, int create) {
+ int i = hash_func(key, tag);
+ struct hash *hp = &h[i];
+ struct hash_v *p;
+ struct hash_v **c = &hp->f;
+ while((p = *c)) {
+ if ((p ->tag == tag)
+ && (p ->key == key)) {
+ return &p->v;
+ }
+ c = &p->n;
+ }
+ if (create) {
+ p = __alloc_hash_v(0);
+ p->key = key;
+ p->tag = tag;
+ p->v = 0;
+ *c = p;
+ return &p->v;
+ }
+ return 0;
+}
+
+void *set_attr(void *key, enum attr_tags tag, void *data) {
+ void **p = lookup_attr(key, tag, 1);
+ assert(p);
+ *p = data;
+ return data;
+}
+
+void *get_attr(void *key, enum attr_tags tag) {
+ void **p = lookup_attr(key, tag, 0);
+ if (!p)
+ return 0;
+ return *p;
+}
diff --git a/attr.h b/attr.h
new file mode 100644
index 0000000..aa5750c
--- /dev/null
+++ b/attr.h
@@ -0,0 +1,18 @@
+#ifndef _SPARSE_ATTR_H
+#define _SPARSE_ATTR_H
+
+enum attr_tags {
+ ATTR_TAG_MACRO_DEP = 1,
+ ATTR_TAG_FLAGS = 2,
+ ATTR_TAG_MACRO_EXP = 3
+};
+
+#define SET_MACRO_DEP(a,v) set_attr(a, ATTR_TAG_MACRO_DEP, v)
+#define GET_MACRO_DEP(a) ((struct macro_dep *)get_attr(a, ATTR_TAG_MACRO_DEP))
+#define NEW_MACRO_DEP() ((struct macro_dep *)attr_data(ATTR_TAG_MACRO_DEP))
+
+extern void *set_attr(void *key, enum attr_tags tag, void *data);
+extern void *get_attr(void *key, enum attr_tags tag);
+extern void *attr_data(enum attr_tags tag);
+
+#endif
diff --git a/depend.c b/depend.c
new file mode 100644
index 0000000..f36134a
--- /dev/null
+++ b/depend.c
@@ -0,0 +1,329 @@
+/*
+ * Build macros dependency tree
+ * Copyright (C) 2012 Konrad Eisele <konrad@xxxxxxxxxxx,eiselekd@xxxxxxxxx>
+ * BSD-License
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the <organization>. The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "token.h"
+#include "allocate.h"
+#include "compat.h"
+#include "depend.h"
+#include "attr.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+
+__DECLARE_ALLOCATOR(struct dep_flags, dep_flags);
+__ALLOCATOR(struct dep_flags, "dependency flags", dep_flags);
+__DECLARE_ALLOCATOR(struct tok_macro_dep, tok_macro_dep);
+__ALLOCATOR(struct tok_macro_dep, "token macro expansion relation", tok_macro_dep);
+__DECLARE_ALLOCATOR(struct macro_dep_el, macro_dep_el);
+__ALLOCATOR(struct macro_dep_el, "macro dependency element", macro_dep_el);
+
+static void * push_dep(struct depend_if *dif, struct token *tok);
+static void * else_dep(struct depend_if *dif, struct token *tok);
+static void * pop_dep(struct depend_if *dif, struct token *tok);
+static void * push_sym(struct depend_if *dif, struct symbol *sym);
+static void * on_dep(struct depend_if *dif, void *p);
+static void * off_dep(struct depend_if *dif, void *p);
+static void * tag_dep(struct depend_if *dif,struct token *tok);
+static void * set_tok(struct depend_if *dif,void *p, struct token *tok);
+static void * end_tok(struct depend_if *dif,void *p, struct token *tok);
+static void * inherit_tok(struct depend_if *dif,void *a, void *b);
+static void * set_symlist(struct depend_if *dif,void *a, struct symbol_list * l);
+static void * macro_exp(struct depend_if *dif,struct token *tok, struct tok_macro_dep *m);
+
+static void depend_symbol_list(struct symbol_list *ptrlist);
+static void depend_expression(struct expression *expr);
+static void depend_statement(struct statement *stmt);
+
+struct depend_if d = {
+ .push_dep = push_dep,
+ .else_dep = else_dep,
+ .pop_dep = pop_dep,
+ .push_sym = push_sym,
+ .on = on_dep,
+ .off = off_dep,
+ .tag_dep = tag_dep,
+ .set_tok = set_tok,
+ .end_tok = end_tok,
+ .inherit_tok = inherit_tok,
+ .set_symlist = set_symlist,
+ .macro_exp = macro_exp,
+ .dep = &d.root_dep,
+};
+
+struct macro_dep *alloc_macro_dep(struct token *tok) {
+ struct macro_dep *e;
+ e = __alloc_macro_dep(0);
+ e->ppline = tok;
+ return e;
+}
+
+static int is_root(struct depend_if *dif) {
+ return dif->dep == &dif->root_dep ? 1 : 0;
+}
+
+static void *on_dep(struct depend_if *dif, void *p) {
+ dif->dep_use = dif->dep;
+ return 0;
+}
+
+static void *off_dep(struct depend_if *dif, void *p) {
+ dif->dep_use = 0;
+ return 0;
+}
+
+static void *push_dep(struct depend_if *dif, struct token *tok) {
+ struct macro_dep *e = alloc_macro_dep(tok);
+ e->up = dif->dep;
+ dif->dep = e;
+ on_dep(dif, 0);
+ return e;
+}
+
+/* push a macro_dep not on top of stack but one below, to reference <tok> */
+static void *else_dep(struct depend_if *dif, struct token *tok) {
+ struct macro_dep *e;
+ e = alloc_macro_dep(tok);
+ e->up = dif->dep->up;
+ dif->dep->up = e;
+ return e;
+}
+
+static void *pop_dep(struct depend_if *dif, struct token *tok) {
+ struct macro_dep *r = 0;
+ if (!is_root(dif)) {
+ dif->dep = dif->dep->up;
+ }
+ return r;
+}
+
+static void *push_sym(struct depend_if *dif, struct symbol *sym) {
+
+ struct macro_dep_el *e = 0;
+ if (dif->dep_use) {
+ e = __alloc_macro_dep_el(0);
+ e->sym = sym;
+ e->n = dif->dep_use->f;
+ dif->dep_use->f = e;
+ }
+ return e;
+}
+
+static void * tag_dep(struct depend_if *dif,struct token *tok)
+{
+ struct macro_dep *a = 0, *c, *d = GET_MACRO_DEP(tok);
+ if (!eof_token(tok) && (a = dif->dep) && !is_root(dif)) {
+ if (d) {
+ c = alloc_macro_dep(0);
+ c->up = a;
+ c->same = d;
+ a = c;
+ }
+ SET_MACRO_DEP(tok, a);
+ }
+ return a;
+}
+
+void init_dep(void) {
+ dif = &d;
+ token_allocator_nofree();
+}
+
+struct dep_flags *depend_flags(void *p, int create) {
+ struct dep_flags *f;
+ if (!(f = (struct dep_flags *)get_attr(p, ATTR_TAG_FLAGS))) {
+ if (create) {
+ f = __alloc_dep_flags(0);
+ memset(f, 0, sizeof(struct dep_flags));
+ set_attr(p, ATTR_TAG_FLAGS, f);
+ }
+ }
+ return f;
+}
+
+struct dep_flags *depend_visited(void *p) {
+ struct dep_flags *f = 0; int r = 1;
+ if (p) {
+ f = depend_flags(p,1);
+ r = f->visited;
+ f->visited = 1;
+ }
+ return r ? 0 : f;
+}
+
+static void * set_tok(struct depend_if *dif,void *p, struct token *tok)
+{
+ struct dep_flags *f = depend_flags(p,1);
+ f->tok = tok;
+ return f;
+}
+
+static void * end_tok(struct depend_if *dif,void *p, struct token *tok)
+{
+ struct dep_flags *f = depend_flags(p,1);
+ f->end = tok;
+ return f;
+}
+
+static void * inherit_tok(struct depend_if *dif,void *a, void *b)
+{
+ struct dep_flags *af = depend_flags(a,1);
+ struct dep_flags *bf = depend_flags(b,1);
+ af->tok = bf->tok;
+ af->end = bf->end;
+ return af;
+}
+
+static void * set_symlist(struct depend_if *dif,void *a, struct symbol_list * l)
+{
+ struct dep_flags *f = depend_flags(a,1);
+ f->symlist = l;
+ return f;
+}
+
+static void * macro_exp(struct depend_if *dif, struct token *tok, struct tok_macro_dep *m) {
+ struct tok_macro_dep *p = 0;
+ if (tok && m) {
+ p = __alloc_tok_macro_dep(0);
+ *p = *m;
+ set_attr(tok, ATTR_TAG_MACRO_EXP, p);
+ return p;
+ }
+ return p;
+}
+
+void depend_statement_list(struct ptr_list *ptrlist)
+{
+ void *ptr;
+ if (!ptrlist)
+ return;
+ FOR_EACH_PTR(ptrlist, ptr) {
+ depend_statement(ptr);
+ } END_FOR_EACH_PTR(ptr);
+}
+
+void depend_symbol_list(struct symbol_list *ptrlist)
+{
+ void *ptr;
+ if (!ptrlist)
+ return;
+ FOR_EACH_PTR(((struct ptr_list *)ptrlist), ptr) {
+ depend_symbol(ptr);
+ } END_FOR_EACH_PTR(ptr);
+}
+
+void depend_statement(struct statement *stmt)
+{
+ struct dep_flags *f;
+ if (!(f = depend_visited(stmt)))
+ return;
+
+ switch (stmt->type) {
+ case STMT_COMPOUND:
+ depend_statement_list((struct ptr_list *)stmt->stmts);
+ break;
+ case STMT_EXPRESSION:
+ depend_expression(stmt->expression);
+ break;
+ case STMT_IF:
+ depend_expression(stmt->if_conditional);
+ depend_statement(stmt->if_true);
+ depend_statement(stmt->if_false);
+ break;
+ case STMT_ITERATOR:
+ depend_symbol(stmt->iterator_break);
+ depend_symbol(stmt->iterator_continue);
+ depend_statement(stmt->iterator_pre_statement);
+ depend_statement(stmt->iterator_statement);
+ depend_statement(stmt->iterator_post_statement);
+ break;
+ case STMT_SWITCH:
+ depend_expression(stmt->switch_expression);
+ depend_statement(stmt->switch_statement);
+ depend_symbol(stmt->switch_break);
+ depend_symbol(stmt->switch_case);
+ break;
+ case STMT_CASE:
+ depend_expression(stmt->case_expression);
+ depend_expression(stmt->case_to);
+ depend_statement(stmt->case_statement);
+ depend_symbol(stmt->case_label);
+ break;
+ case STMT_RETURN:
+ depend_expression(stmt->ret_value);
+ depend_symbol(stmt->ret_target);
+ break;
+ default:
+ break;
+ }
+}
+
+void depend_expression(struct expression *expr)
+{
+ struct dep_flags *f;
+ if (!(f = depend_visited(expr)))
+ return;
+ switch (expr->type) {
+ case EXPR_STATEMENT:
+ depend_statement(expr->statement);
+ break;
+ case EXPR_BINOP:
+ case EXPR_COMMA:
+ case EXPR_COMPARE:
+ case EXPR_LOGICAL:
+ case EXPR_ASSIGNMENT:
+ depend_expression(expr->left);
+ depend_expression(expr->right);
+ break;
+ case EXPR_CAST:
+ case EXPR_FORCE_CAST:
+ case EXPR_IMPLIED_CAST:
+ depend_symbol(expr->cast_type);
+ depend_expression(expr->cast_expression);
+ break;
+ case EXPR_PREOP:
+ depend_expression(expr->unop);
+ break;
+ default:
+ break;
+ }
+}
+
+void depend_symbol(struct symbol *sym)
+{
+ struct dep_flags *f;
+ if (!(f = depend_visited(sym)))
+ return;
+
+ depend_symbol(sym->ctype.base_type);
+ depend_symbol_list(f->symlist);
+
+ switch (sym->namespace) {
+ case NS_PREPROCESSOR:
+ break;
+ case NS_MACRO:
+ /*depend_macro_dep(sym->dep);*/
+ default:
+ /*use_line_fromto(sym->token, sym->endtoken);*/
+ depend_symbol_list(sym->arguments);
+ depend_symbol_list(sym->symbol_list);
+ depend_statement(sym->stmt);
+ break;
+ }
+}
diff --git a/depend.h b/depend.h
new file mode 100644
index 0000000..34a2159
--- /dev/null
+++ b/depend.h
@@ -0,0 +1,91 @@
+/*
+ * Build macros dependency tree
+ * Copyright (C) 2012 Konrad Eisele <konrad@xxxxxxxxxxx>
+ * BSD-License
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the <organization>. The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ */
+
+#ifndef _SPARSE_DEPEND_H
+#define _SPARSE_DEPEND_H
+
+#include "attr.h"
+#include "token.h"
+
+struct macro_dep_el {
+ struct macro_dep_el *n;
+ struct symbol *sym;
+};
+
+struct macro_dep {
+ struct macro_dep *up, *same;
+ struct token *ppline;
+ struct macro_dep_el *f;
+ int visited : 1;
+};
+
+struct dep_flags {
+ struct token *tok;
+ struct token *end;
+ struct symbol_list *symlist;
+ unsigned int visited : 1;
+};
+
+struct macro_expansion {
+ int nargs;
+ struct symbol *sym;
+ struct token *m;
+ struct arg args[0];
+};
+
+struct tok_macro_dep {
+ struct macro_expansion *m;
+ unsigned int argi;
+ unsigned int isbody : 1;
+ unsigned int visited : 1;
+};
+
+struct depend_if {
+ /* ATTR_TAG_MACRO_DEP tagging */
+ void * (*push_dep)(struct depend_if *dif, struct token *tok);
+ void * (*else_dep)(struct depend_if *dif, struct token *tok);
+ void * (*pop_dep)(struct depend_if *dif, struct token *tok);
+ void * (*push_sym)(struct depend_if *dif, struct symbol *sym);
+ void * (*on)(struct depend_if *dif, void *p);
+ void * (*off)(struct depend_if *dif, void *p);
+ /* ATTR_TAG_FLAGS tagging */
+ void * (*tag_dep)(struct depend_if *dif,struct token *tok);
+ void * (*set_tok)(struct depend_if *dif,void *p, struct token *tok);
+ void * (*end_tok)(struct depend_if *dif,void *p, struct token *tok);
+ void * (*inherit_tok)(struct depend_if *dif,void *a, void *b);
+ void * (*set_symlist)(struct depend_if *dif,void *a, struct symbol_list * l);
+ /* ATTR_TAG_MACRO_EXP tagging */
+ void * (*macro_exp)(struct depend_if *dif, struct token *tok, struct tok_macro_dep *m);
+
+ struct macro_dep *dep, *dep_use;
+ struct macro_dep root_dep;
+};
+
+#define DEPEN() (dif != 0)
+#define DEPCALL(f,v) if (DEPEN()) dif->f(dif,v)
+#define DEP_TOK(p,tok) if (DEPEN()) dif->set_tok(dif,p,tok)
+#define DEP_INHERIT(a,b) if (DEPEN()) dif->inherit_tok(dif,a,b)
+#define DEP_END(p,tok) if (DEPEN()) dif->end_tok(dif,p,tok)
+#define DEP_SYMLIST(p,l) if (DEPEN()) dif->set_symlist(dif,p,l)
+#define DEP_MACRO_EXP(p,m,i,b) if (DEPEN()) { \
+ struct tok_macro_dep n = { m, i, b }; \
+ dif->macro_exp(dif,p,&n); \
+ }
+
+extern void init_dep(void);
+extern void depend_symbol(struct symbol *sym);
+#endif
diff --git a/expand.c b/expand.c
index 63a9075..cf292e1 100644
--- a/expand.c
+++ b/expand.c
@@ -859,6 +859,7 @@ static int expand_pos_expression(struct expression *expr)
* zero..
*/
reuse = alloc_expression(entry->pos, EXPR_POS);
+ DEP_INHERIT (reuse, entry);
}
reuse->type = EXPR_POS;
reuse->ctype = entry->ctype;
diff --git a/expression.c b/expression.c
index 0ae3a60..9ae8148 100644
--- a/expression.c
+++ b/expression.c
@@ -47,7 +47,7 @@ struct token *parens_expression(struct token *token, struct expression **expr, c
{
token = expect(token, '(', where);
if (match_op(token, '{')) {
- struct expression *e = alloc_expression(token->pos, EXPR_STATEMENT);
+ struct expression *e = alloc_expression_tok(token, EXPR_STATEMENT);
struct statement *stmt = alloc_statement(token->pos, STMT_COMPOUND);
*expr = e;
e->statement = stmt;
@@ -116,7 +116,7 @@ static int convert_function(struct token *next)
static struct token *parse_type(struct token *token, struct expression **tree)
{
struct symbol *sym;
- *tree = alloc_expression(token->pos, EXPR_TYPE);
+ *tree = alloc_expression_tok(token, EXPR_TYPE);
(*tree)->flags = Int_const_expr; /* sic */
token = typename(token, &sym, NULL);
if (sym->ident)
@@ -130,8 +130,8 @@ static struct token *parse_type(struct token *token, struct expression **tree)
static struct token *builtin_types_compatible_p_expr(struct token *token,
struct expression **tree)
{
- struct expression *expr = alloc_expression(
- token->pos, EXPR_COMPARE);
+ struct expression *expr = alloc_expression_tok(
+ token, EXPR_COMPARE);
expr->flags = Int_const_expr;
expr->op = SPECIAL_EQUAL;
token = token->next;
@@ -185,7 +185,7 @@ static struct token *builtin_offsetof_expr(struct token *token,
default:
return expect(token, ')', "at end of __builtin_offset");
case SPECIAL_DEREFERENCE:
- e = alloc_expression(token->pos, EXPR_OFFSETOF);
+ e = alloc_expression_tok(token, EXPR_OFFSETOF);
e->flags = Int_const_expr;
e->op = '[';
*p = e;
@@ -193,7 +193,7 @@ static struct token *builtin_offsetof_expr(struct token *token,
/* fall through */
case '.':
token = token->next;
- e = alloc_expression(token->pos, EXPR_OFFSETOF);
+ e = alloc_expression_tok(token, EXPR_OFFSETOF);
e->flags = Int_const_expr;
e->op = '.';
if (token_type(token) != TOKEN_IDENT) {
@@ -205,7 +205,7 @@ static struct token *builtin_offsetof_expr(struct token *token,
break;
case '[':
token = token->next;
- e = alloc_expression(token->pos, EXPR_OFFSETOF);
+ e = alloc_expression_tok(token, EXPR_OFFSETOF);
e->flags = Int_const_expr;
e->op = '[';
token = parse_expression(token, &e->index);
@@ -406,7 +406,7 @@ struct token *primary_expression(struct token *token, struct expression **tree)
switch (token_type(token)) {
case TOKEN_CHAR:
case TOKEN_WIDE_CHAR:
- expr = alloc_expression(token->pos, EXPR_VALUE);
+ expr = alloc_expression_tok(token, EXPR_VALUE);
expr->flags = Int_const_expr;
expr->ctype = token_type(token) == TOKEN_CHAR ? &int_ctype : &long_ctype;
expr->value = (unsigned char) token->character;
@@ -414,13 +414,13 @@ struct token *primary_expression(struct token *token, struct expression **tree)
break;
case TOKEN_NUMBER:
- expr = alloc_expression(token->pos, EXPR_VALUE);
+ expr = alloc_expression_tok(token, EXPR_VALUE);
get_number_value(expr, token); /* will see if it's an integer */
token = token->next;
break;
case TOKEN_ZERO_IDENT: {
- expr = alloc_expression(token->pos, EXPR_SYMBOL);
+ expr = alloc_expression_tok(token, EXPR_SYMBOL);
expr->flags = Int_const_expr;
expr->ctype = &int_ctype;
expr->symbol = &zero_int;
@@ -445,7 +445,7 @@ struct token *primary_expression(struct token *token, struct expression **tree)
break;
}
} else if (sym->enum_member) {
- expr = alloc_expression(token->pos, EXPR_VALUE);
+ expr = alloc_expression_tok(token, EXPR_VALUE);
*expr = *sym->initializer;
/* we want the right position reported, thus the copy */
expr->pos = token->pos;
@@ -454,7 +454,7 @@ struct token *primary_expression(struct token *token, struct expression **tree)
break;
}
- expr = alloc_expression(token->pos, EXPR_SYMBOL);
+ expr = alloc_expression_tok(token, EXPR_SYMBOL);
/*
* We support types as real first-class citizens, with type
@@ -475,7 +475,7 @@ struct token *primary_expression(struct token *token, struct expression **tree)
case TOKEN_STRING:
case TOKEN_WIDE_STRING: {
handle_string:
- expr = alloc_expression(token->pos, EXPR_STRING);
+ expr = alloc_expression_tok(token, EXPR_STRING);
expr->wide = token_type(token) == TOKEN_WIDE_STRING;
token = string_expression(token, expr);
break;
@@ -483,7 +483,7 @@ struct token *primary_expression(struct token *token, struct expression **tree)
case TOKEN_SPECIAL:
if (token->special == '(') {
- expr = alloc_expression(token->pos, EXPR_PREOP);
+ expr = alloc_expression_tok(token, EXPR_PREOP);
expr->op = '(';
token = parens_expression(token, &expr->unop, "in expression");
if (expr->unop)
@@ -491,7 +491,7 @@ struct token *primary_expression(struct token *token, struct expression **tree)
break;
}
if (token->special == '[' && lookup_type(token->next)) {
- expr = alloc_expression(token->pos, EXPR_TYPE);
+ expr = alloc_expression_tok(token, EXPR_TYPE);
expr->flags = Int_const_expr; /* sic */
token = typename(token->next, &expr->symbol, NULL);
token = expect(token, ']', "in type expression");
@@ -534,8 +534,8 @@ static struct token *postfix_expression(struct token *token, struct expression *
while (expr && token_type(token) == TOKEN_SPECIAL) {
switch (token->special) {
case '[': { /* Array dereference */
- struct expression *deref = alloc_expression(token->pos, EXPR_PREOP);
- struct expression *add = alloc_expression(token->pos, EXPR_BINOP);
+ struct expression *deref = alloc_expression_tok(token, EXPR_PREOP);
+ struct expression *add = alloc_expression_tok(token, EXPR_BINOP);
deref->op = '*';
deref->unop = add;
@@ -549,7 +549,7 @@ static struct token *postfix_expression(struct token *token, struct expression *
}
case SPECIAL_INCREMENT: /* Post-increment */
case SPECIAL_DECREMENT: { /* Post-decrement */
- struct expression *post = alloc_expression(token->pos, EXPR_POSTOP);
+ struct expression *post = alloc_expression_tok(token, EXPR_POSTOP);
post->op = token->special;
post->unop = expr;
expr = post;
@@ -558,14 +558,14 @@ static struct token *postfix_expression(struct token *token, struct expression *
}
case SPECIAL_DEREFERENCE: { /* Structure pointer member dereference */
/* "x->y" is just shorthand for "(*x).y" */
- struct expression *inner = alloc_expression(token->pos, EXPR_PREOP);
+ struct expression *inner = alloc_expression_tok(token, EXPR_PREOP);
inner->op = '*';
inner->unop = expr;
expr = inner;
}
/* Fall through!! */
case '.': { /* Structure member dereference */
- struct expression *deref = alloc_expression(token->pos, EXPR_DEREF);
+ struct expression *deref = alloc_expression_tok(token, EXPR_DEREF);
deref->op = '.';
deref->deref = expr;
token = token->next;
@@ -580,7 +580,7 @@ static struct token *postfix_expression(struct token *token, struct expression *
}
case '(': { /* Function call */
- struct expression *call = alloc_expression(token->pos, EXPR_CALL);
+ struct expression *call = alloc_expression_tok(token, EXPR_CALL);
call->op = '(';
call->fn = expr;
token = expression_list(token->next, &call->args);
@@ -604,7 +604,7 @@ static struct token *unary_expression(struct token *token, struct expression **t
static struct token *type_info_expression(struct token *token,
struct expression **tree, int type)
{
- struct expression *expr = alloc_expression(token->pos, type);
+ struct expression *expr = alloc_expression_tok(token, type);
struct token *p;
*tree = expr;
@@ -630,7 +630,7 @@ static struct token *type_info_expression(struct token *token,
* of a typed initializer expression..
*/
if (match_op(token, '{')) {
- struct expression *cast = alloc_expression(p->pos, EXPR_CAST);
+ struct expression *cast = alloc_expression_tok(p, EXPR_CAST);
cast->cast_type = expr->cast_type;
expr->cast_type = NULL;
expr->cast_expression = cast;
@@ -676,7 +676,7 @@ static struct token *unary_expression(struct token *token, struct expression **t
*tree = NULL;
return next;
}
- unary = alloc_expression(token->pos, EXPR_PREOP);
+ unary = alloc_expression_tok(token, EXPR_PREOP);
unary->op = token->special;
unary->unop = unop;
*tree = unary;
@@ -694,7 +694,7 @@ static struct token *unary_expression(struct token *token, struct expression **t
*tree = NULL;
return next;
}
- unary = alloc_expression(token->pos, EXPR_PREOP);
+ unary = alloc_expression_tok(token, EXPR_PREOP);
unary->op = token->special;
unary->unop = unop;
unary->flags = unop->flags & Int_const_expr;
@@ -704,7 +704,7 @@ static struct token *unary_expression(struct token *token, struct expression **t
/* Gcc extension: &&label gives the address of a label */
if (match_op(token, SPECIAL_LOGICAL_AND) &&
token_type(token->next) == TOKEN_IDENT) {
- struct expression *label = alloc_expression(token->pos, EXPR_LABEL);
+ struct expression *label = alloc_expression_tok(token, EXPR_LABEL);
struct symbol *sym = label_symbol(token->next);
if (!(sym->ctype.modifiers & MOD_ADDRESSABLE)) {
sym->ctype.modifiers |= MOD_ADDRESSABLE;
@@ -733,7 +733,7 @@ static struct token *cast_expression(struct token *token, struct expression **tr
if (match_op(token, '(')) {
struct token *next = token->next;
if (lookup_type(next)) {
- struct expression *cast = alloc_expression(next->pos, EXPR_CAST);
+ struct expression *cast = alloc_expression_tok(next, EXPR_CAST);
struct expression *v;
struct symbol *sym;
int is_force;
@@ -789,7 +789,7 @@ static struct token *cast_expression(struct token *token, struct expression **tr
\
if (!(compare)) \
goto out; \
- top = alloc_expression(next->pos, type); \
+ top = alloc_expression_tok(next, type); \
next = inner(next->next, &right); \
if (!right) { \
sparse_error(next->pos, "No right hand side of '%s'-expression", show_special(op)); \
@@ -892,7 +892,7 @@ struct token *conditional_expression(struct token *token, struct expression **tr
{
token = logical_or_expression(token, tree);
if (*tree && match_op(token, '?')) {
- struct expression *expr = alloc_expression(token->pos, EXPR_CONDITIONAL);
+ struct expression *expr = alloc_expression_tok(token, EXPR_CONDITIONAL);
expr->op = token->special;
expr->left = *tree;
*tree = expr;
@@ -925,7 +925,7 @@ struct token *assignment_expression(struct token *token, struct expression **tre
int i, op = token->special;
for (i = 0; i < ARRAY_SIZE(assignments); i++)
if (assignments[i] == op) {
- struct expression * expr = alloc_expression(token->pos, EXPR_ASSIGNMENT);
+ struct expression * expr = alloc_expression_tok(token, EXPR_ASSIGNMENT);
expr->left = *tree;
expr->op = op;
*tree = expr;
diff --git a/expression.h b/expression.h
index 9778de8..95edf0f 100644
--- a/expression.h
+++ b/expression.h
@@ -14,6 +14,7 @@
#include "allocate.h"
#include "lib.h"
#include "symbol.h"
+#include "depend.h"
struct expression_list;
@@ -185,6 +186,13 @@ static inline struct expression *alloc_expression(struct position pos, int type)
return expr;
}
+static inline struct expression *alloc_expression_tok(struct token *tok, int type)
+{
+ struct expression *e = alloc_expression(tok->pos, type);
+ DEP_TOK(e, tok);
+ return e;
+}
+
static inline struct expression *alloc_const_expression(struct position pos, int value)
{
struct expression *expr = __alloc_expression(0);
diff --git a/inline.c b/inline.c
index 9ed4570..5ba1747 100644
--- a/inline.c
+++ b/inline.c
@@ -20,6 +20,7 @@
static struct expression * dup_expression(struct expression *expr)
{
struct expression *dup = alloc_expression(expr->pos, expr->type);
+ DEP_INHERIT (dup, expr);
*dup = *expr;
return dup;
}
@@ -27,6 +28,7 @@ static struct expression * dup_expression(struct expression *expr)
static struct statement * dup_statement(struct statement *stmt)
{
struct statement *dup = alloc_statement(stmt->pos, stmt->type);
+ DEP_INHERIT (dup, stmt);
*dup = *stmt;
return dup;
}
@@ -142,6 +144,7 @@ static struct expression * copy_expression(struct expression *expr)
expr = dup_expression(expr);
expr->cast_expression = copy_expression(cast);
expr->cast_type = alloc_symbol(sym->pos, sym->type);
+ DEP_INHERIT (expr->cast_type, sym);
*expr->cast_type = *sym;
break;
}
@@ -176,6 +179,7 @@ static struct expression * copy_expression(struct expression *expr)
/* Statement expression */
case EXPR_STATEMENT: {
struct statement *stmt = alloc_statement(expr->pos, STMT_COMPOUND);
+ DEP_INHERIT (stmt, expr);
copy_statement(expr->statement, stmt);
expr = dup_expression(expr);
expr->statement = stmt;
@@ -347,6 +351,7 @@ static struct statement *copy_one_statement(struct statement *stmt)
}
case STMT_COMPOUND: {
struct statement *new = alloc_statement(stmt->pos, STMT_COMPOUND);
+ DEP_INHERIT (new, stmt);
copy_statement(stmt, new);
stmt = new;
break;
@@ -469,6 +474,7 @@ static struct symbol *create_copy_symbol(struct symbol *orig)
struct symbol *sym = orig;
if (orig) {
sym = alloc_symbol(orig->pos, orig->type);
+ DEP_INHERIT (sym, orig);
*sym = *orig;
sym->bb_target = NULL;
sym->pseudo = NULL;
@@ -499,6 +505,7 @@ int inline_function(struct expression *expr, struct symbol *sym)
struct symbol_list *name_list, *arg_decl;
struct symbol *name;
struct expression *arg;
+ DEP_INHERIT (stmt, expr);
if (!fn->inline_stmt) {
sparse_error(fn->pos, "marked inline, but without a definition");
@@ -521,6 +528,7 @@ int inline_function(struct expression *expr, struct symbol *sym)
PREPARE_PTR_LIST(name_list, name);
FOR_EACH_PTR(arg_list, arg) {
struct symbol *a = alloc_symbol(arg->pos, SYM_NODE);
+ DEP_INHERIT (a, arg);
a->ctype.base_type = arg->ctype;
if (name) {
@@ -539,6 +547,7 @@ int inline_function(struct expression *expr, struct symbol *sym)
if (arg_decl) {
struct statement *decl = alloc_statement(expr->pos, STMT_DECLARATION);
+ DEP_INHERIT (decl, expr);
decl->declaration = arg_decl;
stmt->args = decl;
}
@@ -563,6 +572,7 @@ void uninline(struct symbol *sym)
p->replace = p;
} END_FOR_EACH_PTR(p);
fn->stmt = alloc_statement(fn->pos, STMT_COMPOUND);
+ DEP_INHERIT (fn->stmt, fn);
copy_statement(fn->inline_stmt, fn->stmt);
unset_replace_list(sym->symbol_list);
unset_replace_list(arg_list);
diff --git a/lib.c b/lib.c
index 396e9f1..d835870 100644
--- a/lib.c
+++ b/lib.c
@@ -213,6 +213,8 @@ int Wundef = 0;
int Wuninitialized = 1;
int Wdeclarationafterstatement = -1;
+int fnobuiltin = 0;
+
int dbg_entry = 0;
int dbg_dead = 0;
@@ -553,6 +555,9 @@ static char **handle_switch_f(char *arg, char **next)
arg += 3;
}
/* handle switch here.. */
+ if (!strncmp(arg, "builtin", 7)) {
+ fnobuiltin = 1;
+ }
return next;
}
@@ -668,6 +673,9 @@ static char **handle_switch(char *arg, char **next)
void declare_builtin_functions(void)
{
+ if (fnobuiltin)
+ return;
+
/* Gaah. gcc knows tons of builtin <string.h> functions */
add_pre_buffer("extern void *__builtin_memcpy(void *, const void *, __SIZE_TYPE__);\n");
add_pre_buffer("extern void *__builtin_mempcpy(void *, const void *, __SIZE_TYPE__);\n");
diff --git a/parse.c b/parse.c
index bd42180..f7bfc1c 100644
--- a/parse.c
+++ b/parse.c
@@ -652,9 +652,9 @@ static void apply_modifiers(struct position pos, struct decl_state *ctx)
}
-static struct symbol * alloc_indirect_symbol(struct position pos, struct ctype *ctype, int type)
+static struct symbol * alloc_indirect_symbol(struct token *tok, struct ctype *ctype, int type)
{
- struct symbol *sym = alloc_symbol(pos, type);
+ struct symbol *sym = alloc_symbol_tok(tok, type);
sym->ctype.base_type = ctype->base_type;
sym->ctype.modifiers = ctype->modifiers;
@@ -673,7 +673,7 @@ struct symbol *label_symbol(struct token *token)
{
struct symbol *sym = lookup_symbol(token->ident, NS_LABEL);
if (!sym) {
- sym = alloc_symbol(token->pos, SYM_LABEL);
+ sym = alloc_symbol_tok(token, SYM_LABEL);
bind_symbol(sym, token->ident, NS_LABEL);
fn_local_symbol(sym);
}
@@ -695,7 +695,7 @@ static struct token *struct_union_enum_specifier(enum type type,
(match_op(token->next,';') || match_op(token->next,'{')))) {
// Either a new symbol, or else an out-of-scope
// symbol being redefined.
- sym = alloc_symbol(token->pos, type);
+ sym = alloc_symbol_tok(token, type);
bind_symbol(sym, token->ident, NS_STRUCT);
}
if (sym->type != type)
@@ -716,6 +716,7 @@ static struct token *struct_union_enum_specifier(enum type type,
// Mark the structure as needing re-examination
sym->examined = 0;
sym->endpos = token->pos;
+ DEP_END (sym, token);
}
return token;
}
@@ -727,11 +728,12 @@ static struct token *struct_union_enum_specifier(enum type type,
return token;
}
- sym = alloc_symbol(token->pos, type);
+ sym = alloc_symbol_tok(token, type);
token = parse(token->next, sym);
ctx->ctype.base_type = sym;
token = expect(token, '}', "at end of specifier");
sym->endpos = token->pos;
+ DEP_END (sym, token);
return token;
}
@@ -875,7 +877,7 @@ static struct token *parse_enum_declaration(struct token *token, struct symbol *
expr->ctype = ctype;
}
- sym = alloc_symbol(token->pos, SYM_NODE);
+ sym = alloc_symbol_tok(token, SYM_NODE);
bind_symbol(sym, token->ident, NS_SYMBOL);
sym->ctype.modifiers &= ~MOD_ADDRESSABLE;
sym->initializer = expr;
@@ -926,6 +928,7 @@ static struct token *parse_enum_declaration(struct token *token, struct symbol *
token = next;
sym->endpos = token->pos;
+ DEP_END (sym, token);
if (!match_op(token, ','))
break;
@@ -988,10 +991,11 @@ static struct token *typeof_specifier(struct token *token, struct decl_state *ct
ctx->ctype.base_type = sym->ctype.base_type;
apply_ctype(token->pos, &sym->ctype, &ctx->ctype);
} else {
- struct symbol *typeof_sym = alloc_symbol(token->pos, SYM_TYPEOF);
+ struct symbol *typeof_sym = alloc_symbol_tok(token, SYM_TYPEOF);
token = parse_expression(token->next, &typeof_sym->initializer);
typeof_sym->endpos = token->pos;
+ DEP_END (typeof_sym, token);
if (!typeof_sym->initializer) {
sparse_error(token->pos, "expected expression after the '(' token");
typeof_sym = &bad_ctype;
@@ -1440,6 +1444,8 @@ static struct token *declaration_specifiers(struct token *token, struct decl_sta
NS_TYPEDEF | NS_SYMBOL);
if (!s || !(s->namespace & NS_TYPEDEF))
break;
+ if (DEPEN())
+ add_symbol (&ctx->dep, s);
if (s->type != SYM_KEYWORD) {
if (seen & Set_Any)
break;
@@ -1493,7 +1499,7 @@ static struct token *declaration_specifiers(struct token *token, struct decl_sta
sparse_error(token->pos, "invalid modifier");
return token;
}
- type = alloc_symbol(token->pos, SYM_BASETYPE);
+ type = alloc_symbol_tok(token, SYM_BASETYPE);
*type = *ctx->ctype.base_type;
type->ctype.modifiers &= ~MOD_SPECIFIER;
type->ctype.base_type = ctx->ctype.base_type;
@@ -1679,7 +1685,7 @@ static struct token *direct_declarator(struct token *token, struct decl_state *c
if (match_op(token, '(')) {
enum kind kind = which_func(token, p, ctx->prefer_abstract);
struct symbol *fn;
- fn = alloc_indirect_symbol(token->pos, ctype, SYM_FN);
+ fn = alloc_indirect_symbol(token, ctype, SYM_FN);
token = token->next;
if (kind == K_R)
token = identifier_list(token, fn);
@@ -1687,15 +1693,17 @@ static struct token *direct_declarator(struct token *token, struct decl_state *c
token = parameter_type_list(token, fn);
token = expect(token, ')', "in function declarator");
fn->endpos = token->pos;
+ DEP_END (fn, token);
return token;
}
while (match_op(token, '[')) {
struct symbol *array;
- array = alloc_indirect_symbol(token->pos, ctype, SYM_ARRAY);
+ array = alloc_indirect_symbol(token, ctype, SYM_ARRAY);
token = abstract_array_declarator(token->next, array);
token = expect(token, ']', "in abstract_array_declarator");
array->endpos = token->pos;
+ DEP_END (array, token);
ctype = &array->ctype;
}
return token;
@@ -1704,7 +1712,7 @@ static struct token *direct_declarator(struct token *token, struct decl_state *c
static struct token *pointer(struct token *token, struct decl_state *ctx)
{
while (match_op(token,'*')) {
- struct symbol *ptr = alloc_symbol(token->pos, SYM_PTR);
+ struct symbol *ptr = alloc_symbol_tok(token, SYM_PTR);
ptr->ctype.modifiers = ctx->ctype.modifiers;
ptr->ctype.base_type = ctx->ctype.base_type;
ptr->ctype.as = ctx->ctype.as;
@@ -1717,6 +1725,8 @@ static struct token *pointer(struct token *token, struct decl_state *ctx)
token = handle_qualifiers(token->next, ctx);
ctx->ctype.base_type->endpos = token->pos;
+ DEP_END (ctx->ctype.base_type, token);
+
}
return token;
}
@@ -1741,7 +1751,7 @@ static struct token *handle_bitfield(struct token *token, struct decl_state *ctx
return conditional_expression(token->next, &expr);
}
- bitfield = alloc_indirect_symbol(token->pos, ctype, SYM_BITFIELD);
+ bitfield = alloc_indirect_symbol(token, ctype, SYM_BITFIELD);
token = conditional_expression(token->next, &expr);
width = const_expression_value(expr);
bitfield->bit_size = width;
@@ -1772,6 +1782,7 @@ static struct token *handle_bitfield(struct token *token, struct decl_state *ctx
}
bitfield->bit_size = width;
bitfield->endpos = token->pos;
+ DEP_END (bitfield, token);
return token;
}
@@ -1785,7 +1796,7 @@ static struct token *declaration_list(struct token *token, struct symbol_list **
mod = storage_modifiers(&ctx);
saved = ctx.ctype;
for (;;) {
- struct symbol *decl = alloc_symbol(token->pos, SYM_NODE);
+ struct symbol *decl = alloc_symbol_tok(token, SYM_NODE);
ctx.ident = &decl->ident;
token = declarator(token, &ctx);
@@ -1798,6 +1809,7 @@ static struct token *declaration_list(struct token *token, struct symbol_list **
decl->ctype = ctx.ctype;
decl->ctype.modifiers |= mod;
decl->endpos = token->pos;
+ DEP_END (decl, token);
add_symbol(list, decl);
if (!match_op(token, ','))
break;
@@ -1833,6 +1845,7 @@ static struct token *parameter_declaration(struct token *token, struct symbol *s
sym->ctype = ctx.ctype;
sym->ctype.modifiers |= storage_modifiers(&ctx);
sym->endpos = token->pos;
+ DEP_END (sym, token);
return token;
}
@@ -1840,13 +1853,14 @@ struct token *typename(struct token *token, struct symbol **p, int *forced)
{
struct decl_state ctx = {.prefer_abstract = 1};
int class;
- struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
+ struct symbol *sym = alloc_symbol_tok(token, SYM_NODE);
*p = sym;
token = declaration_specifiers(token, &ctx);
token = declarator(token, &ctx);
apply_modifiers(token->pos, &ctx);
sym->ctype = ctx.ctype;
sym->endpos = token->pos;
+ DEP_END (sym, token);
class = ctx.storage_class;
if (forced) {
*forced = 0;
@@ -1965,6 +1979,7 @@ static struct statement *make_statement(struct expression *expr)
if (!expr)
return NULL;
stmt = alloc_statement(expr->pos, STMT_EXPRESSION);
+ DEP_INHERIT (stmt, expr);
stmt->expression = expr;
return stmt;
}
@@ -1984,8 +1999,10 @@ static void start_iterator(struct statement *stmt)
start_symbol_scope();
cont = alloc_symbol(stmt->pos, SYM_NODE);
+ DEP_INHERIT (cont, stmt);
bind_symbol(cont, &continue_ident, NS_ITERATOR);
brk = alloc_symbol(stmt->pos, SYM_NODE);
+ DEP_INHERIT (brk, stmt);
bind_symbol(brk, &break_ident, NS_ITERATOR);
stmt->type = STMT_ITERATOR;
@@ -2004,9 +2021,11 @@ static struct statement *start_function(struct symbol *sym)
{
struct symbol *ret;
struct statement *stmt = alloc_statement(sym->pos, STMT_COMPOUND);
+ DEP_INHERIT (stmt, sym);
start_function_scope();
ret = alloc_symbol(sym->pos, SYM_NODE);
+ DEP_INHERIT (ret, sym);
ret->ctype = sym->ctype.base_type->ctype;
ret->ctype.modifiers &= ~(MOD_STORAGE | MOD_CONST | MOD_VOLATILE | MOD_TLS | MOD_INLINE | MOD_ADDRESSABLE | MOD_NOCAST | MOD_NODEREF | MOD_ACCESSED | MOD_TOPLEVEL);
ret->ctype.modifiers |= (MOD_AUTO | MOD_REGISTER);
@@ -2044,9 +2063,11 @@ static void start_switch(struct statement *stmt)
start_symbol_scope();
brk = alloc_symbol(stmt->pos, SYM_NODE);
+ DEP_INHERIT (brk, stmt);
bind_symbol(brk, &break_ident, NS_ITERATOR);
switch_case = alloc_symbol(stmt->pos, SYM_NODE);
+ DEP_INHERIT (switch_case, stmt);
bind_symbol(switch_case, &case_ident, NS_ITERATOR);
switch_case->stmt = stmt;
@@ -2076,6 +2097,7 @@ static void add_case_statement(struct statement *stmt)
return;
}
sym = alloc_symbol(stmt->pos, SYM_NODE);
+ DEP_INHERIT (sym, stmt);
add_symbol(&target->symbol_list, sym);
sym->stmt = stmt;
stmt->case_label = sym;
@@ -2266,6 +2288,7 @@ static struct token *parse_range_statement(struct token *token, struct statement
static struct token *statement(struct token *token, struct statement **tree)
{
struct statement *stmt = alloc_statement(token->pos, STMT_NONE);
+ DEP_TOK (stmt, token);
*tree = stmt;
if (token_type(token) == TOKEN_IDENT) {
@@ -2298,7 +2321,7 @@ static struct token *statement(struct token *token, struct statement **tree)
static struct token *label_statement(struct token *token)
{
while (token_type(token) == TOKEN_IDENT) {
- struct symbol *sym = alloc_symbol(token->pos, SYM_LABEL);
+ struct symbol *sym = alloc_symbol_tok(token, SYM_LABEL);
/* it's block-scope, but we want label namespace */
bind_symbol(sym, token->ident, NS_SYMBOL);
sym->namespace = NS_LABEL;
@@ -2329,6 +2352,7 @@ static struct token * statement_list(struct token *token, struct statement_list
seen_statement = 0;
}
stmt = alloc_statement(token->pos, STMT_DECLARATION);
+ DEP_TOK (stmt, token);
token = external_declaration(token, &stmt->declaration);
} else {
seen_statement = Wdeclarationafterstatement;
@@ -2343,10 +2367,11 @@ static struct token *identifier_list(struct token *token, struct symbol *fn)
{
struct symbol_list **list = &fn->arguments;
for (;;) {
- struct symbol *sym = alloc_symbol(token->pos, SYM_NODE);
+ struct symbol *sym = alloc_symbol_tok(token, SYM_NODE);
sym->ident = token->ident;
token = token->next;
sym->endpos = token->pos;
+ DEP_END (sym, token);
sym->ctype.base_type = &incomplete_ctype;
add_symbol(list, sym);
if (!match_op(token, ',') ||
@@ -2371,7 +2396,7 @@ static struct token *parameter_type_list(struct token *token, struct symbol *fn)
break;
}
- sym = alloc_symbol(token->pos, SYM_NODE);
+ sym = alloc_symbol_tok(token, SYM_NODE);
token = parameter_declaration(token, sym);
if (sym->ctype.base_type == &void_ctype) {
/* Special case: (void) */
@@ -2642,12 +2667,13 @@ static struct token *parse_k_r_arguments(struct token *token, struct symbol *dec
static struct token *toplevel_asm_declaration(struct token *token, struct symbol_list **list)
{
- struct symbol *anon = alloc_symbol(token->pos, SYM_NODE);
- struct symbol *fn = alloc_symbol(token->pos, SYM_FN);
+ struct symbol *anon = alloc_symbol_tok(token, SYM_NODE);
+ struct symbol *fn = alloc_symbol_tok(token, SYM_FN);
struct statement *stmt;
anon->ctype.base_type = fn;
stmt = alloc_statement(token->pos, STMT_NONE);
+ DEP_TOK (stmt, token);
fn->stmt = stmt;
token = parse_asm_statement(token, stmt);
@@ -2660,7 +2686,7 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
{
struct ident *ident = NULL;
struct symbol *decl;
- struct decl_state ctx = { .ident = &ident };
+ struct decl_state ctx = { .ident = &ident, .dep = 0 };
struct ctype saved;
struct symbol *base_type;
unsigned long mod;
@@ -2676,7 +2702,7 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
/* Parse declaration-specifiers, if any */
token = declaration_specifiers(token, &ctx);
mod = storage_modifiers(&ctx);
- decl = alloc_symbol(token->pos, SYM_NODE);
+ decl = alloc_symbol_tok(token, SYM_NODE);
/* Just a type declaration? */
if (match_op(token, ';')) {
apply_modifiers(token->pos, &ctx);
@@ -2691,6 +2717,8 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
decl->ctype = ctx.ctype;
decl->ctype.modifiers |= mod;
decl->endpos = token->pos;
+ DEP_END (decl, token);
+ DEP_SYMLIST (decl, ctx.dep);
/* Just a type declaration? */
if (!ident) {
@@ -2755,7 +2783,7 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
token = token->next;
ident = NULL;
- decl = alloc_symbol(token->pos, SYM_NODE);
+ decl = alloc_symbol_tok(token, SYM_NODE);
ctx.ctype = saved;
token = handle_attributes(token, &ctx, KW_ATTRIBUTE);
token = declarator(token, &ctx);
@@ -2764,6 +2792,7 @@ struct token *external_declaration(struct token *token, struct symbol_list **lis
decl->ctype = ctx.ctype;
decl->ctype.modifiers |= mod;
decl->endpos = token->pos;
+ DEP_END (decl, token);
if (!ident) {
sparse_error(token->pos, "expected identifier name in type definition");
return token;
diff --git a/parse.h b/parse.h
index b26bd03..9ff6639 100644
--- a/parse.h
+++ b/parse.h
@@ -10,6 +10,7 @@
*/
#include "symbol.h"
+#include "depend.h"
enum statement_type {
STMT_NONE,
diff --git a/pre-process.c b/pre-process.c
index 8a16f8b..3dbbb11 100644
--- a/pre-process.c
+++ b/pre-process.c
@@ -27,7 +27,10 @@
#include "symbol.h"
#include "expression.h"
#include "scope.h"
+#include "depend.h"
+/* interface to depend.c, if set */
+struct depend_if *dif;
static int false_nesting = 0;
#define INCLUDEPATHS 300
@@ -111,6 +114,7 @@ static struct symbol *lookup_macro(struct ident *ident)
struct symbol *sym = lookup_symbol(ident, NS_MACRO | NS_UNDEF);
if (sym && sym->namespace != NS_MACRO)
sym = NULL;
+ DEPCALL(push_sym, sym);
return sym;
}
@@ -244,15 +248,6 @@ static struct token *collect_arg(struct token *prev, int vararg, struct position
* We store arglist as <counter> [arg1] <number of uses for arg1> ... eof
*/
-struct arg {
- struct token *arg;
- struct token *expanded;
- struct token *str;
- int n_normal;
- int n_quoted;
- int n_str;
-};
-
static int collect_arguments(struct token *start, struct token *arglist, struct arg *args, struct token *what)
{
int wanted = arglist->count.normal;
@@ -325,15 +320,22 @@ out:
return 0;
}
-static struct token *dup_list(struct token *list)
+static struct token *dup_one(struct token *list)
+{
+ struct token *newtok = __alloc_token(0);
+ *newtok = *list;
+ return newtok;
+}
+
+static struct token *dup_list(struct token *list, struct macro_expansion *me, int argi)
{
struct token *res = NULL;
struct token **p = &res;
while (!eof_token(list)) {
- struct token *newtok = __alloc_token(0);
- *newtok = *list;
+ struct token *newtok = dup_one(list);
*p = newtok;
+ DEP_MACRO_EXP(newtok, me, argi, 0);
p = &newtok->next;
list = list->next;
}
@@ -356,7 +358,7 @@ static struct token *stringify(struct token *arg)
return token;
}
-static void expand_arguments(int count, struct arg *args)
+static void expand_arguments(int count, struct arg *args, struct macro_expansion *me)
{
int i;
for (i = 0; i < count; i++) {
@@ -372,7 +374,7 @@ static void expand_arguments(int count, struct arg *args)
} else if (eof_token(arg)) {
args[i].expanded = arg;
} else {
- args[i].expanded = dup_list(arg);
+ args[i].expanded = dup_list(arg,me,i);
}
expand_list(&args[i].expanded);
}
@@ -472,7 +474,7 @@ static int merge(struct token *left, struct token *right)
return 0;
}
-static struct token *dup_token(struct token *token, struct position *streampos, struct position *pos)
+static struct token *dup_token(struct token *token, struct position *streampos, struct position *pos, struct macro_expansion *me)
{
struct token *alloc = alloc_token(streampos);
token_type(alloc) = token_type(token);
@@ -480,16 +482,17 @@ static struct token *dup_token(struct token *token, struct position *streampos,
alloc->pos.whitespace = pos->whitespace;
alloc->number = token->number;
alloc->pos.noexpand = token->pos.noexpand;
- return alloc;
+ DEP_MACRO_EXP(token, me, 0, 1);
+ return alloc;
}
-static struct token **copy(struct token **where, struct token *list, int *count)
+static struct token **copy(struct token **where, struct token *list, int *count, struct macro_expansion *me)
{
int need_copy = --*count;
while (!eof_token(list)) {
struct token *token;
if (need_copy)
- token = dup_token(list, &list->pos, &list->pos);
+ token = dup_token(list, &list->pos, &list->pos, me);
else
token = list;
if (token_type(token) == TOKEN_IDENT && token->ident->tainted)
@@ -502,7 +505,7 @@ static struct token **copy(struct token **where, struct token *list, int *count)
return where;
}
-static struct token **substitute(struct token **list, struct token *body, struct arg *args)
+static struct token **substitute(struct token **list, struct token *body, struct arg *args, struct macro_expansion *me)
{
struct token *token = *list;
struct position *base_pos = &token->pos;
@@ -526,7 +529,7 @@ static struct token **substitute(struct token **list, struct token *body, struct
*/
if (!args[body->next->argnum].arg)
continue;
- added = dup_token(body, base_pos, pos);
+ added = dup_token(body, base_pos, pos, me);
token_type(added) = TOKEN_SPECIAL;
tail = &added->next;
break;
@@ -556,7 +559,7 @@ static struct token **substitute(struct token **list, struct token *body, struct
continue;
}
copy_arg:
- tail = copy(&added, arg, count);
+ tail = copy(&added, arg, count, me);
added->pos.newline = pos->newline;
added->pos.whitespace = pos->whitespace;
break;
@@ -569,14 +572,14 @@ static struct token **substitute(struct token **list, struct token *body, struct
continue;
case TOKEN_IDENT:
- added = dup_token(body, base_pos, pos);
+ added = dup_token(body, base_pos, pos, me);
if (added->ident->tainted)
added->pos.noexpand = 1;
tail = &added->next;
break;
default:
- added = dup_token(body, base_pos, pos);
+ added = dup_token(body, base_pos, pos, me);
tail = &added->next;
break;
}
@@ -606,7 +609,16 @@ static int expand(struct token **list, struct symbol *sym)
struct ident *expanding = token->ident;
struct token **tail;
int nargs = sym->arglist ? sym->arglist->count.normal : 0;
- struct arg args[nargs];
+ struct arg _args[nargs];
+ struct arg *args = _args;
+ struct macro_expansion *me = 0;
+
+ if (DEPEN()) {
+ me = __alloc_macro_expansion(sizeof(struct arg) * nargs);
+ me->m = token;
+ me->sym = sym;
+ args = me->args;
+ }
if (expanding->tainted) {
token->pos.noexpand = 1;
@@ -618,13 +630,13 @@ static int expand(struct token **list, struct symbol *sym)
return 1;
if (!collect_arguments(token->next, sym->arglist, args, token))
return 1;
- expand_arguments(nargs, args);
+ expand_arguments(nargs, args, me);
}
expanding->tainted = 1;
last = token->next;
- tail = substitute(list, sym->expansion, args);
+ tail = substitute(list, sym->expansion, args, me);
*tail = last;
return 0;
@@ -907,11 +919,18 @@ static inline void set_arg_count(struct token *token)
token->count.str = token->count.vararg = 0;
}
-static struct token *parse_arguments(struct token *list)
+#define DUP(l) (DEPEN() ? dup_one(l) : (l))
+#define DUP_NEXT(l) (DEPEN() ? (l)->next = dup_one((l)->next) : (l)->next)
+
+static struct token *parse_arguments(struct token **arglist)
{
- struct token *arg = list->next, *next = list;
+ struct token *list = DUP(*arglist);
+ struct token *arg = DUP_NEXT(list), *next = list;
struct argcount *count = &list->count;
+ if (DEPEN())
+ *arglist = list;
+
set_arg_count(list);
if (match_op(arg, ')')) {
@@ -925,11 +944,11 @@ static struct token *parse_arguments(struct token *list)
goto Eva_args;
if (!++count->normal)
goto Eargs;
- next = arg->next;
+ next = DUP_NEXT(arg);
if (match_op(next, ',')) {
set_arg_count(next);
- arg = next->next;
+ arg = DUP_NEXT(next);
continue;
}
@@ -964,7 +983,7 @@ static struct token *parse_arguments(struct token *list)
}
if (match_op(arg, SPECIAL_ELLIPSIS)) {
- next = arg->next;
+ next = DUP_NEXT(arg);
token_type(arg) = TOKEN_IDENT;
arg->ident = &__VA_ARGS___ident;
if (!match_op(next, ')'))
@@ -1125,7 +1144,7 @@ static int do_handle_define(struct stream *stream, struct token **line, struct t
if (!expansion->pos.whitespace) {
if (match_op(expansion, '(')) {
arglist = expansion;
- expansion = parse_arguments(expansion);
+ expansion = parse_arguments(&arglist);
if (!expansion)
return 1;
} else if (!eof_token(expansion)) {
@@ -1299,6 +1318,8 @@ static int expression_value(struct token **where)
long long value;
int state = 0;
+ DEPCALL(on, *list);
+
while (!eof_token(p = scan_next(list))) {
switch (state) {
case 0:
@@ -1352,8 +1373,10 @@ static int expression_value(struct token **where)
static int handle_if(struct stream *stream, struct token **line, struct token *token)
{
int value = 0;
- if (!false_nesting)
+ if (!false_nesting) {
+ DEPCALL(push_dep,token);
value = expression_value(&token->next);
+ }
dirty_stream(stream);
return preprocessor_if(stream, token, value);
@@ -1378,6 +1401,8 @@ static int handle_elif(struct stream * stream, struct token **line, struct token
return 1;
}
+ DEPCALL(else_dep,token);
+
dirty_stream(stream);
if (token_type(top_if) != TOKEN_IF)
return 1;
@@ -1407,6 +1432,9 @@ static int handle_else(struct stream *stream, struct token **line, struct token
nesting_error(stream);
sparse_error(token->pos, "#else after #else");
}
+
+ DEPCALL(else_dep,token);
+
if (false_nesting) {
if (token_type(top_if) == TOKEN_IF)
false_nesting = 0;
@@ -1428,6 +1456,9 @@ static int handle_endif(struct stream *stream, struct token **line, struct token
}
if (false_nesting)
false_nesting--;
+
+ DEPCALL(pop_dep,token);
+
stream->top_if = top_if->next;
__free_token(top_if);
return 1;
@@ -1740,7 +1771,7 @@ static void handle_preprocessor_line(struct stream *stream, struct token **line,
int is_normal = 1;
if (eof_token(token))
- return;
+ goto ret;
if (token_type(token) == TOKEN_IDENT) {
struct symbol *sym = lookup_symbol(token->ident, NS_PREPROCESSOR);
@@ -1762,10 +1793,12 @@ static void handle_preprocessor_line(struct stream *stream, struct token **line,
goto out;
}
if (!handler(stream, line, token)) /* all set */
- return;
+ goto ret;
out:
free_preprocessor_line(token);
+ret:
+ DEPCALL(off, token);
}
static void preprocessor_line(struct stream *stream, struct token **line)
@@ -1817,6 +1850,7 @@ static void do_preprocess(struct token **list)
default:
dirty_stream(stream);
+ DEPCALL(tag_dep, next);
if (false_nesting) {
*list = next->next;
__free_token(next);
diff --git a/shrink.c b/shrink.c
new file mode 100644
index 0000000..b7a4404
--- /dev/null
+++ b/shrink.c
@@ -0,0 +1,102 @@
+/*
+ * Build macros dependency tree
+ * Copyright (C) 2012 Konrad Eisele <konrad@xxxxxxxxxxx,eiselekd@xxxxxxxxx>
+ * BSD-License
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the <organization>. The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ */
+
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include "lib.h"
+#include "allocate.h"
+#include "token.h"
+#include "parse.h"
+#include "symbol.h"
+#include "expression.h"
+#include "depend.h"
+
+void stream_print_line(FILE *io, struct stream *stream, int j);
+
+static void
+expand_symbols(struct symbol_list *list)
+{
+ struct symbol *sym;
+ FOR_EACH_PTR(list, sym) {
+ expand_symbol(sym);
+ depend_symbol(sym);
+ } END_FOR_EACH_PTR(sym);
+}
+
+int
+main(int argc, char **argv)
+{
+ struct string_list *filelist = NULL; int i;
+ char *file; struct symbol_list *all_syms = 0;
+
+ init_dep();
+
+ expand_symbols(sparse_initialize(argc, argv, &filelist));
+ FOR_EACH_PTR_NOTAG(filelist, file) {
+ struct symbol_list *syms = sparse(file);
+ expand_symbols(syms);
+ concat_symbol_list(syms, &all_syms);
+ } END_FOR_EACH_PTR_NOTAG(file);
+
+ for (i = 0; i < input_stream_nr; i++) {
+ /* struct stream *c; int j; */
+ /* c = input_streams + i; */
+ /* if (c->n && c->b) { */
+ /* for (j = 0; j < c->linenr; j++) { */
+ /* struct stream_line *l = c->n[j]; */
+ /* if (l->used) { */
+ /* stream_print_line(stdout, c, j); */
+ /* } */
+ /* } */
+ /* } */
+
+ }
+
+ return 0;
+}
+
+/* void */
+/* stream_print_line(FILE *io, struct stream *stream, int j) */
+/* { */
+/* int k; */
+/* if (stream->b && j < stream->linenr) { */
+/* struct stream_line *l = stream->n[j]; */
+/* int f, t, len; */
+/* f = t = l->off; */
+/* if (j+1 < stream->linenr && */
+/* stream->n[j+1] && */
+/* stream->n[j+1]->off > t) { */
+/* t = stream->n[j+1]->off; */
+/* } */
+/* if (f > stream->bz) */
+/* f = stream->bz; */
+/* if (t > stream->bz) */
+/* t = stream->bz; */
+/* len = t - f; */
+/* /\*fprintf(io, "%s:%04d:",stream->name,j);*\/ */
+/* for (k = 0; k < len; k++) { */
+/* fprintf(io, "%c", stream->b[f + k]); */
+/* } */
+/* /\*fprintf(io, "\n");*\/ */
+/* } */
+/* } */
diff --git a/sparse.c b/sparse.c
index 67b7d9e..ffdd8d4 100644
--- a/sparse.c
+++ b/sparse.c
@@ -23,6 +23,7 @@
#include "symbol.h"
#include "expression.h"
#include "linearize.h"
+#include "depend.h"
static int context_increase(struct basic_block *bb, int entry)
{
@@ -278,6 +279,8 @@ int main(int argc, char **argv)
struct string_list *filelist = NULL;
char *file;
+ init_dep();
+
// Expand, linearize and show it.
check_symbols(sparse_initialize(argc, argv, &filelist));
FOR_EACH_PTR_NOTAG(filelist, file) {
diff --git a/symbol.h b/symbol.h
index 1e74579..e7dcb82 100644
--- a/symbol.h
+++ b/symbol.h
@@ -11,6 +11,7 @@
#include "token.h"
#include "target.h"
+#include "depend.h"
/*
* An identifier with semantic meaning is a "symbol".
@@ -94,6 +95,7 @@ struct decl_state {
struct ident **ident;
struct symbol_op *mode;
unsigned char prefer_abstract, is_inline, storage_class, is_tls;
+ struct symbol_list *dep;
};
struct symbol_op {
@@ -294,6 +296,13 @@ extern void debug_symbol(struct symbol *);
extern void merge_type(struct symbol *sym, struct symbol *base_type);
extern void check_declaration(struct symbol *sym);
+static inline struct symbol *alloc_symbol_tok(struct token *tok, int type)
+{
+ struct symbol *e = alloc_symbol (tok->pos, type);
+ DEP_TOK(e, tok);
+ return e;
+}
+
static inline struct symbol *get_base_type(const struct symbol *sym)
{
return examine_symbol_type(sym->ctype.base_type);
diff --git a/token.h b/token.h
index cd29233..00518e5 100644
--- a/token.h
+++ b/token.h
@@ -152,6 +152,15 @@ struct argcount {
unsigned vararg:1;
};
+struct arg {
+ struct token *arg;
+ struct token *expanded;
+ struct token *str;
+ int n_normal;
+ int n_quoted;
+ int n_str;
+};
+
/*
* This is a very common data structure, it should be kept
* as small as humanly possible. Big (rare) types go as
@@ -203,6 +212,7 @@ extern struct token * tokenize_buffer(void *, unsigned long, struct token **);
extern void show_identifier_stats(void);
extern struct token *preprocess(struct token *);
+extern struct depend_if *dif;
static inline int match_op(struct token *token, int op)
{
--
1.7.4.4
--
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
