mob
16
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Kirill Smelkov
|
75118780da |
tccrun: Mark argv area as valid for bcheck
On my x86_64 box in i386 mode with address space randomization turned off,
I've observed the following:
tests$ ../tcc -B.. -b -run boundtest.c 1
Runtime error: dereferencing invalid pointer
boundtest.c:222: at 0x808da73 main()
With diagnostic patch (like in
|
||
|
Kirill Smelkov
|
63193d1794 |
Optimize vswap()
vswap() is called often enough and shows in profile and it was easy to
hand optimize swapping vtop[-1] and vtop[0] - instead of large (28 bytes
on i386) tmp variable and two memory to memory copies, let's swap areas
by longs through registers with streamlined assembly.
For
$ ./tcc -B. -bench -DONE_SOURCE -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" -c tcc.c
before:
# Overhead Command Shared Object Symbol
# ........ ........... ................... ..............................................
#
15.19% tcc tcc [.] next_nomacro1
5.19% tcc libc-2.13.so [.] _int_malloc
4.57% tcc tcc [.] next
3.36% tcc tcc [.] tok_str_add2
3.03% tcc tcc [.] macro_subst_tok
2.93% tcc tcc [.] macro_subst
2.53% tcc tcc [.] next_nomacro_spc
2.49% tcc tcc [.] vswap
2.36% tcc libc-2.13.so [.] _int_free
│ ST_FUNC void vswap(void)
│ {
1,96 │ push %edi
2,65 │ push %esi
1,08 │ sub $0x20,%esp
│ SValue tmp;
│
│ /* cannot let cpu flags if other instruction are generated. Also
│ avoid leaving VT_JMP anywhere except on the top of the stack
│ because it would complicate the code generator. */
│ if (vtop >= vstack) {
0,98 │ mov 0x8078cac,%eax
│ cmp $0x8078d3c,%eax
1,18 │ ┌──jb 24
│ │ int v = vtop->r & VT_VALMASK;
1,08 │ │ mov 0x8(%eax),%edx
0,78 │ │ and $0x3f,%edx
│ │ if (v == VT_CMP || (v & ~1) == VT_JMP)
0,78 │ │ cmp $0x33,%edx
0,69 │ │↓ je 54
0,59 │ │ and $0xfffffffe,%edx
0,49 │ │ cmp $0x34,%edx
0,29 │ │↓ je 54
│ │ gv(RC_INT);
│ │ }
│ │ tmp = vtop[0];
1,08 │24:└─→lea 0x4(%esp),%edi
0,39 │ mov $0x7,%ecx
│ mov %eax,%esi
14,41 │ rep movsl %ds:(%esi),%es:(%edi)
│ vtop[0] = vtop[-1];
9,51 │ lea -0x1c(%eax),%esi
1,96 │ mov $0x7,%cl
│ mov %eax,%edi
17,06 │ rep movsl %ds:(%esi),%es:(%edi)
│ vtop[-1] = tmp;
10,20 │ mov 0x8078cac,%edi
2,35 │ sub $0x1c,%edi
0,78 │ lea 0x4(%esp),%esi
│ mov $0x7,%cl
15,20 │ rep movsl %ds:(%esi),%es:(%edi)
│ }
9,90 │ add $0x20,%esp
2,25 │ pop %esi
1,67 │ pop %edi
0,69 │ ret
after:
# Overhead Command Shared Object Symbol
# ........ ........... ................... ..............................................
#
15.27% tcc tcc [.] next_nomacro1
5.08% tcc libc-2.13.so [.] _int_malloc
4.57% tcc tcc [.] next
3.17% tcc tcc [.] tok_str_add2
3.12% tcc tcc [.] macro_subst
2.99% tcc tcc [.] macro_subst_tok
2.43% tcc tcc [.] next_nomacro_spc
2.32% tcc libc-2.13.so [.] _int_free
. . .
0.71% tcc tcc [.] vswap
│ ST_FUNC void vswap(void)
│ {
7,22 │ push %eax
│ /* cannot let cpu flags if other instruction are generated. Also
│ avoid leaving VT_JMP anywhere except on the top of the stack
│ because it would complicate the code generator. */
│ if (vtop >= vstack) {
11,34 │ mov 0x8078cac,%eax
2,75 │ cmp $0x8078d3c,%eax
0,34 │ ┌──jb 20
│ │ int v = vtop->r & VT_VALMASK;
0,34 │ │ mov 0x8(%eax),%edx
8,93 │ │ and $0x3f,%edx
│ │ if (v == VT_CMP || (v & ~1) == VT_JMP)
2,06 │ │ cmp $0x33,%edx
2,41 │ │↓ je 74
2,41 │ │ and $0xfffffffe,%edx
0,34 │ │ cmp $0x34,%edx
2,41 │ │↓ je 74
│ │ vtopl[-1*VSIZEL + i] = tmpl; \
│ │ } do {} while (0)
│ │
│ │ VSWAPL(15); VSWAPL(14); VSWAPL(13); VSWAPL(12);
│ │ VSWAPL(11); VSWAPL(10); VSWAPL( 9); VSWAPL( 8);
│ │ VSWAPL( 7); VSWAPL( 6); VSWAPL( 5); VSWAPL( 4);
2,06 │20:└─→mov 0x18(%eax),%edx
1,37 │ mov -0x4(%eax),%ecx
2,06 │ mov %ecx,0x18(%eax)
1,37 │ mov %edx,-0x4(%eax)
2,06 │ mov 0x14(%eax),%edx
2,06 │ mov -0x8(%eax),%ecx
2,41 │ mov %ecx,0x14(%eax)
3,09 │ mov %edx,-0x8(%eax)
3,09 │ mov 0x10(%eax),%edx
1,72 │ mov -0xc(%eax),%ecx
2,75 │ mov %ecx,0x10(%eax)
1,72 │ mov %edx,-0xc(%eax)
│ VSWAPL( 3); VSWAPL( 2); VSWAPL( 1); VSWAPL( 0);
2,41 │ mov 0xc(%eax),%edx
2,41 │ mov -0x10(%eax),%ecx
2,41 │ mov %ecx,0xc(%eax)
0,69 │ mov %edx,-0x10(%eax)
1,72 │ mov 0x8(%eax),%edx
0,69 │ mov -0x14(%eax),%ecx
1,03 │ mov %ecx,0x8(%eax)
1,37 │ mov %edx,-0x14(%eax)
1,37 │ mov 0x4(%eax),%edx
0,69 │ mov -0x18(%eax),%ecx
3,09 │ mov %ecx,0x4(%eax)
2,06 │ mov %edx,-0x18(%eax)
1,37 │ mov (%eax),%edx
2,41 │ mov -0x1c(%eax),%ecx
1,37 │ mov %ecx,(%eax)
4,12 │ mov %edx,-0x1c(%eax)
│ }
│
│ # undef VSWAPL
│ # undef VSIZEL
│ }
1,03 │ pop %eax
3,44 │ ret
Overal speedup:
# best of 5 runs
before: 8268 idents, 47203 lines, 1526763 bytes, 0.148 s, 319217 lines/s, 10.3 MB/s
after: 8273 idents, 47231 lines, 1527685 bytes, 0.146 s, 324092 lines/s, 10.5 MB/s
Static ASSERT macro taken from CCAN's[1] build_assert[2] which is in
public domain.
[1] http://ccodearchive.net/
[2] http://git.ozlabs.org/?p=ccan;a=blob;f=ccan/build_assert/build_assert.h;h=24e59c44cd930173178ac9b6e101b0af64a879e9;hb=HEAD
|
||
|
Kirill Smelkov
|
8eb92e6052 |
Optimize cstr_reset() to only reset string to empty, not call free() and later malloc()
A CString could be reset to empty just setting its .size to 0.
If memory was already allocated, that would be remembered in
.data_allocated and .size_allocated and on consequent string
manipulations that memory will be used without immediate need to call
malloc().
For
$ ./tcc -B. -bench -DONE_SOURCE -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" -c tcc.c
after the patch malloc/free are called less often:
(tcc is run in loop; perf record -a sleep 10 && perf report)
before:
# Overhead Command Shared Object Symbol
# ........ ........... .................. ..........................................
#
13.89% tcc tcc [.] next_nomacro1
4.73% tcc libc-2.13.so [.] _int_malloc
4.39% tcc tcc [.] next
2.94% tcc tcc [.] tok_str_add2
2.78% tcc tcc [.] macro_subst_tok
2.75% tcc libc-2.13.so [.] free
2.74% tcc tcc [.] macro_subst
2.63% tcc libc-2.13.so [.] _int_free
2.28% tcc tcc [.] vswap
2.24% tcc tcc [.] next_nomacro_spc
2.06% tcc libc-2.13.so [.] realloc
2.00% tcc libc-2.13.so [.] malloc
1.99% tcc tcc [.] unary
1.85% tcc libc-2.13.so [.] __i686.get_pc_thunk.bx
1.76% kworker/0:1 [kernel.kallsyms] [k] delay_tsc
1.70% tcc tcc [.] next_nomacro
1.62% tcc tcc [.] preprocess
1.41% tcc libc-2.13.so [.] __memcmp_ssse3
1.38% tcc [kernel.kallsyms] [k] memset
1.10% tcc tcc [.] g
1.06% tcc tcc [.] parse_btype
1.05% tcc tcc [.] sym_push2
1.04% tcc libc-2.13.so [.] _int_realloc
1.00% tcc libc-2.13.so [.] malloc_consolidate
after:
# Overhead Command Shared Object Symbol
# ........ ........... .................. ..............................................
#
15.26% tcc tcc [.] next_nomacro1
5.07% tcc libc-2.13.so [.] _int_malloc
4.62% tcc tcc [.] next
3.22% tcc tcc [.] tok_str_add2
3.03% tcc tcc [.] macro_subst_tok
3.02% tcc tcc [.] macro_subst
2.59% tcc tcc [.] next_nomacro_spc
2.44% tcc tcc [.] vswap
2.39% tcc libc-2.13.so [.] _int_free
2.28% tcc libc-2.13.so [.] free
2.22% tcc tcc [.] unary
2.07% tcc libc-2.13.so [.] realloc
1.97% tcc libc-2.13.so [.] malloc
1.70% tcc tcc [.] preprocess
1.69% tcc libc-2.13.so [.] __i686.get_pc_thunk.bx
1.68% tcc tcc [.] next_nomacro
1.59% tcc [kernel.kallsyms] [k] memset
1.55% tcc libc-2.13.so [.] __memcmp_ssse3
1.22% tcc tcc [.] parse_comment
1.11% tcc tcc [.] g
1.11% tcc tcc [.] sym_push2
1.10% tcc tcc [.] parse_btype
1.10% tcc libc-2.13.so [.] _int_realloc
1.06% tcc tcc [.] vsetc
0.98% tcc libc-2.13.so [.] malloc_consolidate
and this gains small speedup for tcc:
# best of 5 runs
before: 8268 idents, 47191 lines, 1526670 bytes, 0.153 s, 307997 lines/s, 10.0 MB/s
after: 8268 idents, 47203 lines, 1526763 bytes, 0.148 s, 319217 lines/s, 10.3 MB/s
|
||
|
Kirill Smelkov
|
a55ecf6d2c |
Repair bounds-checking more, this time tcc -b -run tcc.c -run tcc.c -run tcctest.c works
Hello up there. On the list Grischka made a point that we can't recommend using -b as long as tcc -b tcc.c doesn't produce anything useful. Now it does, so please don't treat -b mode as second class citizen anymore. Thanks, Kirill * bcheck2: tests: Add tests for compile/run tcc.c with `tcc -b` then compile tcc.c again, then run tcctest.c lib/bcheck: Fix code typo in __bound_delete_region() lib/bcheck: Don't assume heap goes right after bss Make tcc work after self-compiling with bounds-check enabled |
||
|
Kirill Smelkov
|
031ff872be |
tests: Add tests for compile/run tcc.c with tcc -b then compile tcc.c again, then run tcctest.c
Just like with test[123] add their test[123]b variants. After previous 3 patchs all test pass here on Debian GNU/Linux on i385 with gcc-4.7 with or without memory randomization turned on. |
||
|
Kirill Smelkov
|
dbeb4faf21 |
lib/bcheck: Fix code typo in __bound_delete_region()
We were calling get_page() with t2 index which is not correct, since
get_page() operate on t1 indices. The bug is here from day-1, from
|
||
|
Kirill Smelkov
|
efd9d92b7c |
lib/bcheck: Don't assume heap goes right after bss
At startup __bound_init() wants to mark malloc zone as invalid memory,
so that any access to memory on heap, not allocated through malloc be
invalid. Other pages are initialized as empty regions, access to which
is not treated as invalid by bounds-checking.
The problem is code incorrectly assumed that heap goes right after bss,
and that is not correct for two cases:
1) if we are running from `tcc -b -run`, program text data and bss
will be already in malloced memory, possibly in mmaped region
insead of heap, and marking memory as invalid from _end
will not cover heap and probably wrongly mark correct regions.
2) if address space randomization is turned on, again heap does not
start from _end, and we'll mark as invalid something else instead
of malloc area.
For example with the following diagnostic patch ...
diff --git a/tcc.c b/tcc.c
index 5dd5725..31c46e8 100644
--- a/tcc.c
+++ b/tcc.c
@@ -479,6 +479,8 @@ static int parse_args(TCCState *s, int argc, char **argv)
return optind;
}
+extern int _etext, _edata, _end;
+
int main(int argc, char **argv)
{
int i;
@@ -487,6 +489,18 @@ int main(int argc, char **argv)
int64_t start_time = 0;
const char *default_file = NULL;
+ void *brk;
+
+ brk = sbrk(0);
+
+ fprintf(stderr, "\n>>> TCC\n\n");
+ fprintf(stderr, "etext:\t%10p\n", &_etext);
+ fprintf(stderr, "edata:\t%10p\n", &_edata);
+ fprintf(stderr, "end:\t%10p\n", &_end);
+ fprintf(stderr, "brk:\t%10p\n", brk);
+ fprintf(stderr, "stack:\t%10p\n", &brk);
+
+ fprintf(stderr, "&errno: %p\n", &errno);
s = tcc_new();
output_type = TCC_OUTPUT_EXE;
diff --git a/tccrun.c b/tccrun.c
index 531f46a..25ed30a 100644
--- a/tccrun.c
+++ b/tccrun.c
@@ -91,6 +91,8 @@ LIBTCCAPI int tcc_run(TCCState *s1, int argc, char **argv)
int (*prog_main)(int, char **);
int ret;
+ fprintf(stderr, "\n\ntcc_run() ...\n\n");
+
if (tcc_relocate(s1, TCC_RELOCATE_AUTO) < 0)
return -1;
diff --git a/lib/bcheck.c b/lib/bcheck.c
index ea5b233..8b26a5f 100644
--- a/lib/bcheck.c
+++ b/lib/bcheck.c
@@ -296,6 +326,8 @@ static void mark_invalid(unsigned long addr, unsigned long size)
start = addr;
end = addr + size;
+ fprintf(stderr, "mark_invalid %10p - %10p\n", (void *)addr, (void *)end);
+
t2_start = (start + BOUND_T3_SIZE - 1) >> BOUND_T3_BITS;
if (end != 0)
t2_end = end >> BOUND_T3_BITS;
... Look how memory is laid out for `tcc -b -run ...`:
$ ./tcc -B. -b -DTCC_TARGET_I386 -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" -run \
-DONE_SOURCE ./tcc.c -B. -c x.c
>>> TCC
etext: 0x8065477
edata: 0x8070220
end: 0x807a95c
brk: 0x807b000
stack: 0xaffff0f0
&errno: 0xa7e25688
tcc_run() ...
mark_invalid 0xfff80000 - (nil)
mark_invalid 0xa7c31d98 - 0xafc31d98
>>> TCC
etext: 0xa7c22767
edata: 0xa7c2759c
end: 0xa7c31d98
brk: 0x8211000
stack: 0xafffeff0
&errno: 0xa7e25688
Runtime error: dereferencing invalid pointer
./tccpp.c:1953: at 0xa7beebdf parse_number() (included from ./libtcc.c, ./tcc.c)
./tccpp.c:3003: by 0xa7bf0708 next() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:4465: by 0xa7bfe348 block() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:4440: by 0xa7bfe212 block() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:5529: by 0xa7c01929 gen_function() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:5767: by 0xa7c02602 decl0() (included from ./libtcc.c, ./tcc.c)
The second mark_invalid goes right after in-memory-compiled program's
_end, and oops, that's not where malloc zone is (starts from brk), and oops
again, mark_invalid covers e.g. errno. Then compiled tcc is crasshing by
bcheck on errno access:
1776 static void parse_number(const char *p)
1777 {
1778 int b, t, shift, frac_bits, s, exp_val, ch;
...
1951 *q = '\0';
1952 t = toup(ch);
1953 errno = 0;
The solution here is to use sbrk(0) as approximation for the program
break start instead of &_end:
- if we are a separately compiled program, __bound_init() runs early,
and sbrk(0) should be equal or very near to start_brk (in case other
constructors malloc something), or
- if we are running from under `tcc -b -run`, sbrk(0) will return
start of heap portion which is under this program control, and not
mark as invalid earlier allocated memory.
With this patch `tcc -b -run tcc.c ...` succeeds compiling above
small-test program (diagnostic patch is still applied too):
$ ./tcc -B. -b -DTCC_TARGET_I386 -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" -run \
-DONE_SOURCE ./tcc.c -B. -c x.c
>>> TCC
etext: 0x8065477
edata: 0x8070220
end: 0x807a95c
brk: 0x807b000
stack: 0xaffff0f0
&errno: 0xa7e25688
tcc_run() ...
mark_invalid 0xfff80000 - (nil)
mark_invalid 0x8211000 - 0x10211000
>>> TCC
etext: 0xa7c22777
edata: 0xa7c275ac
end: 0xa7c31da8
brk: 0x8211000
stack: 0xafffeff0
&errno: 0xa7e25688
(completes ok)
but running `tcc -b -run tcc.c -run tests/tcctest.c` sigsegv's - that's
the plot for the next patch.
|
||
|
Kirill Smelkov
|
43a11a7ed1 |
Make tcc work after self-compiling with bounds-check enabled
For vstack Fabrice used the trick to initialize vtop to &vstack[-1], so
that on first push, vtop becomes &vstack[0] and a value is also stored
there - everything works.
Except that when tcc is compiled with bounds-checking enabled, vstack - 1
returns INVALID_POINTER and oops...
Let's workaround it with artificial 1 vstack slot which will not be
used, but only serve as an indicator that pointing to &vstack[-1] is ok.
Now, tcc, after being self-compiled with -b works:
$ ./tcc -B. -o tccb -DONE_SOURCE -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" tcc.c -ldl
$ cd tests
$ ../tcc -B.. -run tcctest.c >1
$ ../tccb -B.. -run tcctest.c >2
$ diff -u 1 2
and note, tcc's compilation speed is not affected:
$ ./tcc -B. -bench -DONE_SOURCE -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" -c tcc.c
before: 8270 idents, 47221 lines, 1527730 bytes, 0.152 s, 309800 lines/s, 10.0 MB/s
after: 8271 idents, 47221 lines, 1527733 bytes, 0.152 s, 310107 lines/s, 10.0 MB/s
But note, that `tcc -b -run tcc` is still broken - for example it crashes
on
$ cat x.c
double get100 () { return 100.0; }
$ ./tcc -B. -b -DTCC_TARGET_I386 -DCONFIG_MULTIARCHDIR=\"i386-linux-gnu\" -run \
-DONE_SOURCE ./tcc.c -B. -c x.c
Runtime error: dereferencing invalid pointer
./tccpp.c:1953: at 0xa7beebdf parse_number() (included from ./libtcc.c, ./tcc.c)
./tccpp.c:3003: by 0xa7bf0708 next() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:4465: by 0xa7bfe348 block() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:4440: by 0xa7bfe212 block() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:5529: by 0xa7c01929 gen_function() (included from ./libtcc.c, ./tcc.c)
./tccgen.c:5767: by 0xa7c02602 decl0() (included from ./libtcc.c, ./tcc.c)
that's because lib/bcheck.c runtime needs more fixes -- see next
patches.
|
||
|
Kirill Smelkov
|
168aed4984 |
tests: btest should only run on targets supporting bcheck
After |
||
|
Kirill Smelkov
|
4744269494 |
Update .gitignore
The following files were not ignored (produced by build on i386 with
--enable-cross):
arm-eabi-tcc
arm-fpa-ld-tcc
arm-fpa-tcc
arm-vfp-tcc
c67-tcc
i386-win32-tcc
lib/i386-win32/
lib/x86_64-win32/
x86_64-tcc
x86_64-win32-tcc
|
||
|
Kirill Smelkov
|
ab24aaeca3 |
i386: We can change 'lea 0(%ebp),r' to 'mov %ebp,r'
Because that mov is 1 byte shorter, look:
int *func()
{
return __builtin_frame_address(0);
}
before patch:
00000000 <func>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 81 ec 00 00 00 00 sub $0x0,%esp
9: 8d 45 00 lea 0x0(%ebp),%eax // <- here
c: e9 00 00 00 00 jmp 11 <func+0x11>
11: c9 leave
12: c3 ret
after patch:
00000000 <func>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 81 ec 00 00 00 00 sub $0x0,%esp
9: 89 e8 mov %ebp,%eax // <- here
b: e9 00 00 00 00 jmp 10 <func+0x10>
10: c9 leave
11: c3 ret
|
||
|
Kirill Smelkov
|
b2a02961b4 |
Add support for __builtin_frame_address(level)
Continuing |
||
|
Kirill Smelkov
|
40a54c4399 |
Repair bounds-checking runtime
On this weekend a thought came to me again that tinycc could be used for scripting. Only its bounds-checking mode turned out to be broken, which is a pity because bounds-checking is sometimes handy especially for quickly written scripts. Since tinycc is one of those small beautiful things, seldomly happening in our times, I couldn't resist trying to fix it. Thanks, Kirill * bcheck: Now btest pass! lib/bcheck: Prevent __bound_local_new / __bound_local_delete from being miscompiled lib/bcheck: Prevent libc_malloc/libc_free etc from being miscompiled |
||
|
Kirill Smelkov
|
5d648485bd |
Now btest pass!
Thanks to two previous commits now btest tests pass, at least on Linux. Signed-off-by: Kirill Smelkov <kirr@navytux.spb.ru> |
||
|
Kirill Smelkov
|
cffb7af9f9 |
lib/bcheck: Prevent __bound_local_new / __bound_local_delete from being miscompiled
On i386 and gcc-4.7 I found that __bound_local_new was miscompiled -
look:
#ifdef __i386__
/* return the frame pointer of the caller */
#define GET_CALLER_FP(fp)\
{\
unsigned long *fp1;\
__asm__ __volatile__ ("movl %%ebp,%0" :"=g" (fp1));\
fp = fp1[0];\
}
#endif
/* called when entering a function to add all the local regions */
void FASTCALL __bound_local_new(void *p1)
{
unsigned long addr, size, fp, *p = p1;
GET_CALLER_FP(fp);
for(;;) {
addr = p[0];
if (addr == 0)
break;
addr += fp;
size = p[1];
p += 2;
__bound_new_region((void *)addr, size);
}
}
__bound_local_new:
.LFB40:
.cfi_startproc
pushl %esi
.cfi_def_cfa_offset 8
.cfi_offset 6, -8
pushl %ebx
.cfi_def_cfa_offset 12
.cfi_offset 3, -12
subl $8, %esp // NOTE prologue does not touch %ebp
.cfi_def_cfa_offset 20
#APP
# 235 "lib/bcheck.c" 1
movl %ebp,%edx // %ebp -> fp1
# 0 "" 2
#NO_APP
movl (%edx), %esi // fp1[0] -> fp
movl (%eax), %edx
movl %eax, %ebx
testl %edx, %edx
je .L167
.p2align 2,,3
.L173:
movl 4(%ebx), %eax
addl $8, %ebx
movl %eax, 4(%esp)
addl %esi, %edx
movl %edx, (%esp)
call __bound_new_region
movl (%ebx), %edx
testl %edx, %edx
jne .L173
.L167:
addl $8, %esp
.cfi_def_cfa_offset 12
popl %ebx
.cfi_restore 3
.cfi_def_cfa_offset 8
popl %esi
.cfi_restore 6
.cfi_def_cfa_offset 4
ret
here GET_CALLER_FP() assumed that its using function setups it's stack
frame, i.e. first save, then set %ebp to stack frame start, and then it
has to do perform two lookups: 1) to get current stack frame through
%ebp, and 2) get caller stack frame through (%ebp).
And here is the problem: gcc decided not to setup %ebp for
__bound_local_new and in such case GET_CALLER_FP actually becomes
GET_CALLER_CALLER_FP and oops, wrong regions are registered in bcheck
tables...
The solution is to stop using hand written assembly and rely on gcc's
__builtin_frame_address(1) to get callers frame stack(*). I think for the
builtin gcc should generate correct code, independent of whether it
decides or not to omit frame pointer in using function - it knows it.
(*) judging by gcc history, __builtin_frame_address was there almost
from the beginning - at least it is present in 1992 as seen from the
following commit:
http://gcc.gnu.org/git/?p=gcc.git;a=commit;h=be07f7bdbac76d87d3006c89855491504d5d6202
so we can rely on it being supported by all versions of gcc.
In my environment the assembly of __bound_local_new changes as follows:
diff --git a/bcheck0.s b/bcheck1.s
index 4c02a5f..ef68918 100644
--- a/bcheck0.s
+++ b/bcheck1.s
@@ -1409,20 +1409,17 @@ __bound_init:
__bound_local_new:
.LFB40:
.cfi_startproc
- pushl %esi
+ pushl %ebp // NOTE prologue saves %ebp ...
.cfi_def_cfa_offset 8
- .cfi_offset 6, -8
+ .cfi_offset 5, -8
+ movl %esp, %ebp // ... and reset it to local stack frame
+ .cfi_def_cfa_register 5
+ pushl %esi
pushl %ebx
- .cfi_def_cfa_offset 12
- .cfi_offset 3, -12
subl $8, %esp
- .cfi_def_cfa_offset 20
-#APP
-# 235 "lib/bcheck.c" 1
- movl %ebp,%edx
-# 0 "" 2
-#NO_APP
- movl (%edx), %esi
+ .cfi_offset 6, -12
+ .cfi_offset 3, -16
+ movl 0(%ebp), %esi // stkframe -> stkframe.parent -> fp
movl (%eax), %edx
movl %eax, %ebx
testl %edx, %edx
@@ -1440,13 +1437,13 @@ __bound_local_new:
jne .L173
.L167:
addl $8, %esp
- .cfi_def_cfa_offset 12
popl %ebx
.cfi_restore 3
- .cfi_def_cfa_offset 8
popl %esi
.cfi_restore 6
- .cfi_def_cfa_offset 4
+ popl %ebp
+ .cfi_restore 5
+ .cfi_def_cfa 4, 4
ret
.cfi_endproc
i.e. now it compiles correctly.
Though I do not have x86_64 to test, my guess is that
__builtin_frame_address(1) should work there too. If not - please revert
only x86_64 part of the patch. Thanks.
Cc: Michael Matz <matz@suse.de>
|
||
|
Kirill Smelkov
|
646b51833f |
lib/bcheck: Prevent libc_malloc/libc_free etc from being miscompiled
On i386 and gcc-4.7 I found that libc_malloc was miscompiled - look:
static void *libc_malloc(size_t size)
{
void *ptr;
restore_malloc_hooks(); // __malloc_hook = saved_malloc_hook
ptr = malloc(size);
install_malloc_hooks(); // saved_malloc_hook = __malloc_hook, __malloc_hook = __bound_malloc
return ptr;
}
.type libc_malloc, @function
libc_malloc:
.LFB56:
.cfi_startproc
pushl %edx
.cfi_def_cfa_offset 8
movl %eax, (%esp)
call malloc
movl $__bound_malloc, __malloc_hook
movl $__bound_free, __free_hook
movl $__bound_realloc, __realloc_hook
movl $__bound_memalign, __memalign_hook
popl %ecx
.cfi_def_cfa_offset 4
ret
Here gcc inlined both restore_malloc_hooks() and install_malloc_hooks()
and decided that
saved_malloc_hook -> __malloc_hook -> saved_malloc_hook
stores are not needed and could be ommitted. Only it did not know
__molloc_hook affects malloc()...
So add compiler barrier to both install and restore hooks functions and
be done with it - the code is now ok:
diff --git a/bcheck0.s b/bcheck1.s
index 5f50293..4c02a5f 100644
--- a/bcheck0.s
+++ b/bcheck1.s
@@ -42,8 +42,24 @@ libc_malloc:
.cfi_startproc
pushl %edx
.cfi_def_cfa_offset 8
+ movl saved_malloc_hook, %edx
+ movl %edx, __malloc_hook
+ movl saved_free_hook, %edx
+ movl %edx, __free_hook
+ movl saved_realloc_hook, %edx
+ movl %edx, __realloc_hook
+ movl saved_memalign_hook, %edx
+ movl %edx, __memalign_hook
movl %eax, (%esp)
call malloc
+ movl __malloc_hook, %edx
+ movl %edx, saved_malloc_hook
+ movl __free_hook, %edx
+ movl %edx, saved_free_hook
+ movl __realloc_hook, %edx
+ movl %edx, saved_realloc_hook
+ movl __memalign_hook, %edx
+ movl %edx, saved_memalign_hook
movl $__bound_malloc, __malloc_hook
movl $__bound_free, __free_hook
movl $__bound_realloc, __realloc_hook
For barrier I use
__asm__ __volatile__ ("": : : "memory")
which is used as compiler barrier by Linux kernel, and mentioned in gcc
docs and in wikipedia [1].
Without this patch any program compiled with tcc -b crashes in startup
because of infinite recursion in libc_malloc.
[1] http://en.wikipedia.org/wiki/Memory_ordering#Compiler_memory_barrier
|