emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

bc: shrink "dc only" code by dropping unused structure members

Browse Source 
function                                             old     new   delta
zbc_program_num                                      979     981      +2
zbc_program_pushArray                                147     145      -2
bc_program_pushVar                                   198     196      -2
bc_program_func                                       17      15      -2
dc_num_printChar                                      24      21      -3
bc_program_retire                                     35      32      -3
bc_program_binOpRetire                                46      43      -3
zdc_program_printStream                              153     148      -5
zbc_program_prep                                      91      86      -5
zbc_program_copyToVar                                300     295      -5
zdc_program_modexp                                   721     715      -6
zbc_program_binOpPrep                                311     305      -6
bc_program_addFunc                                   138     132      -6
bc_num_printNewline                                   51      45      -6
bc_num_printHex                                       67      61      -6
bc_num_printDigits                                   137     131      -6
zdc_program_assignStr                                146     137      -9
bc_program_reset                                      64      55      -9
bc_func_free                                          27       5     -22
bc_parse_free                                         38       8     -30
bc_parse_create                                       92      47     -45
bc_func_init                                          50       5     -45
dc_main                                              691     645     -46
zdc_program_execStr                                  496     442     -54
zbc_program_print                                    677     623     -54
zbc_vm_process                                       204     137     -67
zbc_program_exec                                    4132    4057     -75
------------------------------------------------------------------------------
(add/remove: 0/0 grow/shrink: 1/26 up/down: 2/-522)          Total: -520 bytes
   text	   data	    bss	    dec	    hex	filename
 969767	    485	   7296	 977548	  eea8c	busybox_old
 969210	    485	   7296	 976991	  ee85f	busybox_unstripped

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko 2018-12-20 16:24:18 +01:00
parent eaa3b00002
commit 503faf9d53
1 changed files with 46 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
miscutils/bc.c
View File

@ -348,9 +348,9 @@ typedef struct BcId {
typedef struct BcFunc { typedef struct BcFunc {
BcVec code; BcVec code;
BcVec labels; IF_BC(BcVec labels;)
size_t nparams; IF_BC(BcVec autos;)
BcVec autos; IF_BC(size_t nparams;)
} BcFunc; } BcFunc;
typedef enum BcResultType { typedef enum BcResultType {
@ -385,7 +385,7 @@ typedef struct BcResult {
typedef struct BcInstPtr { typedef struct BcInstPtr {
size_t func; size_t func;
size_t idx; size_t idx;
size_t len; IF_BC(size_t len;)
} BcInstPtr; } BcInstPtr;
// BC_LEX_NEG is not used in lexing; it is only for parsing. // BC_LEX_NEG is not used in lexing; it is only for parsing.
@ -664,30 +664,29 @@ typedef struct BcLex {
typedef struct BcParse { typedef struct BcParse {
BcLex l; BcLex l;
BcVec exits; IF_BC(BcVec exits;)
BcVec conds; IF_BC(BcVec conds;)
IF_BC(BcVec ops;)
BcVec ops;
BcFunc *func; BcFunc *func;
size_t fidx; size_t fidx;
size_t in_funcdef; IF_BC(size_t in_funcdef;)
} BcParse; } BcParse;
typedef struct BcProgram { typedef struct BcProgram {
size_t len; size_t len;
size_t scale; size_t nchars;
size_t scale;
size_t ib_t; size_t ib_t;
size_t ob_t; size_t ob_t;
BcNum ob;
BcVec results; BcVec results;
BcVec exestack; BcVec exestack;
BcVec fns; BcVec fns;
BcVec fn_map; BcVec fn_map; //TODO: dc does not need this, its 'functions' are anonynomous (have no names)
BcVec vars; BcVec vars;
BcVec var_map; BcVec var_map;
@ -700,11 +699,9 @@ typedef struct BcProgram {
const char *file; const char *file;
BcNum last;
BcNum zero; BcNum zero;
BcNum one; IF_BC(BcNum one;)
IF_BC(BcNum last;)
size_t nchars;
} BcProgram; } BcProgram;
#define BC_PROG_MAIN (0) #define BC_PROG_MAIN (0)
@ -1616,6 +1613,7 @@ static BC_STATUS zbc_num_shift(BcNum *n, size_t places)
static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale) static BC_STATUS zbc_num_inv(BcNum *a, BcNum *b, size_t scale)
{ {
//TODO: nice example of non-allocated BcNum, use in other places as well!
BcNum one; BcNum one;
BcDig num[2]; BcDig num[2];
@ -2527,17 +2525,17 @@ static BC_STATUS zbc_func_insert(BcFunc *f, char *name, bool var)
static void bc_func_init(BcFunc *f) static void bc_func_init(BcFunc *f)
{ {
bc_char_vec_init(&f->code); bc_char_vec_init(&f->code);
bc_vec_init(&f->autos, sizeof(BcId), bc_id_free); IF_BC(bc_vec_init(&f->labels, sizeof(size_t), NULL);)
bc_vec_init(&f->labels, sizeof(size_t), NULL); IF_BC(bc_vec_init(&f->autos, sizeof(BcId), bc_id_free);)
f->nparams = 0; IF_BC(f->nparams = 0;)
} }
static FAST_FUNC void bc_func_free(void *func) static FAST_FUNC void bc_func_free(void *func)
{ {
BcFunc *f = (BcFunc *) func; BcFunc *f = (BcFunc *) func;
bc_vec_free(&f->code); bc_vec_free(&f->code);
bc_vec_free(&f->autos); IF_BC(bc_vec_free(&f->labels);)
bc_vec_free(&f->labels); IF_BC(bc_vec_free(&f->autos);)
} }
static void bc_array_expand(BcVec *a, size_t len); static void bc_array_expand(BcVec *a, size_t len);
@ -3566,10 +3564,10 @@ static void bc_program_reset(void)
static void bc_parse_reset(BcParse *p) static void bc_parse_reset(BcParse *p)
{ {
if (p->fidx != BC_PROG_MAIN) { if (p->fidx != BC_PROG_MAIN) {
p->func->nparams = 0;
bc_vec_pop_all(&p->func->code); bc_vec_pop_all(&p->func->code);
bc_vec_pop_all(&p->func->autos); IF_BC(bc_vec_pop_all(&p->func->labels);)
bc_vec_pop_all(&p->func->labels); IF_BC(bc_vec_pop_all(&p->func->autos);)
IF_BC(p->func->nparams = 0;)
p->fidx = BC_PROG_MAIN; p->fidx = BC_PROG_MAIN;
p->func = bc_program_func_BC_PROG_MAIN(); p->func = bc_program_func_BC_PROG_MAIN();
@ -3578,18 +3576,18 @@ static void bc_parse_reset(BcParse *p)
p->l.i = p->l.len; p->l.i = p->l.len;
p->l.t.t = BC_LEX_EOF; p->l.t.t = BC_LEX_EOF;
bc_vec_pop_all(&p->exits); IF_BC(bc_vec_pop_all(&p->exits);)
bc_vec_pop_all(&p->conds); IF_BC(bc_vec_pop_all(&p->conds);)
bc_vec_pop_all(&p->ops); IF_BC(bc_vec_pop_all(&p->ops);)
bc_program_reset(); bc_program_reset();
} }
static void bc_parse_free(BcParse *p) static void bc_parse_free(BcParse *p)
{ {
bc_vec_free(&p->exits); IF_BC(bc_vec_free(&p->exits);)
bc_vec_free(&p->conds); IF_BC(bc_vec_free(&p->conds);)
bc_vec_free(&p->ops); IF_BC(bc_vec_free(&p->ops);)
bc_lex_free(&p->l); bc_lex_free(&p->l);
} }
@ -3598,9 +3596,9 @@ static void bc_parse_create(BcParse *p, size_t fidx)
memset(p, 0, sizeof(BcParse)); memset(p, 0, sizeof(BcParse));
bc_lex_init(&p->l); bc_lex_init(&p->l);
bc_vec_init(&p->exits, sizeof(size_t), NULL); IF_BC(bc_vec_init(&p->exits, sizeof(size_t), NULL);)
bc_vec_init(&p->conds, sizeof(size_t), NULL); IF_BC(bc_vec_init(&p->conds, sizeof(size_t), NULL);)
bc_vec_init(&p->ops, sizeof(BcLexType), NULL); IF_BC(bc_vec_init(&p->ops, sizeof(BcLexType), NULL);)
p->fidx = fidx; p->fidx = fidx;
p->func = bc_program_func(fidx); p->func = bc_program_func(fidx);
@ -5036,12 +5034,17 @@ static BC_STATUS zbc_program_num(BcResult *r, BcNum **num, bool hex)
*num = bc_vec_top(v); *num = bc_vec_top(v);
break; break;
} }
#if ENABLE_BC
case BC_RESULT_LAST: case BC_RESULT_LAST:
*num = &G.prog.last; *num = &G.prog.last;
break; break;
case BC_RESULT_ONE: case BC_RESULT_ONE:
*num = &G.prog.one; *num = &G.prog.one;
break; break;
#endif
default:
// Testing the theory that dc does not reach LAST/ONE
bb_error_msg_and_die("BUG:%d", r->t);
} }
RETURN_STATUS(BC_STATUS_SUCCESS); RETURN_STATUS(BC_STATUS_SUCCESS);
@ -5178,7 +5181,7 @@ static BC_STATUS zbc_program_read(void)
ip.func = BC_PROG_READ; ip.func = BC_PROG_READ;
ip.idx = 0; ip.idx = 0;
ip.len = G.prog.results.len; IF_BC(ip.len = G.prog.results.len;)
// Update this pointer, just in case. // Update this pointer, just in case.
f = bc_program_func(BC_PROG_READ); f = bc_program_func(BC_PROG_READ);
@ -5496,7 +5499,9 @@ static BC_STATUS zbc_program_print(char inst, size_t idx)
if (BC_PROG_NUM(r, num)) { if (BC_PROG_NUM(r, num)) {
s = zbc_num_print(num, !pop); s = zbc_num_print(num, !pop);
if (!s) bc_num_copy(&G.prog.last, num); #if ENABLE_BC
if (!s && IS_BC) bc_num_copy(&G.prog.last, num);
#endif
} else { } else {
char *str; char *str;
@ -6322,7 +6327,7 @@ static BC_STATUS zdc_program_execStr(char *code, size_t *bgn, bool cond)
} }
ip.idx = 0; ip.idx = 0;
ip.len = G.prog.results.len; IF_BC(ip.len = G.prog.results.len;)
ip.func = fidx; ip.func = fidx;
bc_vec_pop(&G.prog.results); bc_vec_pop(&G.prog.results);
@ -6977,7 +6982,7 @@ static void bc_program_free(void)
bc_vec_free(&G.prog.exestack); bc_vec_free(&G.prog.exestack);
bc_num_free(&G.prog.last); bc_num_free(&G.prog.last);
bc_num_free(&G.prog.zero); bc_num_free(&G.prog.zero);
bc_num_free(&G.prog.one); IF_BC(bc_num_free(&G.prog.one);)
bc_vec_free(&G.input_buffer); bc_vec_free(&G.input_buffer);
} }
@ -7001,14 +7006,14 @@ static void bc_program_init(void)
G.prog.ib_t = 10; G.prog.ib_t = 10;
G.prog.ob_t = 10; G.prog.ob_t = 10;
bc_num_init_DEF_SIZE(&G.prog.last); IF_BC(bc_num_init_DEF_SIZE(&G.prog.last);)
//bc_num_zero(&G.prog.last); - already is //IF_BC(bc_num_zero(&G.prog.last);) - already is
bc_num_init_DEF_SIZE(&G.prog.zero); bc_num_init_DEF_SIZE(&G.prog.zero);
//bc_num_zero(&G.prog.zero); - already is //bc_num_zero(&G.prog.zero); - already is
bc_num_init_DEF_SIZE(&G.prog.one); IF_BC(bc_num_init_DEF_SIZE(&G.prog.one);)
bc_num_one(&G.prog.one); IF_BC(bc_num_one(&G.prog.one);)
bc_vec_init(&G.prog.fns, sizeof(BcFunc), bc_func_free); bc_vec_init(&G.prog.fns, sizeof(BcFunc), bc_func_free);
bc_vec_init(&G.prog.fn_map, sizeof(BcId), bc_id_free); bc_vec_init(&G.prog.fn_map, sizeof(BcId), bc_id_free);