Go to:
Gentoo Home
Documentation
Forums
Lists
Bugs
Planet
Store
Wiki
Get Gentoo!
Gentoo's Bugzilla – Attachment 650644 Details for
Bug 730406
sys-kernel/genkernel-4.0.9-r1: Failed to create binpkg of boost-1.73.0: *** stack smashing detected ***: terminated
Home
|
New
–
[Ex]
|
Browse
|
Search
|
Privacy Policy
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
[x]
|
Forgot Password
Login:
[x]
gdb output
gdb.out (text/plain), 278.60 KB, created by
Jack
on 2020-07-24 22:12:39 UTC
(
hide
)
Description:
gdb output
Filename:
MIME Type:
Creator:
Jack
Created:
2020-07-24 22:12:39 UTC
Size:
278.60 KB
patch
obsolete
>GNU gdb (Gentoo 9.1 vanilla) 9.1 >Copyright (C) 2020 Free Software Foundation, Inc. >License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> >This is free software: you are free to change and redistribute it. >There is NO WARRANTY, to the extent permitted by law. >Type "show copying" and "show warranty" for details. >This GDB was configured as "x86_64-pc-linux-gnu". >Type "show configuration" for configuration details. >For bug reporting instructions, please see: ><https://bugs.gentoo.org/>. >Find the GDB manual and other documentation resources online at: > <http://www.gnu.org/software/gdb/documentation/>. > >For help, type "help". >Type "apropos word" to search for commands related to "word"... >Reading symbols from x86_64-pc-linux-gnu-g++... >Breakpoint 1 at 0x432a60: file /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/diagnostic.c, line 1706. >(gdb) b /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:667 >Make breakpoint pending on future shared library load? (y or [n]) y >Breakpoint 2 (/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:667) pending. >(gdb) r >Starting program: /usr/bin/x86_64-pc-linux-gnu-g++ -fvisibility-inlines-hidden -Os -pipe -fomit-frame-pointer -std=c++14 -fPIC -m64 -pthread -finline-functions -Wno-inline -Wall -fvisibility=hidden -DBOOST_ALL_DYN_LINK=1 -DBOOST_ALL_NO_LIB=1 -DNDEBUG -I. -c -o instantiate_predef_macros.o instantiate_predef_macros.cpp >[New inferior 2 (process 2237)] >[Inferior 1 (process 2232) detached] >process 2237 is executing new program: /usr/libexec/gcc/x86_64-pc-linux-gnu/10.1.0/cc1plus >[Switching to process 2237] > >Thread 2.1 "cc1plus" hit Breakpoint 2, cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:668 >668 { >(gdb) bt >#0 cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:668 >#1 0x00000000009f49fc in gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=<optimized out>, post_p=<optimized out>, gimple_test_f=<optimized out>, fallback=<optimized out>) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:13516 >#2 0x00000000009f98d9 in gimplify_stmt (seq_p=0x7fffffffd118, stmt_p=0x7fffee1a87c0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:6825 >#3 gimplify_body (fndecl=0x7fffee1a8700, do_parms=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:14857 >#4 0x00000000009f9d16 in gimplify_function_tree (fndecl=fndecl@entry=0x7fffee1a8700) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:15030 >#5 0x0000000000885968 in cgraph_node::analyze (this=0x7fffee569870) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:670 >#6 0x0000000000888288 in analyze_functions (first_time=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:1227 >#7 0x0000000000888ed3 in symbol_table::finalize_compilation_unit (this=0x7ffff7950100) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:2974 >#8 0x0000000000c76321 in compile_file () at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:483 >#9 0x00000000006005e5 in do_compile () at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:2277 >#10 toplev::main (this=this@entry=0x7fffffffd406, argc=<optimized out>, argc@entry=32, argv=<optimized out>, argv@entry=0x7fffffffd508) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:2416 >#11 0x00000000006040cc in main (argc=32, argv=0x7fffffffd508) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/main.c:39 >(gdb) frame 0 >#0 cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:668 >668 { >(gdb) disassemble >Dump of assembler code for function cp_gimplify_expr(tree_node**, gimple**, gimple**): >Address range 0x6595b0 to 0x65a282: >=> 0x00000000006595b0 <+0>: push %r15 > 0x00000000006595b2 <+2>: push %r14 > 0x00000000006595b4 <+4>: mov %rdi,%r14 > 0x00000000006595b7 <+7>: push %r13 > 0x00000000006595b9 <+9>: push %r12 > 0x00000000006595bb <+11>: push %rbp > 0x00000000006595bc <+12>: push %rbx > 0x00000000006595bd <+13>: mov %rsi,%rbp > 0x00000000006595c0 <+16>: sub $0x88,%rsp > 0x00000000006595c7 <+23>: mov (%rdi),%rdi > 0x00000000006595ca <+26>: mov 0x326c928(%rip),%ebx # 0x38c5ef8 <input_location> > 0x00000000006595d0 <+32>: mov %rdx,0x10(%rsp) > 0x00000000006595d5 <+37>: mov %fs:0x28,%rax > 0x00000000006595de <+46>: mov %rax,0x78(%rsp) > 0x00000000006595e3 <+51>: xor %eax,%eax > 0x00000000006595e5 <+53>: callq 0x77b0d0 <cp_expr_location(tree_node const*)> > 0x00000000006595ea <+58>: movl $0x0,0xc(%rsp) > 0x00000000006595f2 <+66>: test %eax,%eax > 0x00000000006595f4 <+68>: mov %eax,%r11d > 0x00000000006595f7 <+71>: mov (%r14),%rax > 0x00000000006595fa <+74>: cmove %ebx,%r11d > 0x00000000006595fe <+78>: movzwl (%rax),%r15d > 0x0000000000659602 <+82>: movzwl %r15w,%ebx > 0x0000000000659606 <+86>: mov %r15d,%r12d > 0x0000000000659609 <+89>: cmpb $0x0,0x208eea0(%rbx) > 0x0000000000659610 <+96>: jne 0x6598b0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+768> > 0x0000000000659616 <+102>: cmp $0x134,%r12w > 0x000000000065961c <+108>: ja 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x000000000065961e <+110>: cmp $0xfd,%r12w > 0x0000000000659624 <+116>: jbe 0x659650 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+160> > 0x0000000000659626 <+118>: lea -0xfe(%r12),%r9d > 0x000000000065962e <+126>: cmp $0x36,%r9w > 0x0000000000659633 <+131>: ja 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659635 <+133>: movzwl %r9w,%r9d > 0x0000000000659639 <+137>: jmpq *0x1639220(,%r9,8) > 0x0000000000659641 <+145>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000065964c <+156>: nopl 0x0(%rax) > 0x0000000000659650 <+160>: cmp $0x42,%r12w > 0x0000000000659655 <+165>: je 0x659d40 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1936> > 0x000000000065965b <+171>: jbe 0x659730 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+384> > 0x0000000000659661 <+177>: cmp $0x92,%r12w > 0x0000000000659667 <+183>: je 0x659d10 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1888> > 0x000000000065966d <+189>: lea -0xac(%r12),%r9d > 0x0000000000659675 <+197>: cmp $0x4,%r9w > 0x000000000065967a <+202>: jbe 0x6596d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+288> > 0x000000000065967c <+204>: mov 0x10(%rsp),%rdx > 0x0000000000659681 <+209>: mov %rbp,%rsi > 0x0000000000659684 <+212>: mov %r14,%rdi > 0x0000000000659687 <+215>: callq 0x7e1d80 <c_gimplify_expr(tree_node**, gimple**, gimple**)> > 0x000000000065968c <+220>: mov %eax,%r13d > 0x000000000065968f <+223>: cmpb $0x0,0x208eea0(%rbx) > 0x0000000000659696 <+230>: jne 0x659755 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+421> > 0x000000000065969c <+236>: nopl 0x0(%rax) > 0x00000000006596a0 <+240>: mov 0x78(%rsp),%rax > 0x00000000006596a5 <+245>: sub %fs:0x28,%rax > 0x00000000006596ae <+254>: jne 0x65a25d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3245> > 0x00000000006596b4 <+260>: add $0x88,%rsp > 0x00000000006596bb <+267>: mov %r13d,%eax > 0x00000000006596be <+270>: pop %rbx > 0x00000000006596bf <+271>: pop %rbp > 0x00000000006596c0 <+272>: pop %r12 > 0x00000000006596c2 <+274>: pop %r13 > 0x00000000006596c4 <+276>: pop %r14 > 0x00000000006596c6 <+278>: pop %r15 > 0x00000000006596c8 <+280>: retq > 0x00000000006596c9 <+281>: nopl 0x0(%rax) > 0x00000000006596d0 <+288>: mov (%r14),%r12 > 0x00000000006596d3 <+291>: movq $0x0,0x40(%rsp) > 0x00000000006596dc <+300>: mov $0xffffffff,%r13d > 0x00000000006596e2 <+306>: movzbl 0x4(%r12),%eax > 0x00000000006596e8 <+312>: test $0x1,%al > 0x00000000006596ea <+314>: jne 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x00000000006596ec <+316>: or $0x1,%eax > 0x00000000006596ef <+319>: lea 0x40(%rsp),%rsi > 0x00000000006596f4 <+324>: mov %r12,%rdi > 0x00000000006596f7 <+327>: mov $0x1,%r13d > 0x00000000006596fd <+333>: mov %al,0x4(%r12) > 0x0000000000659702 <+338>: callq 0x9f94f0 <gimplify_and_add(tree_node*, gimple**)> > 0x0000000000659707 <+343>: mov %rbp,%rdi > 0x000000000065970a <+346>: mov 0x40(%rsp),%rsi > 0x000000000065970f <+351>: callq 0x9be840 <gimple_seq_add_seq(gimple**, gimple*)> > 0x0000000000659714 <+356>: movzbl 0x4(%r12),%eax > 0x000000000065971a <+362>: and $0xfffffffe,%eax > 0x000000000065971d <+365>: mov %al,0x4(%r12) > 0x0000000000659722 <+370>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659727 <+375>: nopw 0x0(%rax,%rax,1) > 0x0000000000659730 <+384>: cmp $0x3a,%r12w > 0x0000000000659735 <+389>: je 0x659dc0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2064> > 0x000000000065973b <+395>: cmp $0x3b,%r12w > 0x0000000000659740 <+400>: jne 0x659766 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+438> > 0x0000000000659742 <+402>: cmpb $0x0,0x208eea0(%rbx) > 0x0000000000659749 <+409>: mov $0xffffffff,%r13d > 0x000000000065974f <+415>: je 0x6596a0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+240> > 0x0000000000659755 <+421>: callq 0x75f3e0 <current_stmt_tree()> > 0x000000000065975a <+426>: mov 0xc(%rsp),%ecx > 0x000000000065975e <+430>: mov %ecx,0x8(%rax) > 0x0000000000659761 <+433>: jmpq 0x6596a0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+240> > 0x0000000000659766 <+438>: cmp $0x39,%r12w > 0x000000000065976b <+443>: jne 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659771 <+449>: mov (%r14),%rax > 0x0000000000659774 <+452>: mov 0x18(%rax),%rcx > 0x0000000000659778 <+456>: mov 0x20(%rax),%r13 > 0x000000000065977c <+460>: mov 0x3243d9d(%rip),%rax # 0x389d520 <global_trees> > 0x0000000000659783 <+467>: mov 0x8(%rcx),%rdi > 0x0000000000659787 <+471>: cmp %rcx,%rax > 0x000000000065978a <+474>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x000000000065978c <+476>: cmp %rdi,%rax > 0x000000000065978f <+479>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x0000000000659791 <+481>: cmp %r13,%rax > 0x0000000000659794 <+484>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x0000000000659796 <+486>: mov 0x8(%r13),%r8 > 0x000000000065979a <+490>: cmp %r8,%rax > 0x000000000065979d <+493>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x000000000065979f <+495>: cmpq $0x0,0x58(%rdi) > 0x00000000006597a4 <+500>: je 0x6597ad <cp_gimplify_expr(tree_node**, gimple**, gimple**)+509> > 0x00000000006597a6 <+502>: cmpq $0x0,0x58(%r8) > 0x00000000006597ab <+507>: jne 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x00000000006597ad <+509>: mov %rdi,%rsi > 0x00000000006597b0 <+512>: mov %r8,%rdi > 0x00000000006597b3 <+515>: mov %rcx,0x18(%rsp) > 0x00000000006597b8 <+520>: callq 0x9c27c0 <useless_type_conversion_p(tree_node*, tree_node*)> > 0x00000000006597bd <+525>: test %al,%al > 0x00000000006597bf <+527>: mov 0x18(%rsp),%rcx > 0x00000000006597c4 <+532>: je 0x65a09d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2797> > 0x00000000006597ca <+538>: mov 0x8(%rcx),%rdi > 0x00000000006597ce <+542>: xchg %ax,%ax > 0x00000000006597d0 <+544>: mov %r15d,%edx > 0x00000000006597d3 <+547>: mov %r13,%rsi > 0x00000000006597d6 <+550>: mov %rcx,0x18(%rsp) > 0x00000000006597db <+555>: callq 0x655fa0 <simple_empty_class_p(tree_node*, tree_node*, tree_code)> > 0x00000000006597e0 <+560>: test %al,%al > 0x00000000006597e2 <+562>: jne 0x6598f4 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+836> > 0x00000000006597e8 <+568>: cmpl $0x1,0x326c121(%rip) # 0x38c5910 <global_options+4432> > 0x00000000006597ef <+575>: mov 0x18(%rsp),%rcx > 0x00000000006597f4 <+580>: jle 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x00000000006597fa <+586>: mov (%r14),%r12 > 0x00000000006597fd <+589>: cmpw $0x39,(%r12) > 0x0000000000659803 <+595>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659809 <+601>: testb $0x1,0x2(%rcx) > 0x000000000065980d <+605>: je 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659813 <+611>: movzwl (%rcx),%eax > 0x0000000000659816 <+614>: lea -0x2e(%rax),%esi > 0x0000000000659819 <+617>: mov %eax,%edx > 0x000000000065981b <+619>: cmp $0x6,%esi > 0x000000000065981e <+622>: ja 0x65983b <cp_gimplify_expr(tree_node**, gimple**, gimple**)+651> > 0x0000000000659820 <+624>: cmp $0x30,%ax > 0x0000000000659824 <+628>: je 0x65a111 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2913> > 0x000000000065982a <+634>: mov 0x18(%rcx),%rcx > 0x000000000065982e <+638>: movzwl (%rcx),%eax > 0x0000000000659831 <+641>: lea -0x2e(%rax),%esi > 0x0000000000659834 <+644>: mov %eax,%edx > 0x0000000000659836 <+646>: cmp $0x6,%esi > 0x0000000000659839 <+649>: jbe 0x659820 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+624> > 0x000000000065983b <+651>: cltq > 0x000000000065983d <+653>: cmpl $0x3,0x175c280(,%rax,4) > 0x0000000000659845 <+661>: je 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x000000000065984b <+667>: cmp $0x35,%dx > 0x000000000065984f <+671>: je 0x65a214 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3172> > 0x0000000000659855 <+677>: movzbl 0x2(%rcx),%eax > 0x0000000000659859 <+681>: and $0x1,%eax > 0x000000000065985c <+684>: test $0x1,%al > 0x000000000065985e <+686>: je 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659864 <+692>: cmpw $0x42,0x0(%r13) > 0x000000000065986a <+698>: je 0x659891 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+737> > 0x000000000065986c <+700>: mov 0x8(%r13),%rdx > 0x0000000000659870 <+704>: movzwl (%rdx),%eax > 0x0000000000659873 <+707>: lea -0x5(%rax),%ecx > 0x0000000000659876 <+710>: cmp $0x5,%cx > 0x000000000065987a <+714>: jbe 0x659886 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+726> > 0x000000000065987c <+716>: cmp $0xe,%ax > 0x0000000000659880 <+720>: jne 0x65a248 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3224> > 0x0000000000659886 <+726>: testb $0x2,0x2(%r13) > 0x000000000065988b <+731>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659891 <+737>: mov %r13,%rdi > 0x0000000000659894 <+740>: mov $0x1,%ecx > 0x0000000000659899 <+745>: xor %edx,%edx > 0x000000000065989b <+747>: mov %rbp,%rsi > 0x000000000065989e <+750>: xor %r13d,%r13d > 0x00000000006598a1 <+753>: callq 0x9faf50 <get_initialized_tmp_var(tree_node*, gimple**, gimple**, bool)> > 0x00000000006598a6 <+758>: mov %rax,0x20(%r12) > 0x00000000006598ab <+763>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x00000000006598b0 <+768>: mov %r11d,0x18(%rsp) > 0x00000000006598b5 <+773>: callq 0x75f240 <stmts_are_full_exprs_p()> > 0x00000000006598ba <+778>: mov %eax,0xc(%rsp) > 0x00000000006598be <+782>: mov (%r14),%rax > 0x00000000006598c1 <+785>: movzbl 0x4(%rax),%r13d > 0x00000000006598c6 <+790>: callq 0x75f3e0 <current_stmt_tree()> > 0x00000000006598cb <+795>: mov 0x18(%rsp),%r11d > 0x00000000006598d0 <+800>: shr %r13w > 0x00000000006598d4 <+804>: and $0x1,%r13d > 0x00000000006598d8 <+808>: movzbl %r13b,%r13d > 0x00000000006598dc <+812>: mov %r13d,0x8(%rax) > 0x00000000006598e0 <+816>: jmpq 0x659616 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+102> > 0x00000000006598e5 <+821>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x00000000006598f0 <+832>: mov 0x20(%r13),%r13 > 0x00000000006598f4 <+836>: movzwl 0x0(%r13),%eax > 0x00000000006598f9 <+841>: cmp $0x3b,%ax > 0x00000000006598fd <+845>: je 0x6598f0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+832> > 0x00000000006598ff <+847>: movzbl 0x2(%r13),%edx > 0x0000000000659904 <+852>: test $0x1,%dl > 0x0000000000659907 <+855>: je 0x65992c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+892> > 0x0000000000659909 <+857>: and $0x8,%edx > 0x000000000065990c <+860>: je 0x659921 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+881> > 0x000000000065990e <+862>: mov 0x175c280(,%rax,4),%eax > 0x0000000000659915 <+869>: sub $0x3,%eax > 0x0000000000659918 <+872>: cmp $0x1,%eax > 0x000000000065991b <+875>: jbe 0x65a0ff <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2895> > 0x0000000000659921 <+881>: mov %rbp,%rsi > 0x0000000000659924 <+884>: mov %r13,%rdi > 0x0000000000659927 <+887>: callq 0x9f94f0 <gimplify_and_add(tree_node*, gimple**)> > 0x000000000065992c <+892>: mov (%r14),%rax > 0x000000000065992f <+895>: mov 0x10(%rsp),%rdx > 0x0000000000659934 <+900>: mov $0x2,%r8d > 0x000000000065993a <+906>: mov $0x9c33e0,%ecx > 0x000000000065993f <+911>: mov %rbp,%rsi > 0x0000000000659942 <+914>: lea 0x18(%rax),%rdi > 0x0000000000659946 <+918>: callq 0x9f4820 <gimplify_expr(tree_node**, gimple**, gimple**, bool (*)(tree_node*), int)> > 0x000000000065994b <+923>: mov (%r14),%rax > 0x000000000065994e <+926>: mov 0x18(%rax),%rax > 0x0000000000659952 <+930>: mov %rax,(%r14) > 0x0000000000659955 <+933>: cmp $0x92,%r12w > 0x000000000065995b <+939>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659961 <+945>: movzwl (%rax),%edx > 0x0000000000659964 <+948>: cmpl $0x4,0x175c280(,%rdx,4) > 0x000000000065996c <+956>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659972 <+962>: mov 0x18(%rax),%rax > 0x0000000000659976 <+966>: xor %r13d,%r13d > 0x0000000000659979 <+969>: mov %rax,(%r14) > 0x000000000065997c <+972>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659981 <+977>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000065998c <+988>: nopl 0x0(%rax) > 0x0000000000659990 <+992>: mov (%r14),%rax > 0x0000000000659993 <+995>: mov 0x18(%rax),%rdx > 0x0000000000659997 <+999>: mov 0x8(%rax),%rsi > 0x000000000065999b <+1003>: cmp %rsi,0x8(%rdx) > 0x000000000065999f <+1007>: je 0x6599ab <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1019> > 0x00000000006599a1 <+1009>: xor %edi,%edi > 0x00000000006599a3 <+1011>: callq 0x990120 <fold_convert_loc(unsigned int, tree_node*, tree_node*)> > 0x00000000006599a8 <+1016>: mov %rax,%rdx > 0x00000000006599ab <+1019>: mov %rdx,(%r14) > 0x00000000006599ae <+1022>: xor %r13d,%r13d > 0x00000000006599b1 <+1025>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x00000000006599b6 <+1030>: nopw %cs:0x0(%rax,%rax,1) > 0x00000000006599c0 <+1040>: mov (%r14),%r13 > 0x00000000006599c3 <+1043>: xor %esi,%esi > 0x00000000006599c5 <+1045>: mov %r13,%rdi > 0x00000000006599c8 <+1048>: callq 0x9ecc40 <voidify_wrapper_expr(tree_node*, tree_node*)> > 0x00000000006599cd <+1053>: mov 0x18(%r13),%rdi > 0x00000000006599d1 <+1057>: lea 0x38(%rsp),%rsi > 0x00000000006599d6 <+1062>: movq $0x0,0x38(%rsp) > 0x00000000006599df <+1071>: mov %rax,%r12 > 0x00000000006599e2 <+1074>: movq $0x0,0x40(%rsp) > 0x00000000006599eb <+1083>: xor %r13d,%r13d > 0x00000000006599ee <+1086>: callq 0x9f94f0 <gimplify_and_add(tree_node*, gimple**)> > 0x00000000006599f3 <+1091>: mov 0x1a35276(%rip),%rdi # 0x208ec70 <cp_global_trees+528> > 0x00000000006599fa <+1098>: callq 0x9bdaa0 <gimple_build_eh_must_not_throw(tree_node*)> > 0x00000000006599ff <+1103>: lea 0x40(%rsp),%rdi > 0x0000000000659a04 <+1108>: mov %rax,%rsi > 0x0000000000659a07 <+1111>: callq 0x9be7c0 <gimple_seq_add_stmt_without_update(gimple**, gimple*)> > 0x0000000000659a0c <+1116>: mov 0x40(%rsp),%rsi > 0x0000000000659a11 <+1121>: mov $0x1,%edx > 0x0000000000659a16 <+1126>: mov 0x38(%rsp),%rdi > 0x0000000000659a1b <+1131>: callq 0x9bdb70 <gimple_build_try(gimple*, gimple*, gimple_try_flags)> > 0x0000000000659a20 <+1136>: mov %rbp,%rdi > 0x0000000000659a23 <+1139>: mov %rax,%rsi > 0x0000000000659a26 <+1142>: callq 0x9be7c0 <gimple_seq_add_stmt_without_update(gimple**, gimple*)> > 0x0000000000659a2b <+1147>: test %r12,%r12 > 0x0000000000659a2e <+1150>: mov %r12,(%r14) > 0x0000000000659a31 <+1153>: sete %r13b > 0x0000000000659a35 <+1157>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659a3a <+1162>: nopw 0x0(%rax,%rax,1) > 0x0000000000659a40 <+1168>: mov (%r14),%rax > 0x0000000000659a43 <+1171>: mov 0x18(%rax),%rbp > 0x0000000000659a47 <+1175>: cmp 0x3243ad2(%rip),%rbp # 0x389d520 <global_trees> > 0x0000000000659a4e <+1182>: je 0x659f10 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2400> > 0x0000000000659a54 <+1188>: test %rbp,%rbp > 0x0000000000659a57 <+1191>: je 0x659f10 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2400> > 0x0000000000659a5d <+1197>: mov 0x326b6d5(%rip),%esi # 0x38c5138 <global_options+2424> > 0x0000000000659a63 <+1203>: test %esi,%esi > 0x0000000000659a65 <+1205>: je 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x0000000000659a67 <+1207>: movzbl 0x2(%rbp),%eax > 0x0000000000659a6b <+1211>: test $0x1,%al > 0x0000000000659a6d <+1213>: jne 0x65a0bd <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2829> > 0x0000000000659a73 <+1219>: cmpw $0x7e,0x0(%rbp) > 0x0000000000659a78 <+1224>: mov 0x8(%rbp),%rdx > 0x0000000000659a7c <+1228>: movzwl (%rdx),%edx > 0x0000000000659a7f <+1231>: je 0x65a0d8 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2856> > 0x0000000000659a85 <+1237>: cmp $0x14,%dx > 0x0000000000659a89 <+1241>: je 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x0000000000659a8b <+1243>: movzbl 0x2(%rbp),%eax > 0x0000000000659a8f <+1247>: test $0x40,%al > 0x0000000000659a91 <+1249>: je 0x65a130 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2944> > 0x0000000000659a97 <+1255>: nopw 0x0(%rax,%rax,1) > 0x0000000000659aa0 <+1264>: mov %rbp,(%r14) > 0x0000000000659aa3 <+1267>: xor %r13d,%r13d > 0x0000000000659aa6 <+1270>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659aab <+1275>: nopl 0x0(%rax,%rax,1) > 0x0000000000659ab0 <+1280>: mov (%r14),%rax > 0x0000000000659ab3 <+1283>: xor %r13d,%r13d > 0x0000000000659ab6 <+1286>: mov 0x20(%rax),%rax > 0x0000000000659aba <+1290>: mov %rax,(%r14) > 0x0000000000659abd <+1293>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659ac2 <+1298>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659acd <+1309>: nopl (%rax) > 0x0000000000659ad0 <+1312>: mov (%r14),%rax > 0x0000000000659ad3 <+1315>: mov 0x3243c26(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659ada <+1322>: mov $0x8c,%edi > 0x0000000000659adf <+1327>: xor %r13d,%r13d > 0x0000000000659ae2 <+1330>: mov 0x20(%rax),%rcx > 0x0000000000659ae6 <+1334>: mov 0x18(%rax),%rdx > 0x0000000000659aea <+1338>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659aef <+1343>: mov %rax,(%r14) > 0x0000000000659af2 <+1346>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659af7 <+1351>: nopw 0x0(%rax,%rax,1) > 0x0000000000659b00 <+1360>: mov (%r14),%rax > 0x0000000000659b03 <+1363>: mov 0x20(%rax),%r12 > 0x0000000000659b07 <+1367>: mov 0x18(%rax),%r13 > 0x0000000000659b0b <+1371>: callq 0x69e8c0 <build_exc_ptr()> > 0x0000000000659b10 <+1376>: mov 0x1a35161(%rip),%rdi # 0x208ec78 <cp_global_trees+536> > 0x0000000000659b17 <+1383>: mov $0x1,%esi > 0x0000000000659b1c <+1388>: mov %rax,%rdx > 0x0000000000659b1f <+1391>: xor %eax,%eax > 0x0000000000659b21 <+1393>: callq 0x607500 <build_call_n(tree_node*, int, ...)> > 0x0000000000659b26 <+1398>: mov 0x3243bd3(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659b2d <+1405>: mov %r12,%rdx > 0x0000000000659b30 <+1408>: xor %ecx,%ecx > 0x0000000000659b32 <+1410>: mov $0x9a,%edi > 0x0000000000659b37 <+1415>: mov %rax,%rbp > 0x0000000000659b3a <+1418>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659b3f <+1423>: mov %rbp,%rdi > 0x0000000000659b42 <+1426>: lea 0x20(%rax),%rsi > 0x0000000000659b46 <+1430>: mov %rax,%r12 > 0x0000000000659b49 <+1433>: callq 0xcf4c70 <append_to_statement_list(tree_node*, tree_node**)> > 0x0000000000659b4e <+1438>: mov 0x3243bab(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659b55 <+1445>: xor %edx,%edx > 0x0000000000659b57 <+1447>: mov %r12,%rcx > 0x0000000000659b5a <+1450>: mov $0x8c,%edi > 0x0000000000659b5f <+1455>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659b64 <+1460>: mov %r13,%rdi > 0x0000000000659b67 <+1463>: mov %rax,%rbp > 0x0000000000659b6a <+1466>: lea 0x18(%rax),%rsi > 0x0000000000659b6e <+1470>: callq 0xcf4c70 <append_to_statement_list(tree_node*, tree_node**)> > 0x0000000000659b73 <+1475>: mov %rbp,(%r14) > 0x0000000000659b76 <+1478>: movzbl 0x2(%rbp),%eax > 0x0000000000659b7a <+1482>: or $0x40,%eax > 0x0000000000659b7d <+1485>: mov %al,0x2(%rbp) > 0x0000000000659b80 <+1488>: mov (%r14),%rax > 0x0000000000659b83 <+1491>: mov 0x20(%rax),%rdx > 0x0000000000659b87 <+1495>: movzbl 0x2(%rdx),%eax > 0x0000000000659b8b <+1499>: or $0x40,%eax > 0x0000000000659b8e <+1502>: mov %al,0x2(%rdx) > 0x0000000000659b91 <+1505>: xor %r13d,%r13d > 0x0000000000659b94 <+1508>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659b99 <+1513>: nopl 0x0(%rax) > 0x0000000000659ba0 <+1520>: mov (%r14),%rax > 0x0000000000659ba3 <+1523>: mov 0x3243b56(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659baa <+1530>: mov $0x99,%edi > 0x0000000000659baf <+1535>: xor %r13d,%r13d > 0x0000000000659bb2 <+1538>: mov 0x20(%rax),%rcx > 0x0000000000659bb6 <+1542>: mov 0x8(%rax),%rdx > 0x0000000000659bba <+1546>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659bbf <+1551>: mov %rax,(%r14) > 0x0000000000659bc2 <+1554>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659bc7 <+1559>: nopw 0x0(%rax,%rax,1) > 0x0000000000659bd0 <+1568>: mov %r14,%rdi > 0x0000000000659bd3 <+1571>: xor %r13d,%r13d > 0x0000000000659bd6 <+1574>: callq 0x7660d0 <simplify_aggr_init_expr(tree_node**)> > 0x0000000000659bdb <+1579>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659be0 <+1584>: mov (%r14),%rax > 0x0000000000659be3 <+1587>: xor %r13d,%r13d > 0x0000000000659be6 <+1590>: mov 0x20(%rax),%r12 > 0x0000000000659bea <+1594>: test %r12,%r12 > 0x0000000000659bed <+1597>: je 0x659bff <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1615> > 0x0000000000659bef <+1599>: mov 0x8(%r12),%rdx > 0x0000000000659bf4 <+1604>: xor %r13d,%r13d > 0x0000000000659bf7 <+1607>: cmpw $0x10,(%rdx) > 0x0000000000659bfb <+1611>: sete %r13b > 0x0000000000659bff <+1615>: movzwl (%rax),%edx > 0x0000000000659c02 <+1618>: mov 0x175c280(,%rdx,4),%edx > 0x0000000000659c09 <+1625>: sub $0x4,%edx > 0x0000000000659c0c <+1628>: cmp $0x6,%edx > 0x0000000000659c0f <+1631>: ja 0x5c079a <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626198> > 0x0000000000659c15 <+1637>: mov 0x10(%rax),%esi > 0x0000000000659c18 <+1640>: mov 0x326c2da(%rip),%ebp # 0x38c5ef8 <input_location> > 0x0000000000659c1e <+1646>: test %esi,%esi > 0x0000000000659c20 <+1648>: js 0x659fb0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2560> > 0x0000000000659c26 <+1654>: je 0x65a27d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3277> > 0x0000000000659c2c <+1660>: mov 0x10(%rax),%edx > 0x0000000000659c2f <+1663>: movzbl 0x4(%rax),%ecx > 0x0000000000659c33 <+1667>: mov 0x18(%rax),%rdi > 0x0000000000659c37 <+1671>: xor %esi,%esi > 0x0000000000659c39 <+1673>: mov %edx,0x326c2b9(%rip) # 0x38c5ef8 <input_location> > 0x0000000000659c3f <+1679>: mov $0x3,%r9d > 0x0000000000659c45 <+1685>: mov %r13d,%r8d > 0x0000000000659c48 <+1688>: mov %r12,%rdx > 0x0000000000659c4b <+1691>: shr %cx > 0x0000000000659c4e <+1694>: and $0x1,%ecx > 0x0000000000659c51 <+1697>: callq 0x6a5fb0 <build_vec_init(tree_node*, tree_node*, tree_node*, bool, int, int)> > 0x0000000000659c56 <+1702>: mov $0x2,%r9d > 0x0000000000659c5c <+1708>: xor %r8d,%r8d > 0x0000000000659c5f <+1711>: xor %edx,%edx > 0x0000000000659c61 <+1713>: mov %rax,(%r14) > 0x0000000000659c64 <+1716>: mov $0x1,%ecx > 0x0000000000659c69 <+1721>: mov $0xd,%esi > 0x0000000000659c6e <+1726>: lea 0x40(%rsp),%rdi > 0x0000000000659c73 <+1731>: callq 0x654180 <hash_table<default_hash_traits<tree_node*>, false, xcallocator>::hash_table(unsigned long, bool, bool, bool, mem_alloc_origin)> > 0x0000000000659c78 <+1736>: xor %ecx,%ecx > 0x0000000000659c7a <+1738>: mov $0x774b90,%r8d > 0x0000000000659c80 <+1744>: lea 0x40(%rsp),%rdx > 0x0000000000659c85 <+1749>: mov $0x65b520,%esi > 0x0000000000659c8a <+1754>: mov %r14,%rdi > 0x0000000000659c8d <+1757>: callq 0xee1990 <walk_tree_1(tree_node**, tree_node* (*)(tree_node**, int*, void*), void*, hash_set<tree_node*, false, default_hash_traits<tree_node*> >*, tree_node* (*)(tree_node**, int*, tree_node* (*)(tree_node**, int*, void*), void*, hash_set<tree_node*, false, default_hash_traits<tree_node*> >*))> > 0x0000000000659c92 <+1762>: xor %esi,%esi > 0x0000000000659c94 <+1764>: mov %r14,%rdi > 0x0000000000659c97 <+1767>: callq 0x656a80 <cp_genericize_tree(tree*, bool)> > 0x0000000000659c9c <+1772>: xor %esi,%esi > 0x0000000000659c9e <+1774>: mov %r14,%rdi > 0x0000000000659ca1 <+1777>: callq 0x9ecb80 <copy_if_shared(tree_node**, void*)> > 0x0000000000659ca6 <+1782>: cmpb $0x0,0x6c(%rsp) > 0x0000000000659cab <+1787>: mov %ebp,0x326c247(%rip) # 0x38c5ef8 <input_location> > 0x0000000000659cb1 <+1793>: mov 0x40(%rsp),%rdi > 0x0000000000659cb6 <+1798>: jne 0x659f20 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2416> > 0x0000000000659cbc <+1804>: callq 0x5be8c0 <free@plt> > 0x0000000000659cc1 <+1809>: jmpq 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659cc6 <+1814>: nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659cd0 <+1824>: mov (%r14),%rax > 0x0000000000659cd3 <+1827>: xor %r13d,%r13d > 0x0000000000659cd6 <+1830>: mov 0x18(%rax),%rax > 0x0000000000659cda <+1834>: mov %rax,(%r14) > 0x0000000000659cdd <+1837>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659ce2 <+1842>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659ced <+1853>: nopl (%rax) > 0x0000000000659cf0 <+1856>: mov (%r14),%rax > 0x0000000000659cf3 <+1859>: xor %esi,%esi > 0x0000000000659cf5 <+1861>: xor %r13d,%r13d > 0x0000000000659cf8 <+1864>: mov 0x8(%rax),%rdi > 0x0000000000659cfc <+1868>: callq 0xecc8f0 <build_constructor(tree_node*, vec<constructor_elt, va_gc, vl_embed>*)> > 0x0000000000659d01 <+1873>: mov %rax,(%r14) > 0x0000000000659d04 <+1876>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659d09 <+1881>: nopl 0x0(%rax) > 0x0000000000659d10 <+1888>: mov (%r14),%rcx > 0x0000000000659d13 <+1891>: mov 0x18(%rcx),%rax > 0x0000000000659d17 <+1895>: test %rax,%rax > 0x0000000000659d1a <+1898>: je 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659d20 <+1904>: movzwl (%rax),%edx > 0x0000000000659d23 <+1907>: sub $0x39,%edx > 0x0000000000659d26 <+1910>: cmp $0x1,%dx > 0x0000000000659d2a <+1914>: ja 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659d30 <+1920>: lea 0x18(%rcx),%r14 > 0x0000000000659d34 <+1924>: jmpq 0x659774 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+452> > 0x0000000000659d39 <+1929>: nopl 0x0(%rax) > 0x0000000000659d40 <+1936>: cmpl $0x2,0x326bbc9(%rip) # 0x38c5910 <global_options+4432> > 0x0000000000659d47 <+1943>: mov (%r14),%r15 > 0x0000000000659d4a <+1946>: mov 0x20(%r15),%rdx > 0x0000000000659d4e <+1950>: mov %r15,%rdi > 0x0000000000659d51 <+1953>: je 0x659ec0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2320> > 0x0000000000659d57 <+1959>: xor %r13d,%r13d > 0x0000000000659d5a <+1962>: test %rdx,%rdx > 0x0000000000659d5d <+1965>: je 0x659f2d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2429> > 0x0000000000659d63 <+1971>: movzbl 0x4(%r15),%eax > 0x0000000000659d68 <+1976>: test $0x20,%al > 0x0000000000659d6a <+1978>: je 0x659ff0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2624> > 0x0000000000659d70 <+1984>: mov 0x18(%r15),%rdx > 0x0000000000659d74 <+1988>: cmpl $0x5,0x10(%rdx) > 0x0000000000659d78 <+1992>: jne 0x5c07c2 <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626158> > 0x0000000000659d7e <+1998>: test $0x8,%al > 0x0000000000659d80 <+2000>: jne 0x5c07ae <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626178> > 0x0000000000659d86 <+2006>: lea 0x38(%r15),%rdi > 0x0000000000659d8a <+2010>: mov $0x1,%ecx > 0x0000000000659d8f <+2015>: mov %r11d,%edx > 0x0000000000659d92 <+2018>: mov %rbp,%rsi > 0x0000000000659d95 <+2021>: callq 0x9fbb40 <gimplify_arg(tree_node**, gimple**, unsigned int, bool)> > 0x0000000000659d9a <+2026>: cmp $0xfffffffe,%eax > 0x0000000000659d9d <+2029>: je 0x659da9 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2041> > 0x0000000000659d9f <+2031>: cmp $0xfffffffe,%r13d > 0x0000000000659da3 <+2035>: jne 0x65a0d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2848> > 0x0000000000659da9 <+2041>: mov $0xfffffffe,%r13d > 0x0000000000659daf <+2047>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659db4 <+2052>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659dbf <+2063>: nop > 0x0000000000659dc0 <+2064>: mov (%r14),%rax > 0x0000000000659dc3 <+2067>: mov 0x20(%rax),%rcx > 0x0000000000659dc7 <+2071>: mov 0x18(%rax),%r13 > 0x0000000000659dcb <+2075>: movzwl (%rcx),%eax > 0x0000000000659dce <+2078>: mov %rcx,0x28(%rsp) > 0x0000000000659dd3 <+2083>: cmp $0x3b,%ax > 0x0000000000659dd7 <+2087>: je 0x659ef0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2368> > 0x0000000000659ddd <+2093>: mov 0x28(%rsp),%r8 > 0x0000000000659de2 <+2098>: jmp 0x659e58 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2216> > 0x0000000000659de4 <+2100>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659def <+2111>: nop > 0x0000000000659df0 <+2112>: lea -0xfe(%rax),%edx > 0x0000000000659df6 <+2118>: cmp $0x1,%dx > 0x0000000000659dfa <+2122>: ja 0x659e90 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2272> > 0x0000000000659e00 <+2128>: mov %r8,%rcx > 0x0000000000659e03 <+2131>: cmp $0xfe,%ax > 0x0000000000659e07 <+2135>: je 0x659e80 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2256> > 0x0000000000659e09 <+2137>: mov %r13,0x18(%rcx) > 0x0000000000659e0d <+2141>: mov 0x28(%rsp),%rsi > 0x0000000000659e12 <+2146>: mov %rsi,(%r14) > 0x0000000000659e15 <+2149>: cmp %rcx,%rsi > 0x0000000000659e18 <+2152>: je 0x659e25 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2165> > 0x0000000000659e1a <+2154>: mov 0x32438df(%rip),%rax # 0x389d700 <global_trees+480> > 0x0000000000659e21 <+2161>: mov %rax,0x8(%rsi) > 0x0000000000659e25 <+2165>: mov %rcx,%rdi > 0x0000000000659e28 <+2168>: xor %edx,%edx > 0x0000000000659e2a <+2170>: mov %r13,%rsi > 0x0000000000659e2d <+2173>: mov %r8,0x20(%rsp) > 0x0000000000659e32 <+2178>: mov %rcx,0x18(%rsp) > 0x0000000000659e37 <+2183>: callq 0x778ec0 <replace_placeholders(tree_node*, tree_node*, bool*)> > 0x0000000000659e3c <+2188>: mov 0x18(%rsp),%rcx > 0x0000000000659e41 <+2193>: mov 0x20(%rsp),%r8 > 0x0000000000659e46 <+2198>: cmp %rcx,%r8 > 0x0000000000659e49 <+2201>: je 0x659e9d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2285> > 0x0000000000659e4b <+2203>: mov 0x20(%r8),%r8 > 0x0000000000659e4f <+2207>: test %r8,%r8 > 0x0000000000659e52 <+2210>: je 0x659e9d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2285> > 0x0000000000659e54 <+2212>: movzwl (%r8),%eax > 0x0000000000659e58 <+2216>: cmp $0x38,%ax > 0x0000000000659e5c <+2220>: jne 0x659df0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2112> > 0x0000000000659e5e <+2222>: mov 0x18(%r8),%rcx > 0x0000000000659e62 <+2226>: movzwl (%rcx),%eax > 0x0000000000659e65 <+2229>: lea -0xfe(%rax),%edx > 0x0000000000659e6b <+2235>: cmp $0x1,%dx > 0x0000000000659e6f <+2239>: ja 0x659e25 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2165> > 0x0000000000659e71 <+2241>: jmp 0x659e03 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2131> > 0x0000000000659e73 <+2243>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659e7e <+2254>: xchg %ax,%ax > 0x0000000000659e80 <+2256>: mov %r13,0x28(%rcx) > 0x0000000000659e84 <+2260>: jmp 0x659e0d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2141> > 0x0000000000659e86 <+2262>: nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659e90 <+2272>: xor %edx,%edx > 0x0000000000659e92 <+2274>: mov %r13,%rsi > 0x0000000000659e95 <+2277>: mov %r8,%rdi > 0x0000000000659e98 <+2280>: callq 0x778ec0 <replace_placeholders(tree_node*, tree_node*, bool*)> > 0x0000000000659e9d <+2285>: mov (%r14),%rax > 0x0000000000659ea0 <+2288>: xor %r13d,%r13d > 0x0000000000659ea3 <+2291>: cmpw $0x3a,(%rax) > 0x0000000000659ea7 <+2295>: jne 0x6596a0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+240> > 0x0000000000659ead <+2301>: jmpq 0x659774 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+452> > 0x0000000000659eb2 <+2306>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659ebd <+2317>: nopl (%rax) > 0x0000000000659ec0 <+2320>: mov %r11d,0x10(%rsp) > 0x0000000000659ec5 <+2325>: test %rdx,%rdx > 0x0000000000659ec8 <+2328>: je 0x659f2a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2426> > 0x0000000000659eca <+2330>: callq 0x65e960 <cp_get_callee_fndecl_nofold(tree_node*)> > 0x0000000000659ecf <+2335>: test %rax,%rax > 0x0000000000659ed2 <+2338>: mov 0x10(%rsp),%r11d > 0x0000000000659ed7 <+2343>: je 0x65a146 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2966> > 0x0000000000659edd <+2349>: mov (%r14),%r15 > 0x0000000000659ee0 <+2352>: mov 0x20(%r15),%rdx > 0x0000000000659ee4 <+2356>: mov %r15,%rdi > 0x0000000000659ee7 <+2359>: jmpq 0x659d57 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1959> > 0x0000000000659eec <+2364>: nopl 0x0(%rax) > 0x0000000000659ef0 <+2368>: mov 0x20(%rcx),%rdx > 0x0000000000659ef4 <+2372>: test %rdx,%rdx > 0x0000000000659ef7 <+2375>: je 0x659ddd <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2093> > 0x0000000000659efd <+2381>: movzwl (%rdx),%eax > 0x0000000000659f00 <+2384>: mov %rdx,0x28(%rsp) > 0x0000000000659f05 <+2389>: jmpq 0x659ddd <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2093> > 0x0000000000659f0a <+2394>: nopw 0x0(%rax,%rax,1) > 0x0000000000659f10 <+2400>: callq 0xcf4750 <alloc_stmt_list()> > 0x0000000000659f15 <+2405>: mov %rax,%rbp > 0x0000000000659f18 <+2408>: jmpq 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x0000000000659f1d <+2413>: nopl (%rax) > 0x0000000000659f20 <+2416>: callq 0x80eab0 <ggc_free(void*)> > 0x0000000000659f25 <+2421>: jmpq 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659f2a <+2426>: xor %r13d,%r13d > 0x0000000000659f2d <+2429>: callq 0x65e960 <cp_get_callee_fndecl_nofold(tree_node*)> > 0x0000000000659f32 <+2434>: test %rax,%rax > 0x0000000000659f35 <+2437>: je 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659f3b <+2443>: movzbl 0xd4(%rax),%edx > 0x0000000000659f42 <+2450>: and $0x3,%dx > 0x0000000000659f46 <+2454>: je 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659f4c <+2460>: cmp $0x1,%dx > 0x0000000000659f50 <+2464>: jne 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659f56 <+2470>: mov 0xd0(%rax),%edx > 0x0000000000659f5c <+2476>: test %edx,%edx > 0x0000000000659f5e <+2478>: je 0x65a224 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3188> > 0x0000000000659f64 <+2484>: cmpl $0x2,0xd0(%rax) > 0x0000000000659f6b <+2491>: jne 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659f71 <+2497>: mov (%r14),%rax > 0x0000000000659f74 <+2500>: test %rax,%rax > 0x0000000000659f77 <+2503>: je 0x65a262 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3250> > 0x0000000000659f7d <+2509>: movzwl (%rax),%edx > 0x0000000000659f80 <+2512>: xor %edi,%edi > 0x0000000000659f82 <+2514>: mov 0x175c280(,%rdx,4),%edx > 0x0000000000659f89 <+2521>: sub $0x4,%edx > 0x0000000000659f8c <+2524>: cmp $0x6,%edx > 0x0000000000659f8f <+2527>: ja 0x659f94 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2532> > 0x0000000000659f91 <+2529>: mov 0x10(%rax),%edi > 0x0000000000659f94 <+2532>: callq 0x658d10 <fold_builtin_source_location(unsigned int)> > 0x0000000000659f99 <+2537>: mov %rax,(%r14) > 0x0000000000659f9c <+2540>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659fa1 <+2545>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659fac <+2556>: nopl 0x0(%rax) > 0x0000000000659fb0 <+2560>: mov 0x326bf39(%rip),%rdi # 0x38c5ef0 <line_table> > 0x0000000000659fb7 <+2567>: callq 0x15d84e0 <get_location_from_adhoc_loc(line_maps const*, unsigned int)> > 0x0000000000659fbc <+2572>: test %eax,%eax > 0x0000000000659fbe <+2574>: je 0x65a278 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3272> > 0x0000000000659fc4 <+2580>: mov (%r14),%rax > 0x0000000000659fc7 <+2583>: xor %edx,%edx > 0x0000000000659fc9 <+2585>: test %rax,%rax > 0x0000000000659fcc <+2588>: je 0x659c2f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1663> > 0x0000000000659fd2 <+2594>: movzwl (%rax),%ecx > 0x0000000000659fd5 <+2597>: mov 0x175c280(,%rcx,4),%ecx > 0x0000000000659fdc <+2604>: sub $0x4,%ecx > 0x0000000000659fdf <+2607>: cmp $0x6,%ecx > 0x0000000000659fe2 <+2610>: ja 0x659c2f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1663> > 0x0000000000659fe8 <+2616>: jmpq 0x659c2c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1660> > 0x0000000000659fed <+2621>: nopl (%rax) > 0x0000000000659ff0 <+2624>: test $0x8,%al > 0x0000000000659ff2 <+2626>: je 0x65a05d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2733> > 0x0000000000659ff4 <+2628>: mov 0x18(%r15),%rax > 0x0000000000659ff8 <+2632>: mov 0x10(%rax),%rax > 0x0000000000659ffc <+2636>: cmp $0x4,%eax > 0x0000000000659fff <+2639>: jle 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a005 <+2645>: sub $0x5,%eax > 0x000000000065a008 <+2648>: mov $0x30,%r12d > 0x000000000065a00e <+2654>: lea 0x38(,%rax,8),%rax > 0x000000000065a016 <+2662>: mov %rax,0x18(%rsp) > 0x000000000065a01b <+2667>: jmp 0x65a028 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2680> > 0x000000000065a01d <+2669>: nopl (%rax) > 0x000000000065a020 <+2672>: mov (%r14),%r15 > 0x000000000065a023 <+2675>: mov 0x10(%rsp),%r11d > 0x000000000065a028 <+2680>: lea (%r15,%r12,1),%rdi > 0x000000000065a02c <+2684>: mov $0x1,%ecx > 0x000000000065a031 <+2689>: mov %r11d,%edx > 0x000000000065a034 <+2692>: mov %rbp,%rsi > 0x000000000065a037 <+2695>: mov %r11d,0x10(%rsp) > 0x000000000065a03c <+2700>: callq 0x9fbb40 <gimplify_arg(tree_node**, gimple**, unsigned int, bool)> > 0x000000000065a041 <+2705>: cmp $0xfffffffe,%eax > 0x000000000065a044 <+2708>: mov $0xfffffffe,%eax > 0x000000000065a049 <+2713>: cmove %eax,%r13d > 0x000000000065a04d <+2717>: add $0x8,%r12 > 0x000000000065a051 <+2721>: cmp 0x18(%rsp),%r12 > 0x000000000065a056 <+2726>: jne 0x65a020 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2672> > 0x000000000065a058 <+2728>: jmpq 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a05d <+2733>: mov 0x326b8ad(%rip),%ecx # 0x38c5910 <global_options+4432> > 0x000000000065a063 <+2739>: test %ecx,%ecx > 0x000000000065a065 <+2741>: je 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a06b <+2747>: test $0x40,%al > 0x000000000065a06d <+2749>: jne 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a073 <+2755>: mov 0x8(%rdx),%rdx > 0x000000000065a077 <+2759>: movzwl (%rdx),%eax > 0x000000000065a07a <+2762>: lea -0xa(%rax),%ecx > 0x000000000065a07d <+2765>: cmp $0x1,%cx > 0x000000000065a081 <+2769>: ja 0x65a08a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2778> > 0x000000000065a083 <+2771>: mov 0x8(%rdx),%rax > 0x000000000065a087 <+2775>: movzwl (%rax),%eax > 0x000000000065a08a <+2778>: cmp $0x16,%ax > 0x000000000065a08e <+2782>: jne 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a094 <+2788>: lea 0x30(%r15),%rdi > 0x000000000065a098 <+2792>: jmpq 0x659d8a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2010> > 0x000000000065a09d <+2797>: mov 0x8(%rcx),%rsi > 0x000000000065a0a1 <+2801>: mov (%r14),%rbp > 0x000000000065a0a4 <+2804>: mov %r13,%rdx > 0x000000000065a0a7 <+2807>: mov $0x34,%edi > 0x000000000065a0ac <+2812>: xor %r13d,%r13d > 0x000000000065a0af <+2815>: callq 0xece6e0 <build1(tree_code, tree_node*, tree_node*)> > 0x000000000065a0b4 <+2820>: mov %rax,0x20(%rbp) > 0x000000000065a0b8 <+2824>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x000000000065a0bd <+2829>: mov 0x326be35(%rip),%esi # 0x38c5ef8 <input_location> > 0x000000000065a0c3 <+2835>: mov %rbp,%rdi > 0x000000000065a0c6 <+2838>: callq 0x807280 <warn_if_unused_value(tree_node const*, unsigned int)> > 0x000000000065a0cb <+2843>: jmpq 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x000000000065a0d0 <+2848>: mov (%r14),%rdi > 0x000000000065a0d3 <+2851>: jmpq 0x659f2d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2429> > 0x000000000065a0d8 <+2856>: cmp $0x14,%dx > 0x000000000065a0dc <+2860>: jne 0x659a8f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1247> > 0x000000000065a0e2 <+2866>: mov 0x18(%rbp),%rdi > 0x000000000065a0e6 <+2870>: callq 0xeccdc0 <integer_zerop(tree_node const*)> > 0x000000000065a0eb <+2875>: test %al,%al > 0x000000000065a0ed <+2877>: jne 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x000000000065a0f3 <+2883>: mov 0x8(%rbp),%rax > 0x000000000065a0f7 <+2887>: movzwl (%rax),%edx > 0x000000000065a0fa <+2890>: jmpq 0x659a85 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1237> > 0x000000000065a0ff <+2895>: mov %r13,%rsi > 0x000000000065a102 <+2898>: xor %edi,%edi > 0x000000000065a104 <+2900>: callq 0x9941c0 <build_fold_addr_expr_loc(unsigned int, tree_node*)> > 0x000000000065a109 <+2905>: mov %rax,%r13 > 0x000000000065a10c <+2908>: jmpq 0x659921 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+881> > 0x000000000065a111 <+2913>: mov 0x20(%rcx),%rax > 0x000000000065a115 <+2917>: testb $0x1,0x2(%rax) > 0x000000000065a119 <+2921>: je 0x65982a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+634> > 0x000000000065a11f <+2927>: jmpq 0x659864 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+692> > 0x000000000065a124 <+2932>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000065a12f <+2943>: nop > 0x000000000065a130 <+2944>: mov $0x163865e,%esi > 0x000000000065a135 <+2949>: mov $0x2d6,%edi > 0x000000000065a13a <+2954>: xor %eax,%eax > 0x000000000065a13c <+2956>: callq 0x15b0b80 <warning(int, char const*, ...)> > 0x000000000065a141 <+2961>: jmpq 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x000000000065a146 <+2966>: mov (%r14),%r15 > 0x000000000065a149 <+2969>: xor %edx,%edx > 0x000000000065a14b <+2971>: mov $0x1,%r8d > 0x000000000065a151 <+2977>: mov $0x9c3810,%ecx > 0x000000000065a156 <+2982>: mov %rbp,%rsi > 0x000000000065a159 <+2985>: mov %r11d,0x10(%rsp) > 0x000000000065a15e <+2990>: mov 0x20(%r15),%rax > 0x000000000065a162 <+2994>: lea 0x20(%r15),%rdi > 0x000000000065a166 <+2998>: mov 0x8(%rax),%r12 > 0x000000000065a16a <+3002>: callq 0x9f4820 <gimplify_expr(tree_node**, gimple**, gimple**, bool (*)(tree_node*), int)> > 0x000000000065a16f <+3007>: cmp $0xfffffffe,%eax > 0x000000000065a172 <+3010>: mov 0x10(%rsp),%r11d > 0x000000000065a177 <+3015>: mov %eax,%r13d > 0x000000000065a17a <+3018>: je 0x65a233 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3203> > 0x000000000065a180 <+3024>: mov 0x20(%r15),%rdi > 0x000000000065a184 <+3028>: movzwl (%rdi),%eax > 0x000000000065a187 <+3031>: cmp $0x98,%ax > 0x000000000065a18b <+3035>: sete %dl > 0x000000000065a18e <+3038>: cmp $0x25,%ax > 0x000000000065a192 <+3042>: sete %cl > 0x000000000065a195 <+3045>: or %ecx,%edx > 0x000000000065a197 <+3047>: and $0x1,%edx > 0x000000000065a19a <+3050>: jne 0x65a1a7 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3063> > 0x000000000065a19c <+3052>: mov %eax,%edx > 0x000000000065a19e <+3054>: and $0xfffffffb,%edx > 0x000000000065a1a1 <+3057>: cmp $0x23,%dx > 0x000000000065a1a5 <+3061>: jne 0x65a1ca <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3098> > 0x000000000065a1a7 <+3063>: cmp $0x98,%ax > 0x000000000065a1ab <+3067>: je 0x65a1ca <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3098> > 0x000000000065a1ad <+3069>: mov $0x1,%ecx > 0x000000000065a1b2 <+3074>: xor %edx,%edx > 0x000000000065a1b4 <+3076>: mov %rbp,%rsi > 0x000000000065a1b7 <+3079>: mov %r11d,0x10(%rsp) > 0x000000000065a1bc <+3084>: callq 0x9faf50 <get_initialized_tmp_var(tree_node*, gimple**, gimple**, bool)> > 0x000000000065a1c1 <+3089>: mov 0x10(%rsp),%r11d > 0x000000000065a1c6 <+3094>: mov %rax,0x20(%r15) > 0x000000000065a1ca <+3098>: mov (%r14),%r15 > 0x000000000065a1cd <+3101>: xor %r13d,%r13d > 0x000000000065a1d0 <+3104>: mov 0x20(%r15),%rdx > 0x000000000065a1d4 <+3108>: cmp %r12,0x8(%rdx) > 0x000000000065a1d8 <+3112>: je 0x659d63 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1971> > 0x000000000065a1de <+3118>: mov $0x7e,%edi > 0x000000000065a1e3 <+3123>: mov %r12,%rsi > 0x000000000065a1e6 <+3126>: mov %r11d,0x10(%rsp) > 0x000000000065a1eb <+3131>: callq 0xece6e0 <build1(tree_code, tree_node*, tree_node*)> > 0x000000000065a1f0 <+3136>: xor %r13d,%r13d > 0x000000000065a1f3 <+3139>: mov %rax,0x20(%r15) > 0x000000000065a1f7 <+3143>: mov (%r14),%r15 > 0x000000000065a1fa <+3146>: mov 0x20(%r15),%rdx > 0x000000000065a1fe <+3150>: mov %r15,%rdi > 0x000000000065a201 <+3153>: test %rdx,%rdx > 0x000000000065a204 <+3156>: je 0x659f2d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2429> > 0x000000000065a20a <+3162>: mov 0x10(%rsp),%r11d > 0x000000000065a20f <+3167>: jmpq 0x659d63 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1971> > 0x000000000065a214 <+3172>: mov 0x18(%rcx),%rax > 0x000000000065a218 <+3176>: movzbl 0x2(%rax),%eax > 0x000000000065a21c <+3180>: and $0x1,%eax > 0x000000000065a21f <+3183>: jmpq 0x65985c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+684> > 0x000000000065a224 <+3188>: mov 0x32433fd(%rip),%rax # 0x389d628 <global_trees+264> > 0x000000000065a22b <+3195>: mov %rax,(%r14) > 0x000000000065a22e <+3198>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x000000000065a233 <+3203>: mov (%r14),%r15 > 0x000000000065a236 <+3206>: mov 0x20(%r15),%rdx > 0x000000000065a23a <+3210>: test %rdx,%rdx > 0x000000000065a23d <+3213>: jne 0x659d63 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1971> > 0x000000000065a243 <+3219>: jmpq 0x659da9 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2041> > 0x000000000065a248 <+3224>: cmp $0x11,%ax > 0x000000000065a24c <+3228>: je 0x65a269 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3257> > 0x000000000065a24e <+3230>: cmp $0xc,%ax > 0x000000000065a252 <+3234>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x000000000065a258 <+3240>: jmpq 0x659886 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+726> > 0x000000000065a25d <+3245>: callq 0x5be820 <__stack_chk_fail@plt> > 0x000000000065a262 <+3250>: xor %edi,%edi > 0x000000000065a264 <+3252>: jmpq 0x659f94 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2532> > 0x000000000065a269 <+3257>: testb $0x8,0x37(%rdx) > 0x000000000065a26d <+3261>: jne 0x659886 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+726> > 0x000000000065a273 <+3267>: jmpq 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x000000000065a278 <+3272>: jmpq 0x5c079a <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626198> > 0x000000000065a27d <+3277>: jmpq 0x5c079a <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626198> >Address range 0x5c0772 to 0x5c07d6: > 0x00000000005c0772 <-626238>: mov $0x163864d,%edx > 0x00000000005c0777 <-626233>: mov $0x332,%esi > 0x00000000005c077c <-626228>: mov $0x1638678,%edi > 0x00000000005c0781 <-626223>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c0786 <-626218>: mov $0x163864d,%edx > 0x00000000005c078b <-626213>: mov $0x33a,%esi > 0x00000000005c0790 <-626208>: mov $0x1638678,%edi > 0x00000000005c0795 <-626203>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c079a <-626198>: mov $0x163864d,%edx > 0x00000000005c079f <-626193>: mov $0x2b5,%esi > 0x00000000005c07a4 <-626188>: mov $0x1638678,%edi > 0x00000000005c07a9 <-626183>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c07ae <-626178>: mov $0x163864d,%edx > 0x00000000005c07b3 <-626173>: mov $0x36c,%esi > 0x00000000005c07b8 <-626168>: mov $0x1638678,%edi > 0x00000000005c07bd <-626163>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c07c2 <-626158>: mov $0x163864d,%edx > 0x00000000005c07c7 <-626153>: mov $0x36b,%esi > 0x00000000005c07cc <-626148>: mov $0x1638678,%edi > 0x00000000005c07d1 <-626143>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> >End of assembler dump. >(gdb) b *0x00000000006595e3 >Breakpoint 3 at 0x6595e3: file /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c, line 668. >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Breakpoint 3, 0x00000000006595e3 in cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:668 >668 { >(gdb) watch *(long*)($rsp+78)078)x78)[C[C[C >Watchpoint 4: *(long*)($rsp+0x78) >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 0 >cp_expr_location (t_=0x7fffedb1fdb0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/tree.c:5746 >5746 if (t == NULL_TREE) >(gdb) l >5741 >5742 location_t >5743 cp_expr_location (const_tree t_) >5744 { >5745 tree t = CONST_CAST_TREE (t_); >5746 if (t == NULL_TREE) >5747 return UNKNOWN_LOCATION; >5748 switch (TREE_CODE (t)) >5749 { >5750 case LAMBDA_EXPR: >(gdb) disassemble /s >Dump of assembler code for function cp_expr_location(tree_node const*): >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/tree.c: >5744 { >5745 tree t = CONST_CAST_TREE (t_); >5746 if (t == NULL_TREE) >=> 0x000000000077b0d0 <+0>: test %rdi,%rdi > 0x000000000077b0d3 <+3>: je 0x77b100 <cp_expr_location(tree_node const*)+48> > >5747 return UNKNOWN_LOCATION; >5748 switch (TREE_CODE (t)) > 0x000000000077b0d5 <+5>: movzwl (%rdi),%eax > 0x000000000077b0d8 <+8>: cmp $0x13f,%ax > 0x000000000077b0dc <+12>: je 0x77b110 <cp_expr_location(tree_node const*)+64> > 0x000000000077b0de <+14>: cmp $0x140,%ax > 0x000000000077b0e2 <+18>: je 0x77b120 <cp_expr_location(tree_node const*)+80> > 0x000000000077b0e4 <+20>: cmp $0x135,%ax > 0x000000000077b0e8 <+24>: je 0x77b110 <cp_expr_location(tree_node const*)+64> > >5756 default: >5757 return EXPR_LOCATION (t); > 0x000000000077b0ea <+26>: mov 0x175c280(,%rax,4),%edx > 0x000000000077b0f1 <+33>: xor %eax,%eax > 0x000000000077b0f3 <+35>: sub $0x4,%edx > 0x000000000077b0f6 <+38>: cmp $0x6,%edx > 0x000000000077b0f9 <+41>: ja 0x77b102 <cp_expr_location(tree_node const*)+50> > 0x000000000077b0fb <+43>: mov 0x10(%rdi),%eax > 0x000000000077b0fe <+46>: retq > 0x000000000077b0ff <+47>: nop > 0x000000000077b100 <+48>: xor %eax,%eax > 0x000000000077b102 <+50>: retq > 0x000000000077b103 <+51>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000077b10e <+62>: xchg %ax,%ax > >5755 return TRAIT_EXPR_LOCATION (t); > 0x000000000077b110 <+64>: mov 0x28(%rdi),%eax > 0x000000000077b113 <+67>: retq > 0x000000000077b114 <+68>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000077b11f <+79>: nop > >5751 return LAMBDA_EXPR_LOCATION (t); > 0x000000000077b120 <+80>: mov 0x30(%rdi),%eax > 0x000000000077b123 <+83>: retq >End of assembler dump. >(gdb) bt >#0 cp_expr_location (t_=0x7fffedb1fdb0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/tree.c:5746 >#1 0x00000000006595ea in cp_expr_loc_or_loc (or_loc=1344891005, t=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-tree.h:7696 >#2 cp_expr_loc_or_input_loc (t=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-tree.h:7696 >#3 cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:670 >#4 0x00000000009f49fc in gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=<optimized out>, post_p=<optimized out>, gimple_test_f=<optimized out>, fallback=<optimized out>) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:13516 >#5 0x00000000009f98d9 in gimplify_stmt (seq_p=0x7fffffffd118, stmt_p=0x7fffee1a87c0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:6825 >#6 gimplify_body (fndecl=0x7fffee1a8700, do_parms=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:14857 >#7 0x00000000009f9d16 in gimplify_function_tree (fndecl=fndecl@entry=0x7fffee1a8700) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:15030 >#8 0x0000000000885968 in cgraph_node::analyze (this=0x7fffee569870) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:670 >#9 0x0000000000888288 in analyze_functions (first_time=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:1227 >#10 0x0000000000888ed3 in symbol_table::finalize_compilation_unit (this=0x7ffff7950100) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:2974 >#11 0x0000000000c76321 in compile_file () at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:483 >#12 0x00000000006005e5 in do_compile () at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:2277 >#13 toplev::main (this=this@entry=0x7fffffffd406, argc=<optimized out>, argc@entry=32, argv=<optimized out>, argv@entry=0x7fffffffd508) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:2416 >#14 0x00000000006040cc in main (argc=32, argv=0x7fffffffd508) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/main.c:39 >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = -6399947259967866368 >0x00000000006595ea in cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-tree.h:7696 >7696 return cp_expr_loc_or_loc (t, input_location); >(gdb) l >7691 } >7692 >7693 inline location_t >7694 cp_expr_loc_or_input_loc (const_tree t) >7695 { >7696 return cp_expr_loc_or_loc (t, input_location); >7697 } >7698 >7699 inline void >7700 cxx_incomplete_type_diagnostic (const_tree value, const_tree type, >(gdb) disassemble /s >Dump of assembler code for function cp_gimplify_expr(tree_node**, gimple**, gimple**): >Address range 0x6595b0 to 0x65a282: >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >668 { > 0x00000000006595b0 <+0>: push %r15 > 0x00000000006595b2 <+2>: push %r14 > 0x00000000006595b4 <+4>: mov %rdi,%r14 > 0x00000000006595b7 <+7>: push %r13 > 0x00000000006595b9 <+9>: push %r12 > 0x00000000006595bb <+11>: push %rbp > 0x00000000006595bc <+12>: push %rbx > 0x00000000006595bd <+13>: mov %rsi,%rbp > 0x00000000006595c0 <+16>: sub $0x88,%rsp > 0x00000000006595c7 <+23>: mov (%rdi),%rdi > 0x00000000006595ca <+26>: mov 0x326c928(%rip),%ebx # 0x38c5ef8 <input_location> > 0x00000000006595d0 <+32>: mov %rdx,0x10(%rsp) > 0x00000000006595d5 <+37>: mov %fs:0x28,%rax > 0x00000000006595de <+46>: mov %rax,0x78(%rsp) > 0x00000000006595e3 <+51>: xor %eax,%eax > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-tree.h: >7696 return cp_expr_loc_or_loc (t, input_location); > 0x00000000006595e5 <+53>: callq 0x77b0d0 <cp_expr_location(tree_node const*)> >=> 0x00000000006595ea <+58>: movl $0x0,0xc(%rsp) > 0x00000000006595f2 <+66>: test %eax,%eax > 0x00000000006595f4 <+68>: mov %eax,%r11d > >7688 if (loc == UNKNOWN_LOCATION) > 0x00000000006595f7 <+71>: mov (%r14),%rax > 0x00000000006595fa <+74>: cmove %ebx,%r11d > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >671 enum tree_code code = TREE_CODE (*expr_p); > 0x00000000006595fe <+78>: movzwl (%rax),%r15d > 0x0000000000659602 <+82>: movzwl %r15w,%ebx > 0x0000000000659606 <+86>: mov %r15d,%r12d > >672 enum gimplify_status ret; >673 >674 if (STATEMENT_CODE_P (code)) > 0x0000000000659609 <+89>: cmpb $0x0,0x208eea0(%rbx) > 0x0000000000659610 <+96>: jne 0x6598b0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+768> > >678 = STMT_IS_FULL_EXPR_P (*expr_p); >679 } >680 >681 switch (code) > 0x0000000000659616 <+102>: cmp $0x134,%r12w > 0x000000000065961c <+108>: ja 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x000000000065961e <+110>: cmp $0xfd,%r12w > 0x0000000000659624 <+116>: jbe 0x659650 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+160> > 0x0000000000659626 <+118>: lea -0xfe(%r12),%r9d > 0x000000000065962e <+126>: cmp $0x36,%r9w > 0x0000000000659633 <+131>: ja 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659635 <+133>: movzwl %r9w,%r9d > 0x0000000000659639 <+137>: jmpq *0x1639220(,%r9,8) > 0x0000000000659641 <+145>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000065964c <+156>: nopl 0x0(%rax) > 0x0000000000659650 <+160>: cmp $0x42,%r12w > 0x0000000000659655 <+165>: je 0x659d40 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1936> > 0x000000000065965b <+171>: jbe 0x659730 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+384> > 0x0000000000659661 <+177>: cmp $0x92,%r12w > 0x0000000000659667 <+183>: je 0x659d10 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1888> > 0x000000000065966d <+189>: lea -0xac(%r12),%r9d > 0x0000000000659675 <+197>: cmp $0x4,%r9w > 0x000000000065967a <+202>: jbe 0x6596d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+288> > >940 } >941 /* Fall through. */ >942 >943 default: >944 ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p); > 0x000000000065967c <+204>: mov 0x10(%rsp),%rdx > 0x0000000000659681 <+209>: mov %rbp,%rsi > 0x0000000000659684 <+212>: mov %r14,%rdi > 0x0000000000659687 <+215>: callq 0x7e1d80 <c_gimplify_expr(tree_node**, gimple**, gimple**)> > 0x000000000065968c <+220>: mov %eax,%r13d > >945 break; >946 } >947 >948 /* Restore saved state. */ >949 if (STATEMENT_CODE_P (code)) > 0x000000000065968f <+223>: cmpb $0x0,0x208eea0(%rbx) > 0x0000000000659696 <+230>: jne 0x659755 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+421> > 0x000000000065969c <+236>: nopl 0x0(%rax) > 0x00000000006596a0 <+240>: mov 0x78(%rsp),%rax > 0x00000000006596a5 <+245>: sub %fs:0x28,%rax > 0x00000000006596ae <+254>: jne 0x65a25d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3245> > 0x00000000006596b4 <+260>: add $0x88,%rsp > 0x00000000006596bb <+267>: mov %r13d,%eax > 0x00000000006596be <+270>: pop %rbx > 0x00000000006596bf <+271>: pop %rbp > 0x00000000006596c0 <+272>: pop %r12 > 0x00000000006596c2 <+274>: pop %r13 > 0x00000000006596c4 <+276>: pop %r14 > 0x00000000006596c6 <+278>: pop %r15 > 0x00000000006596c8 <+280>: retq > 0x00000000006596c9 <+281>: nopl 0x0(%rax) > >833 ret = cp_gimplify_omp_for (expr_p, pre_p); > 0x00000000006596d0 <+288>: mov (%r14),%r12 > >461 gimple_seq seq = NULL; > 0x00000000006596d3 <+291>: movq $0x0,0x40(%rsp) > >462 >463 /* Protect ourselves from recursion. */ >464 if (OMP_FOR_GIMPLIFYING_P (for_stmt)) > 0x00000000006596dc <+300>: mov $0xffffffff,%r13d > 0x00000000006596e2 <+306>: movzbl 0x4(%r12),%eax > 0x00000000006596e8 <+312>: test $0x1,%al > 0x00000000006596ea <+314>: jne 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > >465 return GS_UNHANDLED; >466 OMP_FOR_GIMPLIFYING_P (for_stmt) = 1; > 0x00000000006596ec <+316>: or $0x1,%eax > 0x00000000006596ef <+319>: lea 0x40(%rsp),%rsi > 0x00000000006596f4 <+324>: mov %r12,%rdi > 0x00000000006596f7 <+327>: mov $0x1,%r13d > 0x00000000006596fd <+333>: mov %al,0x4(%r12) > >467 >468 gimplify_and_add (for_stmt, &seq); > 0x0000000000659702 <+338>: callq 0x9f94f0 <gimplify_and_add(tree_node*, gimple**)> > >469 gimple_seq_add_seq (pre_p, seq); > 0x0000000000659707 <+343>: mov %rbp,%rdi > 0x000000000065970a <+346>: mov 0x40(%rsp),%rsi > 0x000000000065970f <+351>: callq 0x9be840 <gimple_seq_add_seq(gimple**, gimple*)> > >470 >471 OMP_FOR_GIMPLIFYING_P (for_stmt) = 0; > 0x0000000000659714 <+356>: movzbl 0x4(%r12),%eax > 0x000000000065971a <+362>: and $0xfffffffe,%eax > 0x000000000065971d <+365>: mov %al,0x4(%r12) > >472 >473 return GS_ALL_DONE; > 0x0000000000659722 <+370>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659727 <+375>: nopw 0x0(%rax,%rax,1) > 0x0000000000659730 <+384>: cmp $0x3a,%r12w > 0x0000000000659735 <+389>: je 0x659dc0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2064> > 0x000000000065973b <+395>: cmp $0x3b,%r12w > 0x0000000000659740 <+400>: jne 0x659766 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+438> > 0x0000000000659742 <+402>: cmpb $0x0,0x208eea0(%rbx) > 0x0000000000659749 <+409>: mov $0xffffffff,%r13d > >945 break; >946 } >947 >948 /* Restore saved state. */ >949 if (STATEMENT_CODE_P (code)) > 0x000000000065974f <+415>: je 0x6596a0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+240> > >950 current_stmt_tree ()->stmts_are_full_exprs_p > 0x0000000000659755 <+421>: callq 0x75f3e0 <current_stmt_tree()> > 0x000000000065975a <+426>: mov 0xc(%rsp),%ecx > 0x000000000065975e <+430>: mov %ecx,0x8(%rax) > 0x0000000000659761 <+433>: jmpq 0x6596a0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+240> > 0x0000000000659766 <+438>: cmp $0x39,%r12w > 0x000000000065976b <+443>: jne 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659771 <+449>: mov (%r14),%rax > >732 tree op0 = TREE_OPERAND (*expr_p, 0); > 0x0000000000659774 <+452>: mov 0x18(%rax),%rcx > >733 tree op1 = TREE_OPERAND (*expr_p, 1); > 0x0000000000659778 <+456>: mov 0x20(%rax),%r13 > >734 >735 if (!error_operand_p (op0) > 0x000000000065977c <+460>: mov 0x3243d9d(%rip),%rax # 0x389d520 <global_trees> > 0x0000000000659783 <+467>: mov 0x8(%rcx),%rdi > 0x0000000000659787 <+471>: cmp %rcx,%rax > 0x000000000065978a <+474>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x000000000065978c <+476>: cmp %rdi,%rax > 0x000000000065978f <+479>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x0000000000659791 <+481>: cmp %r13,%rax > 0x0000000000659794 <+484>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x0000000000659796 <+486>: mov 0x8(%r13),%r8 > 0x000000000065979a <+490>: cmp %r8,%rax > 0x000000000065979d <+493>: je 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x000000000065979f <+495>: cmpq $0x0,0x58(%rdi) > 0x00000000006597a4 <+500>: je 0x6597ad <cp_gimplify_expr(tree_node**, gimple**, gimple**)+509> > 0x00000000006597a6 <+502>: cmpq $0x0,0x58(%r8) > 0x00000000006597ab <+507>: jne 0x6597d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+544> > 0x00000000006597ad <+509>: mov %rdi,%rsi > 0x00000000006597b0 <+512>: mov %r8,%rdi > 0x00000000006597b3 <+515>: mov %rcx,0x18(%rsp) > 0x00000000006597b8 <+520>: callq 0x9c27c0 <useless_type_conversion_p(tree_node*, tree_node*)> > 0x00000000006597bd <+525>: test %al,%al > 0x00000000006597bf <+527>: mov 0x18(%rsp),%rcx > 0x00000000006597c4 <+532>: je 0x65a09d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2797> > 0x00000000006597ca <+538>: mov 0x8(%rcx),%rdi > 0x00000000006597ce <+542>: xchg %ax,%ax > 0x00000000006597d0 <+544>: mov %r15d,%edx > 0x00000000006597d3 <+547>: mov %r13,%rsi > 0x00000000006597d6 <+550>: mov %rcx,0x18(%rsp) > >741 TREE_TYPE (op0), op1); >742 >743 else if (simple_empty_class_p (TREE_TYPE (op0), op1, code)) > 0x00000000006597db <+555>: callq 0x655fa0 <simple_empty_class_p(tree_node*, tree_node*, tree_code)> > 0x00000000006597e0 <+560>: test %al,%al > 0x00000000006597e2 <+562>: jne 0x6598f4 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+836> > 0x00000000006597e8 <+568>: cmpl $0x1,0x326c121(%rip) # 0x38c5910 <global_options+4432> > 0x00000000006597ef <+575>: mov 0x18(%rsp),%rcx > >767 } >768 /* P0145 says that the RHS is sequenced before the LHS. >769 gimplify_modify_expr gimplifies the RHS before the LHS, but that >770 isn't quite strong enough in two cases: >771 >772 1) gimplify.c wants to leave a CALL_EXPR on the RHS, which would >773 mean it's evaluated after the LHS. >774 >775 2) the value calculation of the RHS is also sequenced before the >776 LHS, so for scalar assignment we need to preevaluate if the >777 RHS could be affected by LHS side-effects even if it has no >778 side-effects of its own. We don't need this for classes because >779 class assignment takes its RHS by reference. */ >780 else if (flag_strong_eval_order > 1 > 0x00000000006597f4 <+580>: jle 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x00000000006597fa <+586>: mov (%r14),%r12 > 0x00000000006597fd <+589>: cmpw $0x39,(%r12) > 0x0000000000659803 <+595>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > >628 if (!TREE_SIDE_EFFECTS (e)) > 0x0000000000659809 <+601>: testb $0x1,0x2(%rcx) > 0x000000000065980d <+605>: je 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/tree.h: >4903 switch (TREE_CODE (t)) > 0x0000000000659813 <+611>: movzwl (%rcx),%eax > 0x0000000000659816 <+614>: lea -0x2e(%rax),%esi > 0x0000000000659819 <+617>: mov %eax,%edx > 0x000000000065981b <+619>: cmp $0x6,%esi > 0x000000000065981e <+622>: ja 0x65983b <cp_gimplify_expr(tree_node**, gimple**, gimple**)+651> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >632 if (TREE_CODE (e) == ARRAY_REF > 0x0000000000659820 <+624>: cmp $0x30,%ax > 0x0000000000659824 <+628>: je 0x65a111 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2913> > >633 && TREE_SIDE_EFFECTS (TREE_OPERAND (e, 1))) >634 return true; >635 e = TREE_OPERAND (e, 0); > 0x000000000065982a <+634>: mov 0x18(%rcx),%rcx > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/tree.h: >4903 switch (TREE_CODE (t)) > 0x000000000065982e <+638>: movzwl (%rcx),%eax > 0x0000000000659831 <+641>: lea -0x2e(%rax),%esi > 0x0000000000659834 <+644>: mov %eax,%edx > 0x0000000000659836 <+646>: cmp $0x6,%esi > 0x0000000000659839 <+649>: jbe 0x659820 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+624> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >637 if (DECL_P (e)) > 0x000000000065983b <+651>: cltq > 0x000000000065983d <+653>: cmpl $0x3,0x175c280(,%rax,4) > 0x0000000000659845 <+661>: je 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > >638 /* Just naming a variable has no side-effects. */ >639 return false; >640 else if (INDIRECT_REF_P (e)) > 0x000000000065984b <+667>: cmp $0x35,%dx > 0x000000000065984f <+671>: je 0x65a214 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3172> > >643 else >644 /* For anything else, trust TREE_SIDE_EFFECTS. */ >645 return TREE_SIDE_EFFECTS (e); > 0x0000000000659855 <+677>: movzbl 0x2(%rcx),%eax > 0x0000000000659859 <+681>: and $0x1,%eax > 0x000000000065985c <+684>: test $0x1,%al > 0x000000000065985e <+686>: je 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659864 <+692>: cmpw $0x42,0x0(%r13) > 0x000000000065986a <+698>: je 0x659891 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+737> > 0x000000000065986c <+700>: mov 0x8(%r13),%rdx > 0x0000000000659870 <+704>: movzwl (%rdx),%eax > 0x0000000000659873 <+707>: lea -0x5(%rax),%ecx > 0x0000000000659876 <+710>: cmp $0x5,%cx > 0x000000000065987a <+714>: jbe 0x659886 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+726> > 0x000000000065987c <+716>: cmp $0xe,%ax > 0x0000000000659880 <+720>: jne 0x65a248 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3224> > 0x0000000000659886 <+726>: testb $0x2,0x2(%r13) > 0x000000000065988b <+731>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > >781 && TREE_CODE (*expr_p) == MODIFY_EXPR >782 && lvalue_has_side_effects (op0) >783 && (TREE_CODE (op1) == CALL_EXPR >784 || (SCALAR_TYPE_P (TREE_TYPE (op1)) >785 && !TREE_CONSTANT (op1)))) >786 TREE_OPERAND (*expr_p, 1) = get_initialized_tmp_var (op1, pre_p); > 0x0000000000659891 <+737>: mov %r13,%rdi > 0x0000000000659894 <+740>: mov $0x1,%ecx > 0x0000000000659899 <+745>: xor %edx,%edx > 0x000000000065989b <+747>: mov %rbp,%rsi > 0x000000000065989e <+750>: xor %r13d,%r13d > 0x00000000006598a1 <+753>: callq 0x9faf50 <get_initialized_tmp_var(tree_node*, gimple**, gimple**, bool)> > 0x00000000006598a6 <+758>: mov %rax,0x20(%r12) > 0x00000000006598ab <+763>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x00000000006598b0 <+768>: mov %r11d,0x18(%rsp) > >676 saved_stmts_are_full_exprs_p = stmts_are_full_exprs_p (); > 0x00000000006598b5 <+773>: callq 0x75f240 <stmts_are_full_exprs_p()> > 0x00000000006598ba <+778>: mov %eax,0xc(%rsp) > >677 current_stmt_tree ()->stmts_are_full_exprs_p > 0x00000000006598be <+782>: mov (%r14),%rax > 0x00000000006598c1 <+785>: movzbl 0x4(%rax),%r13d > 0x00000000006598c6 <+790>: callq 0x75f3e0 <current_stmt_tree()> > 0x00000000006598cb <+795>: mov 0x18(%rsp),%r11d > 0x00000000006598d0 <+800>: shr %r13w > 0x00000000006598d4 <+804>: and $0x1,%r13d > 0x00000000006598d8 <+808>: movzbl %r13b,%r13d > 0x00000000006598dc <+812>: mov %r13d,0x8(%rax) > 0x00000000006598e0 <+816>: jmpq 0x659616 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+102> > 0x00000000006598e5 <+821>: data16 nopw %cs:0x0(%rax,%rax,1) > >746 /* We're disconnecting the initializer from its target, >747 don't create a temporary. */ >748 op1 = TARGET_EXPR_INITIAL (op1); > 0x00000000006598f0 <+832>: mov 0x20(%r13),%r13 > >745 while (TREE_CODE (op1) == TARGET_EXPR) > 0x00000000006598f4 <+836>: movzwl 0x0(%r13),%eax > 0x00000000006598f9 <+841>: cmp $0x3b,%ax > 0x00000000006598fd <+845>: je 0x6598f0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+832> > >749 >750 /* Remove any copies of empty classes. Also drop volatile >751 variables on the RHS to avoid infinite recursion from >752 gimplify_expr trying to load the value. */ >753 if (TREE_SIDE_EFFECTS (op1)) > 0x00000000006598ff <+847>: movzbl 0x2(%r13),%edx > 0x0000000000659904 <+852>: test $0x1,%dl > 0x0000000000659907 <+855>: je 0x65992c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+892> > >754 { >755 if (TREE_THIS_VOLATILE (op1) > 0x0000000000659909 <+857>: and $0x8,%edx > 0x000000000065990c <+860>: je 0x659921 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+881> > 0x000000000065990e <+862>: mov 0x175c280(,%rax,4),%eax > 0x0000000000659915 <+869>: sub $0x3,%eax > 0x0000000000659918 <+872>: cmp $0x1,%eax > 0x000000000065991b <+875>: jbe 0x65a0ff <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2895> > >758 >759 gimplify_and_add (op1, pre_p); > 0x0000000000659921 <+881>: mov %rbp,%rsi > 0x0000000000659924 <+884>: mov %r13,%rdi > 0x0000000000659927 <+887>: callq 0x9f94f0 <gimplify_and_add(tree_node*, gimple**)> > >760 } >761 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, > 0x000000000065992c <+892>: mov (%r14),%rax > 0x000000000065992f <+895>: mov 0x10(%rsp),%rdx > 0x0000000000659934 <+900>: mov $0x2,%r8d > 0x000000000065993a <+906>: mov $0x9c33e0,%ecx > 0x000000000065993f <+911>: mov %rbp,%rsi > 0x0000000000659942 <+914>: lea 0x18(%rax),%rdi > 0x0000000000659946 <+918>: callq 0x9f4820 <gimplify_expr(tree_node**, gimple**, gimple**, bool (*)(tree_node*), int)> > >762 is_gimple_lvalue, fb_lvalue); >763 *expr_p = TREE_OPERAND (*expr_p, 0); > 0x000000000065994b <+923>: mov (%r14),%rax > 0x000000000065994e <+926>: mov 0x18(%rax),%rax > 0x0000000000659952 <+930>: mov %rax,(%r14) > >764 if (code == RETURN_EXPR && REFERENCE_CLASS_P (*expr_p)) > 0x0000000000659955 <+933>: cmp $0x92,%r12w > 0x000000000065995b <+939>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659961 <+945>: movzwl (%rax),%edx > 0x0000000000659964 <+948>: cmpl $0x4,0x175c280(,%rdx,4) > 0x000000000065996c <+956>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > >765 /* Avoid 'return *<retval>;' */ >766 *expr_p = TREE_OPERAND (*expr_p, 0); > 0x0000000000659972 <+962>: mov 0x18(%rax),%rax > 0x0000000000659976 <+966>: xor %r13d,%r13d > 0x0000000000659979 <+969>: mov %rax,(%r14) > 0x000000000065997c <+972>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659981 <+977>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000065998c <+988>: nopl 0x0(%rax) > >838 ret = GS_OK; >839 break; >840 >841 case UNARY_PLUS_EXPR: >842 { >843 tree arg = TREE_OPERAND (*expr_p, 0); > 0x0000000000659990 <+992>: mov (%r14),%rax > 0x0000000000659993 <+995>: mov 0x18(%rax),%rdx > >844 tree type = TREE_TYPE (*expr_p); > 0x0000000000659997 <+999>: mov 0x8(%rax),%rsi > >845 *expr_p = (TREE_TYPE (arg) != type) ? fold_convert (type, arg) > 0x000000000065999b <+1003>: cmp %rsi,0x8(%rdx) > 0x000000000065999f <+1007>: je 0x6599ab <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1019> > 0x00000000006599a1 <+1009>: xor %edi,%edi > 0x00000000006599a3 <+1011>: callq 0x990120 <fold_convert_loc(unsigned int, tree_node*, tree_node*)> > 0x00000000006599a8 <+1016>: mov %rax,%rdx > 0x00000000006599ab <+1019>: mov %rdx,(%r14) > >846 : arg; >847 ret = GS_OK; >848 } >849 break; > 0x00000000006599ae <+1022>: xor %r13d,%r13d > 0x00000000006599b1 <+1025>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x00000000006599b6 <+1030>: nopw %cs:0x0(%rax,%rax,1) > >716 ret = gimplify_must_not_throw_expr (expr_p, pre_p); > 0x00000000006599c0 <+1040>: mov (%r14),%r13 > >570 tree temp = voidify_wrapper_expr (stmt, NULL); > 0x00000000006599c3 <+1043>: xor %esi,%esi > 0x00000000006599c5 <+1045>: mov %r13,%rdi > 0x00000000006599c8 <+1048>: callq 0x9ecc40 <voidify_wrapper_expr(tree_node*, tree_node*)> > 0x00000000006599cd <+1053>: mov 0x18(%r13),%rdi > 0x00000000006599d1 <+1057>: lea 0x38(%rsp),%rsi > 0x00000000006599d6 <+1062>: movq $0x0,0x38(%rsp) > 0x00000000006599df <+1071>: mov %rax,%r12 > >571 tree body = TREE_OPERAND (stmt, 0); >572 gimple_seq try_ = NULL; >573 gimple_seq catch_ = NULL; > 0x00000000006599e2 <+1074>: movq $0x0,0x40(%rsp) > >574 gimple *mnt; >575 >576 gimplify_and_add (body, &try_); > 0x00000000006599eb <+1083>: xor %r13d,%r13d > 0x00000000006599ee <+1086>: callq 0x9f94f0 <gimplify_and_add(tree_node*, gimple**)> > >577 mnt = gimple_build_eh_must_not_throw (terminate_fn); > 0x00000000006599f3 <+1091>: mov 0x1a35276(%rip),%rdi # 0x208ec70 <cp_global_trees+528> > 0x00000000006599fa <+1098>: callq 0x9bdaa0 <gimple_build_eh_must_not_throw(tree_node*)> > 0x00000000006599ff <+1103>: lea 0x40(%rsp),%rdi > 0x0000000000659a04 <+1108>: mov %rax,%rsi > >578 gimple_seq_add_stmt_without_update (&catch_, mnt); > 0x0000000000659a07 <+1111>: callq 0x9be7c0 <gimple_seq_add_stmt_without_update(gimple**, gimple*)> > >579 mnt = gimple_build_try (try_, catch_, GIMPLE_TRY_CATCH); > 0x0000000000659a0c <+1116>: mov 0x40(%rsp),%rsi > 0x0000000000659a11 <+1121>: mov $0x1,%edx > 0x0000000000659a16 <+1126>: mov 0x38(%rsp),%rdi > 0x0000000000659a1b <+1131>: callq 0x9bdb70 <gimple_build_try(gimple*, gimple*, gimple_try_flags)> > 0x0000000000659a20 <+1136>: mov %rbp,%rdi > 0x0000000000659a23 <+1139>: mov %rax,%rsi > >580 >581 gimple_seq_add_stmt_without_update (pre_p, mnt); > 0x0000000000659a26 <+1142>: callq 0x9be7c0 <gimple_seq_add_stmt_without_update(gimple**, gimple*)> > >582 if (temp) > 0x0000000000659a2b <+1147>: test %r12,%r12 > 0x0000000000659a2e <+1150>: mov %r12,(%r14) > 0x0000000000659a31 <+1153>: sete %r13b > >717 break; > 0x0000000000659a35 <+1157>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659a3a <+1162>: nopw 0x0(%rax,%rax,1) > >834 break; >835 >836 case EXPR_STMT: >837 gimplify_expr_stmt (expr_p); > 0x0000000000659a40 <+1168>: mov (%r14),%rax > 0x0000000000659a43 <+1171>: mov 0x18(%rax),%rbp > >483 if (stmt == error_mark_node) > 0x0000000000659a47 <+1175>: cmp 0x3243ad2(%rip),%rbp # 0x389d520 <global_trees> > 0x0000000000659a4e <+1182>: je 0x659f10 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2400> > >484 stmt = NULL; >485 >486 /* Gimplification of a statement expression will nullify the >487 statement if all its side effects are moved to *PRE_P and *POST_P. >488 >489 In this case we will not want to emit the gimplified statement. >490 However, we may still want to emit a warning, so we do that before >491 gimplification. */ >492 if (stmt && warn_unused_value) > 0x0000000000659a54 <+1188>: test %rbp,%rbp > 0x0000000000659a57 <+1191>: je 0x659f10 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2400> > 0x0000000000659a5d <+1197>: mov 0x326b6d5(%rip),%esi # 0x38c5138 <global_options+2424> > 0x0000000000659a63 <+1203>: test %esi,%esi > 0x0000000000659a65 <+1205>: je 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > >493 { >494 if (!TREE_SIDE_EFFECTS (stmt)) > 0x0000000000659a67 <+1207>: movzbl 0x2(%rbp),%eax > 0x0000000000659a6b <+1211>: test $0x1,%al > 0x0000000000659a6d <+1213>: jne 0x65a0bd <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2829> > >495 { >496 if (!IS_EMPTY_STMT (stmt) > 0x0000000000659a73 <+1219>: cmpw $0x7e,0x0(%rbp) > 0x0000000000659a78 <+1224>: mov 0x8(%rbp),%rdx > 0x0000000000659a7c <+1228>: movzwl (%rdx),%edx > 0x0000000000659a7f <+1231>: je 0x65a0d8 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2856> > 0x0000000000659a85 <+1237>: cmp $0x14,%dx > 0x0000000000659a89 <+1241>: je 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x0000000000659a8b <+1243>: movzbl 0x2(%rbp),%eax > 0x0000000000659a8f <+1247>: test $0x40,%al > 0x0000000000659a91 <+1249>: je 0x65a130 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2944> > 0x0000000000659a97 <+1255>: nopw 0x0(%rax,%rax,1) > >507 >508 *stmt_p = stmt; > 0x0000000000659aa0 <+1264>: mov %rbp,(%r14) > 0x0000000000659aa3 <+1267>: xor %r13d,%r13d > 0x0000000000659aa6 <+1270>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659aab <+1275>: nopl 0x0(%rax,%rax,1) > >796 >797 case BASELINK: >798 *expr_p = BASELINK_FUNCTIONS (*expr_p); > 0x0000000000659ab0 <+1280>: mov (%r14),%rax > 0x0000000000659ab3 <+1283>: xor %r13d,%r13d > 0x0000000000659ab6 <+1286>: mov 0x20(%rax),%rax > 0x0000000000659aba <+1290>: mov %rax,(%r14) > >799 ret = GS_OK; >800 break; > 0x0000000000659abd <+1293>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659ac2 <+1298>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659acd <+1309>: nopl (%rax) > >801 >802 case TRY_BLOCK: >803 genericize_try_block (expr_p); > 0x0000000000659ad0 <+1312>: mov (%r14),%rax > >119 *stmt_p = build2 (TRY_CATCH_EXPR, void_type_node, body, cleanup); > 0x0000000000659ad3 <+1315>: mov 0x3243c26(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659ada <+1322>: mov $0x8c,%edi > 0x0000000000659adf <+1327>: xor %r13d,%r13d > 0x0000000000659ae2 <+1330>: mov 0x20(%rax),%rcx > 0x0000000000659ae6 <+1334>: mov 0x18(%rax),%rdx > 0x0000000000659aea <+1338>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659aef <+1343>: mov %rax,(%r14) > 0x0000000000659af2 <+1346>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659af7 <+1351>: nopw 0x0(%rax,%rax,1) > >809 ret = GS_OK; >810 break; >811 >812 case EH_SPEC_BLOCK: >813 genericize_eh_spec_block (expr_p); > 0x0000000000659b00 <+1360>: mov (%r14),%rax > 0x0000000000659b03 <+1363>: mov 0x20(%rax),%r12 > 0x0000000000659b07 <+1367>: mov 0x18(%rax),%r13 > >160 tree failure = build_call_n (call_unexpected_fn, 1, build_exc_ptr ()); > 0x0000000000659b0b <+1371>: callq 0x69e8c0 <build_exc_ptr()> > 0x0000000000659b10 <+1376>: mov 0x1a35161(%rip),%rdi # 0x208ec78 <cp_global_trees+536> > 0x0000000000659b17 <+1383>: mov $0x1,%esi > 0x0000000000659b1c <+1388>: mov %rax,%rdx > 0x0000000000659b1f <+1391>: xor %eax,%eax > 0x0000000000659b21 <+1393>: callq 0x607500 <build_call_n(tree_node*, int, ...)> > 0x0000000000659b26 <+1398>: mov 0x3243bd3(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659b2d <+1405>: mov %r12,%rdx > 0x0000000000659b30 <+1408>: xor %ecx,%ecx > 0x0000000000659b32 <+1410>: mov $0x9a,%edi > 0x0000000000659b37 <+1415>: mov %rax,%rbp > >161 >162 *stmt_p = build_gimple_eh_filter_tree (body, allowed, failure); > 0x0000000000659b3a <+1418>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659b3f <+1423>: mov %rbp,%rdi > 0x0000000000659b42 <+1426>: lea 0x20(%rax),%rsi > 0x0000000000659b46 <+1430>: mov %rax,%r12 > >144 append_to_statement_list (failure, &EH_FILTER_FAILURE (t)); > 0x0000000000659b49 <+1433>: callq 0xcf4c70 <append_to_statement_list(tree_node*, tree_node**)> > >145 >146 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t); > 0x0000000000659b4e <+1438>: mov 0x3243bab(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659b55 <+1445>: xor %edx,%edx > 0x0000000000659b57 <+1447>: mov %r12,%rcx > 0x0000000000659b5a <+1450>: mov $0x8c,%edi > 0x0000000000659b5f <+1455>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659b64 <+1460>: mov %r13,%rdi > 0x0000000000659b67 <+1463>: mov %rax,%rbp > >147 append_to_statement_list (body, &TREE_OPERAND (t, 0)); > 0x0000000000659b6a <+1466>: lea 0x18(%rax),%rsi > 0x0000000000659b6e <+1470>: callq 0xcf4c70 <append_to_statement_list(tree_node*, tree_node**)> > >148 >149 return t; > 0x0000000000659b73 <+1475>: mov %rbp,(%r14) > >163 TREE_NO_WARNING (*stmt_p) = true; > 0x0000000000659b76 <+1478>: movzbl 0x2(%rbp),%eax > 0x0000000000659b7a <+1482>: or $0x40,%eax > 0x0000000000659b7d <+1485>: mov %al,0x2(%rbp) > >164 TREE_NO_WARNING (TREE_OPERAND (*stmt_p, 1)) = true; > 0x0000000000659b80 <+1488>: mov (%r14),%rax > 0x0000000000659b83 <+1491>: mov 0x20(%rax),%rdx > 0x0000000000659b87 <+1495>: movzbl 0x2(%rdx),%eax > 0x0000000000659b8b <+1499>: or $0x40,%eax > 0x0000000000659b8e <+1502>: mov %al,0x2(%rdx) > 0x0000000000659b91 <+1505>: xor %r13d,%r13d > 0x0000000000659b94 <+1508>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659b99 <+1513>: nopl 0x0(%rax) > >804 ret = GS_OK; >805 break; >806 >807 case HANDLER: >808 genericize_catch_block (expr_p); > 0x0000000000659ba0 <+1520>: mov (%r14),%rax > >131 *stmt_p = build2 (CATCH_EXPR, void_type_node, type, body); > 0x0000000000659ba3 <+1523>: mov 0x3243b56(%rip),%rsi # 0x389d700 <global_trees+480> > 0x0000000000659baa <+1530>: mov $0x99,%edi > 0x0000000000659baf <+1535>: xor %r13d,%r13d > 0x0000000000659bb2 <+1538>: mov 0x20(%rax),%rcx > 0x0000000000659bb6 <+1542>: mov 0x8(%rax),%rdx > 0x0000000000659bba <+1546>: callq 0xece870 <build2(tree_code, tree_node*, tree_node*, tree_node*)> > 0x0000000000659bbf <+1551>: mov %rax,(%r14) > 0x0000000000659bc2 <+1554>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659bc7 <+1559>: nopw 0x0(%rax,%rax,1) > >682 { >683 case AGGR_INIT_EXPR: >684 simplify_aggr_init_expr (expr_p); > 0x0000000000659bd0 <+1568>: mov %r14,%rdi > 0x0000000000659bd3 <+1571>: xor %r13d,%r13d > 0x0000000000659bd6 <+1574>: callq 0x7660d0 <simplify_aggr_init_expr(tree_node**)> > >685 ret = GS_OK; >686 break; > 0x0000000000659bdb <+1579>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > >687 >688 case VEC_INIT_EXPR: >689 { >690 location_t loc = input_location; >691 tree init = VEC_INIT_EXPR_INIT (*expr_p); > 0x0000000000659be0 <+1584>: mov (%r14),%rax > 0x0000000000659be3 <+1587>: xor %r13d,%r13d > 0x0000000000659be6 <+1590>: mov 0x20(%rax),%r12 > >692 int from_array = (init && TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE); > 0x0000000000659bea <+1594>: test %r12,%r12 > 0x0000000000659bed <+1597>: je 0x659bff <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1615> > 0x0000000000659bef <+1599>: mov 0x8(%r12),%rdx > 0x0000000000659bf4 <+1604>: xor %r13d,%r13d > 0x0000000000659bf7 <+1607>: cmpw $0x10,(%rdx) > 0x0000000000659bfb <+1611>: sete %r13b > >693 gcc_assert (EXPR_HAS_LOCATION (*expr_p)); > 0x0000000000659bff <+1615>: movzwl (%rax),%edx > 0x0000000000659c02 <+1618>: mov 0x175c280(,%rdx,4),%edx > 0x0000000000659c09 <+1625>: sub $0x4,%edx > 0x0000000000659c0c <+1628>: cmp $0x6,%edx > 0x0000000000659c0f <+1631>: ja 0x5c079a <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626198> > 0x0000000000659c15 <+1637>: mov 0x10(%rax),%esi > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/../libcpp/include/line-map.h: >575 return loc > MAX_LOCATION_T; > 0x0000000000659c18 <+1640>: mov 0x326c2da(%rip),%ebp # 0x38c5ef8 <input_location> > 0x0000000000659c1e <+1646>: test %esi,%esi > 0x0000000000659c20 <+1648>: js 0x659fb0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2560> > 0x0000000000659c26 <+1654>: je 0x65a27d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3277> > 0x0000000000659c2c <+1660>: mov 0x10(%rax),%edx > 0x0000000000659c2f <+1663>: movzbl 0x4(%rax),%ecx > 0x0000000000659c33 <+1667>: mov 0x18(%rax),%rdi > 0x0000000000659c37 <+1671>: xor %esi,%esi > 0x0000000000659c39 <+1673>: mov %edx,0x326c2b9(%rip) # 0x38c5ef8 <input_location> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >695 *expr_p = build_vec_init (VEC_INIT_EXPR_SLOT (*expr_p), NULL_TREE, > 0x0000000000659c3f <+1679>: mov $0x3,%r9d > 0x0000000000659c45 <+1685>: mov %r13d,%r8d > 0x0000000000659c48 <+1688>: mov %r12,%rdx > 0x0000000000659c4b <+1691>: shr %cx > 0x0000000000659c4e <+1694>: and $0x1,%ecx > 0x0000000000659c51 <+1697>: callq 0x6a5fb0 <build_vec_init(tree_node*, tree_node*, tree_node*, bool, int, int)> > 0x0000000000659c56 <+1702>: mov $0x2,%r9d > 0x0000000000659c5c <+1708>: xor %r8d,%r8d > 0x0000000000659c5f <+1711>: xor %edx,%edx > 0x0000000000659c61 <+1713>: mov %rax,(%r14) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/hash-set.h: >40 explicit hash_set (size_t n = 13, bool ggc = false CXX_MEM_STAT_INFO) > 0x0000000000659c64 <+1716>: mov $0x1,%ecx > 0x0000000000659c69 <+1721>: mov $0xd,%esi > 0x0000000000659c6e <+1726>: lea 0x40(%rsp),%rdi > 0x0000000000659c73 <+1731>: callq 0x654180 <hash_table<default_hash_traits<tree_node*>, false, xcallocator>::hash_table(unsigned long, bool, bool, bool, mem_alloc_origin)> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >700 cp_walk_tree (expr_p, cp_fold_r, &pset, NULL); > 0x0000000000659c78 <+1736>: xor %ecx,%ecx > 0x0000000000659c7a <+1738>: mov $0x774b90,%r8d > 0x0000000000659c80 <+1744>: lea 0x40(%rsp),%rdx > 0x0000000000659c85 <+1749>: mov $0x65b520,%esi > 0x0000000000659c8a <+1754>: mov %r14,%rdi > 0x0000000000659c8d <+1757>: callq 0xee1990 <walk_tree_1(tree_node**, tree_node* (*)(tree_node**, int*, void*), void*, hash_set<tree_node*, false, default_hash_traits<tree_node*> >*, tree_node* (*)(tree_node**, int*, tree_node* (*)(tree_node**, int*, void*), void*, hash_set<tree_node*, false, default_hash_traits<tree_node*> >*))> > >701 cp_genericize_tree (expr_p, false); > 0x0000000000659c92 <+1762>: xor %esi,%esi > 0x0000000000659c94 <+1764>: mov %r14,%rdi > 0x0000000000659c97 <+1767>: callq 0x656a80 <cp_genericize_tree(tree*, bool)> > >702 copy_if_shared (expr_p); > 0x0000000000659c9c <+1772>: xor %esi,%esi > 0x0000000000659c9e <+1774>: mov %r14,%rdi > 0x0000000000659ca1 <+1777>: callq 0x9ecb80 <copy_if_shared(tree_node**, void*)> > >703 ret = GS_OK; >704 input_location = loc; > 0x0000000000659ca6 <+1782>: cmpb $0x0,0x6c(%rsp) > 0x0000000000659cab <+1787>: mov %ebp,0x326c247(%rip) # 0x38c5ef8 <input_location> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/hash-table.h: >680 for (size_t i = m_size - 1; i < m_size; i--) > 0x0000000000659cb1 <+1793>: mov 0x40(%rsp),%rdi > 0x0000000000659cb6 <+1798>: jne 0x659f20 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2416> > >283 xcallocator <Type>::data_free (Type *memory) > 0x0000000000659cbc <+1804>: callq 0x5be8c0 <free@plt> > 0x0000000000659cc1 <+1809>: jmpq 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659cc6 <+1814>: nopw %cs:0x0(%rax,%rax,1) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >711 *expr_p = TREE_OPERAND (*expr_p, 0); > 0x0000000000659cd0 <+1824>: mov (%r14),%rax > 0x0000000000659cd3 <+1827>: xor %r13d,%r13d > 0x0000000000659cd6 <+1830>: mov 0x18(%rax),%rax > 0x0000000000659cda <+1834>: mov %rax,(%r14) > >712 ret = GS_OK; >713 break; > 0x0000000000659cdd <+1837>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659ce2 <+1842>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659ced <+1853>: nopl (%rax) > >787 } >788 ret = GS_OK; >789 break; >790 >791 case EMPTY_CLASS_EXPR: >792 /* We create an empty CONSTRUCTOR with RECORD_TYPE. */ >793 *expr_p = build_constructor (TREE_TYPE (*expr_p), NULL); > 0x0000000000659cf0 <+1856>: mov (%r14),%rax > 0x0000000000659cf3 <+1859>: xor %esi,%esi > 0x0000000000659cf5 <+1861>: xor %r13d,%r13d > 0x0000000000659cf8 <+1864>: mov 0x8(%rax),%rdi > 0x0000000000659cfc <+1868>: callq 0xecc8f0 <build_constructor(tree_node*, vec<constructor_elt, va_gc, vl_embed>*)> > 0x0000000000659d01 <+1873>: mov %rax,(%r14) > >794 ret = GS_OK; >795 break; > 0x0000000000659d04 <+1876>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659d09 <+1881>: nopl 0x0(%rax) > >921 } >922 break; >923 >924 case TARGET_EXPR: >925 /* A TARGET_EXPR that expresses direct-initialization should have been >926 elided by cp_gimplify_init_expr. */ >927 gcc_checking_assert (!TARGET_EXPR_DIRECT_INIT_P (*expr_p)); >928 ret = GS_UNHANDLED; >929 break; >930 >931 case RETURN_EXPR: >932 if (TREE_OPERAND (*expr_p, 0) > 0x0000000000659d10 <+1888>: mov (%r14),%rcx > 0x0000000000659d13 <+1891>: mov 0x18(%rcx),%rax > 0x0000000000659d17 <+1895>: test %rax,%rax > 0x0000000000659d1a <+1898>: je 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > 0x0000000000659d20 <+1904>: movzwl (%rax),%edx > 0x0000000000659d23 <+1907>: sub $0x39,%edx > 0x0000000000659d26 <+1910>: cmp $0x1,%dx > 0x0000000000659d2a <+1914>: ja 0x65967c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+204> > >933 && (TREE_CODE (TREE_OPERAND (*expr_p, 0)) == INIT_EXPR >934 || TREE_CODE (TREE_OPERAND (*expr_p, 0)) == MODIFY_EXPR)) >935 { >936 expr_p = &TREE_OPERAND (*expr_p, 0); > 0x0000000000659d30 <+1920>: lea 0x18(%rcx),%r14 > >937 /* Avoid going through the INIT_EXPR case, which can >938 degrade INIT_EXPRs into AGGR_INIT_EXPRs. */ >939 goto modify_expr_case; > 0x0000000000659d34 <+1924>: jmpq 0x659774 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+452> > 0x0000000000659d39 <+1929>: nopl 0x0(%rax) > >853 if (flag_strong_eval_order == 2 > 0x0000000000659d40 <+1936>: cmpl $0x2,0x326bbc9(%rip) # 0x38c5910 <global_options+4432> > 0x0000000000659d47 <+1943>: mov (%r14),%r15 > 0x0000000000659d4a <+1946>: mov 0x20(%r15),%rdx > 0x0000000000659d4e <+1950>: mov %r15,%rdi > 0x0000000000659d51 <+1953>: je 0x659ec0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2320> > 0x0000000000659d57 <+1959>: xor %r13d,%r13d > 0x0000000000659d5a <+1962>: test %rdx,%rdx > 0x0000000000659d5d <+1965>: je 0x659f2d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2429> > >870 /* Internal function call. */; >871 else if (CALL_EXPR_REVERSE_ARGS (*expr_p)) > 0x0000000000659d63 <+1971>: movzbl 0x4(%r15),%eax > 0x0000000000659d68 <+1976>: test $0x20,%al > 0x0000000000659d6a <+1978>: je 0x659ff0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2624> > >872 { >873 /* This is a call to a (compound) assignment operator that used >874 the operator syntax; gimplify the RHS first. */ >875 gcc_assert (call_expr_nargs (*expr_p) == 2); > 0x0000000000659d70 <+1984>: mov 0x18(%r15),%rdx > 0x0000000000659d74 <+1988>: cmpl $0x5,0x10(%rdx) > 0x0000000000659d78 <+1992>: jne 0x5c07c2 <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626158> > >876 gcc_assert (!CALL_EXPR_ORDERED_ARGS (*expr_p)); > 0x0000000000659d7e <+1998>: test $0x8,%al > 0x0000000000659d80 <+2000>: jne 0x5c07ae <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626178> > >877 enum gimplify_status t > 0x0000000000659d86 <+2006>: lea 0x38(%r15),%rdi > 0x0000000000659d8a <+2010>: mov $0x1,%ecx > 0x0000000000659d8f <+2015>: mov %r11d,%edx > 0x0000000000659d92 <+2018>: mov %rbp,%rsi > 0x0000000000659d95 <+2021>: callq 0x9fbb40 <gimplify_arg(tree_node**, gimple**, unsigned int, bool)> > >905 = gimplify_arg (&CALL_EXPR_ARG (*expr_p, 0), pre_p, loc); >906 if (t == GS_ERROR) > 0x0000000000659d9a <+2026>: cmp $0xfffffffe,%eax > 0x0000000000659d9d <+2029>: je 0x659da9 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2041> > >907 ret = GS_ERROR; >908 } >909 } >910 if (ret != GS_ERROR) > 0x0000000000659d9f <+2031>: cmp $0xfffffffe,%r13d > 0x0000000000659da3 <+2035>: jne 0x65a0d0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2848> > 0x0000000000659da9 <+2041>: mov $0xfffffffe,%r13d > 0x0000000000659daf <+2047>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659db4 <+2052>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659dbf <+2063>: nop > >723 cp_gimplify_init_expr (expr_p); > 0x0000000000659dc0 <+2064>: mov (%r14),%rax > 0x0000000000659dc3 <+2067>: mov 0x20(%rax),%rcx > 0x0000000000659dc7 <+2071>: mov 0x18(%rax),%r13 > 0x0000000000659dcb <+2075>: movzwl (%rcx),%eax > 0x0000000000659dce <+2078>: mov %rcx,0x28(%rsp) > >524 if (TREE_CODE (from) == TARGET_EXPR && TARGET_EXPR_INITIAL (from)) > 0x0000000000659dd3 <+2083>: cmp $0x3b,%ax > 0x0000000000659dd7 <+2087>: je 0x659ef0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2368> > >525 from = TARGET_EXPR_INITIAL (from); >526 >527 /* Look through any COMPOUND_EXPRs, since build_compound_expr pushes them >528 inside the TARGET_EXPR. */ >529 for (t = from; t; ) > 0x0000000000659ddd <+2093>: mov 0x28(%rsp),%r8 > 0x0000000000659de2 <+2098>: jmp 0x659e58 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2216> > 0x0000000000659de4 <+2100>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659def <+2111>: nop > >532 >533 /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and >534 replace the slot operand with our target. >535 >536 Should we add a target parm to gimplify_expr instead? No, as in this >537 case we want to replace the INIT_EXPR. */ >538 if (TREE_CODE (sub) == AGGR_INIT_EXPR > 0x0000000000659df0 <+2112>: lea -0xfe(%rax),%edx > 0x0000000000659df6 <+2118>: cmp $0x1,%dx > 0x0000000000659dfa <+2122>: ja 0x659e90 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2272> > 0x0000000000659e00 <+2128>: mov %r8,%rcx > >539 || TREE_CODE (sub) == VEC_INIT_EXPR) >540 { >541 if (TREE_CODE (sub) == AGGR_INIT_EXPR) > 0x0000000000659e03 <+2131>: cmp $0xfe,%ax > 0x0000000000659e07 <+2135>: je 0x659e80 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2256> > >543 else >544 VEC_INIT_EXPR_SLOT (sub) = to; > 0x0000000000659e09 <+2137>: mov %r13,0x18(%rcx) > >545 *expr_p = from; > 0x0000000000659e0d <+2141>: mov 0x28(%rsp),%rsi > 0x0000000000659e12 <+2146>: mov %rsi,(%r14) > >546 >547 /* The initialization is now a side-effect, so the container can >548 become void. */ >549 if (from != sub) > 0x0000000000659e15 <+2149>: cmp %rcx,%rsi > 0x0000000000659e18 <+2152>: je 0x659e25 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2165> > >550 TREE_TYPE (from) = void_type_node; > 0x0000000000659e1a <+2154>: mov 0x32438df(%rip),%rax # 0x389d700 <global_trees+480> > 0x0000000000659e21 <+2161>: mov %rax,0x8(%rsi) > 0x0000000000659e25 <+2165>: mov %rcx,%rdi > 0x0000000000659e28 <+2168>: xor %edx,%edx > 0x0000000000659e2a <+2170>: mov %r13,%rsi > 0x0000000000659e2d <+2173>: mov %r8,0x20(%rsp) > >551 } >552 >553 /* Handle aggregate NSDMI. */ >554 replace_placeholders (sub, to); > 0x0000000000659e32 <+2178>: mov %rcx,0x18(%rsp) > 0x0000000000659e37 <+2183>: callq 0x778ec0 <replace_placeholders(tree_node*, tree_node*, bool*)> > >555 >556 if (t == sub) > 0x0000000000659e3c <+2188>: mov 0x18(%rsp),%rcx > 0x0000000000659e41 <+2193>: mov 0x20(%rsp),%r8 > 0x0000000000659e46 <+2198>: cmp %rcx,%r8 > 0x0000000000659e49 <+2201>: je 0x659e9d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2285> > >557 break; >558 else >559 t = TREE_OPERAND (t, 1); > 0x0000000000659e4b <+2203>: mov 0x20(%r8),%r8 > >529 for (t = from; t; ) > 0x0000000000659e4f <+2207>: test %r8,%r8 > 0x0000000000659e52 <+2210>: je 0x659e9d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2285> > 0x0000000000659e54 <+2212>: movzwl (%r8),%eax > >530 { >531 tree sub = TREE_CODE (t) == COMPOUND_EXPR ? TREE_OPERAND (t, 0) : t; > 0x0000000000659e58 <+2216>: cmp $0x38,%ax > 0x0000000000659e5c <+2220>: jne 0x659df0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2112> > 0x0000000000659e5e <+2222>: mov 0x18(%r8),%rcx > >532 >533 /* If we are initializing from an AGGR_INIT_EXPR, drop the INIT_EXPR and >534 replace the slot operand with our target. >535 >536 Should we add a target parm to gimplify_expr instead? No, as in this >537 case we want to replace the INIT_EXPR. */ >538 if (TREE_CODE (sub) == AGGR_INIT_EXPR > 0x0000000000659e62 <+2226>: movzwl (%rcx),%eax > 0x0000000000659e65 <+2229>: lea -0xfe(%rax),%edx > 0x0000000000659e6b <+2235>: cmp $0x1,%dx > 0x0000000000659e6f <+2239>: ja 0x659e25 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2165> > 0x0000000000659e71 <+2241>: jmp 0x659e03 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2131> > 0x0000000000659e73 <+2243>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659e7e <+2254>: xchg %ax,%ax > >542 AGGR_INIT_EXPR_SLOT (sub) = to; > 0x0000000000659e80 <+2256>: mov %r13,0x28(%rcx) > 0x0000000000659e84 <+2260>: jmp 0x659e0d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2141> > 0x0000000000659e86 <+2262>: nopw %cs:0x0(%rax,%rax,1) > >551 } >552 >553 /* Handle aggregate NSDMI. */ >554 replace_placeholders (sub, to); > 0x0000000000659e90 <+2272>: xor %edx,%edx > 0x0000000000659e92 <+2274>: mov %r13,%rsi > 0x0000000000659e95 <+2277>: mov %r8,%rdi > 0x0000000000659e98 <+2280>: callq 0x778ec0 <replace_placeholders(tree_node*, tree_node*, bool*)> > >724 if (TREE_CODE (*expr_p) != INIT_EXPR) > 0x0000000000659e9d <+2285>: mov (%r14),%rax > 0x0000000000659ea0 <+2288>: xor %r13d,%r13d > 0x0000000000659ea3 <+2291>: cmpw $0x3a,(%rax) > 0x0000000000659ea7 <+2295>: jne 0x6596a0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+240> > 0x0000000000659ead <+2301>: jmpq 0x659774 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+452> > 0x0000000000659eb2 <+2306>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659ebd <+2317>: nopl (%rax) > 0x0000000000659ec0 <+2320>: mov %r11d,0x10(%rsp) > 0x0000000000659ec5 <+2325>: test %rdx,%rdx > 0x0000000000659ec8 <+2328>: je 0x659f2a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2426> > 0x0000000000659eca <+2330>: callq 0x65e960 <cp_get_callee_fndecl_nofold(tree_node*)> > 0x0000000000659ecf <+2335>: test %rax,%rax > 0x0000000000659ed2 <+2338>: mov 0x10(%rsp),%r11d > 0x0000000000659ed7 <+2343>: je 0x65a146 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2966> > >867 = build1 (NOP_EXPR, fnptrtype, CALL_EXPR_FN (*expr_p)); >868 } >869 if (!CALL_EXPR_FN (*expr_p)) > 0x0000000000659edd <+2349>: mov (%r14),%r15 > 0x0000000000659ee0 <+2352>: mov 0x20(%r15),%rdx > 0x0000000000659ee4 <+2356>: mov %r15,%rdi > 0x0000000000659ee7 <+2359>: jmpq 0x659d57 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1959> > 0x0000000000659eec <+2364>: nopl 0x0(%rax) > 0x0000000000659ef0 <+2368>: mov 0x20(%rcx),%rdx > 0x0000000000659ef4 <+2372>: test %rdx,%rdx > 0x0000000000659ef7 <+2375>: je 0x659ddd <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2093> > 0x0000000000659efd <+2381>: movzwl (%rdx),%eax > 0x0000000000659f00 <+2384>: mov %rdx,0x28(%rsp) > 0x0000000000659f05 <+2389>: jmpq 0x659ddd <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2093> > 0x0000000000659f0a <+2394>: nopw 0x0(%rax,%rax,1) > >506 stmt = alloc_stmt_list (); > 0x0000000000659f10 <+2400>: callq 0xcf4750 <alloc_stmt_list()> > 0x0000000000659f15 <+2405>: mov %rax,%rbp > 0x0000000000659f18 <+2408>: jmpq 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x0000000000659f1d <+2413>: nopl (%rax) > 0x0000000000659f20 <+2416>: callq 0x80eab0 <ggc_free(void*)> > >705 } >706 break; > 0x0000000000659f25 <+2421>: jmpq 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x0000000000659f2a <+2426>: xor %r13d,%r13d > >911 { >912 tree decl = cp_get_callee_fndecl_nofold (*expr_p); > 0x0000000000659f2d <+2429>: callq 0x65e960 <cp_get_callee_fndecl_nofold(tree_node*)> > >913 if (decl > 0x0000000000659f32 <+2434>: test %rax,%rax > 0x0000000000659f35 <+2437>: je 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/tree.h: >6258 return (fndecl_built_in_p (node, klass) > 0x0000000000659f3b <+2443>: movzbl 0xd4(%rax),%edx > 0x0000000000659f42 <+2450>: and $0x3,%dx > 0x0000000000659f46 <+2454>: je 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659f4c <+2460>: cmp $0x1,%dx > 0x0000000000659f50 <+2464>: jne 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659f56 <+2470>: mov 0xd0(%rax),%edx > 0x0000000000659f5c <+2476>: test %edx,%edx > 0x0000000000659f5e <+2478>: je 0x65a224 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3188> > 0x0000000000659f64 <+2484>: cmpl $0x2,0xd0(%rax) > 0x0000000000659f6b <+2491>: jne 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >920 *expr_p = fold_builtin_source_location (EXPR_LOCATION (*expr_p)); > 0x0000000000659f71 <+2497>: mov (%r14),%rax > 0x0000000000659f74 <+2500>: test %rax,%rax > 0x0000000000659f77 <+2503>: je 0x65a262 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3250> > 0x0000000000659f7d <+2509>: movzwl (%rax),%edx > 0x0000000000659f80 <+2512>: xor %edi,%edi > 0x0000000000659f82 <+2514>: mov 0x175c280(,%rdx,4),%edx > 0x0000000000659f89 <+2521>: sub $0x4,%edx > 0x0000000000659f8c <+2524>: cmp $0x6,%edx > 0x0000000000659f8f <+2527>: ja 0x659f94 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2532> > 0x0000000000659f91 <+2529>: mov 0x10(%rax),%edi > 0x0000000000659f94 <+2532>: callq 0x658d10 <fold_builtin_source_location(unsigned int)> > 0x0000000000659f99 <+2537>: mov %rax,(%r14) > 0x0000000000659f9c <+2540>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > 0x0000000000659fa1 <+2545>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x0000000000659fac <+2556>: nopl 0x0(%rax) > 0x0000000000659fb0 <+2560>: mov 0x326bf39(%rip),%rdi # 0x38c5ef0 <line_table> > 0x0000000000659fb7 <+2567>: callq 0x15d84e0 <get_location_from_adhoc_loc(line_maps const*, unsigned int)> > 0x0000000000659fbc <+2572>: test %eax,%eax > 0x0000000000659fbe <+2574>: je 0x65a278 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3272> > >694 input_location = EXPR_LOCATION (*expr_p); > 0x0000000000659fc4 <+2580>: mov (%r14),%rax > 0x0000000000659fc7 <+2583>: xor %edx,%edx > 0x0000000000659fc9 <+2585>: test %rax,%rax > 0x0000000000659fcc <+2588>: je 0x659c2f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1663> > 0x0000000000659fd2 <+2594>: movzwl (%rax),%ecx > 0x0000000000659fd5 <+2597>: mov 0x175c280(,%rcx,4),%ecx > 0x0000000000659fdc <+2604>: sub $0x4,%ecx > 0x0000000000659fdf <+2607>: cmp $0x6,%ecx > 0x0000000000659fe2 <+2610>: ja 0x659c2f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1663> > 0x0000000000659fe8 <+2616>: jmpq 0x659c2c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1660> > 0x0000000000659fed <+2621>: nopl (%rax) > >878 = gimplify_arg (&CALL_EXPR_ARG (*expr_p, 1), pre_p, loc); >879 if (t == GS_ERROR) >880 ret = GS_ERROR; >881 } >882 else if (CALL_EXPR_ORDERED_ARGS (*expr_p)) > 0x0000000000659ff0 <+2624>: test $0x8,%al > 0x0000000000659ff2 <+2626>: je 0x65a05d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2733> > >883 { >884 /* Leave the last argument for gimplify_call_expr, to avoid problems >885 with __builtin_va_arg_pack(). */ >886 int nargs = call_expr_nargs (*expr_p) - 1; > 0x0000000000659ff4 <+2628>: mov 0x18(%r15),%rax > 0x0000000000659ff8 <+2632>: mov 0x10(%rax),%rax > >887 for (int i = 0; i < nargs; ++i) > 0x0000000000659ffc <+2636>: cmp $0x4,%eax > 0x0000000000659fff <+2639>: jle 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a005 <+2645>: sub $0x5,%eax > 0x000000000065a008 <+2648>: mov $0x30,%r12d > 0x000000000065a00e <+2654>: lea 0x38(,%rax,8),%rax > 0x000000000065a016 <+2662>: mov %rax,0x18(%rsp) > 0x000000000065a01b <+2667>: jmp 0x65a028 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2680> > 0x000000000065a01d <+2669>: nopl (%rax) > 0x000000000065a020 <+2672>: mov (%r14),%r15 > 0x000000000065a023 <+2675>: mov 0x10(%rsp),%r11d > >888 { >889 enum gimplify_status t > 0x000000000065a028 <+2680>: lea (%r15,%r12,1),%rdi > 0x000000000065a02c <+2684>: mov $0x1,%ecx > 0x000000000065a031 <+2689>: mov %r11d,%edx > 0x000000000065a034 <+2692>: mov %rbp,%rsi > 0x000000000065a037 <+2695>: mov %r11d,0x10(%rsp) > 0x000000000065a03c <+2700>: callq 0x9fbb40 <gimplify_arg(tree_node**, gimple**, unsigned int, bool)> > >890 = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p, loc); >891 if (t == GS_ERROR) > 0x000000000065a041 <+2705>: cmp $0xfffffffe,%eax > 0x000000000065a044 <+2708>: mov $0xfffffffe,%eax > 0x000000000065a049 <+2713>: cmove %eax,%r13d > >887 for (int i = 0; i < nargs; ++i) > 0x000000000065a04d <+2717>: add $0x8,%r12 > 0x000000000065a051 <+2721>: cmp 0x18(%rsp),%r12 > 0x000000000065a056 <+2726>: jne 0x65a020 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2672> > 0x000000000065a058 <+2728>: jmpq 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > >892 ret = GS_ERROR; >893 } >894 } >895 else if (flag_strong_eval_order > 0x000000000065a05d <+2733>: mov 0x326b8ad(%rip),%ecx # 0x38c5910 <global_options+4432> > 0x000000000065a063 <+2739>: test %ecx,%ecx > 0x000000000065a065 <+2741>: je 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > 0x000000000065a06b <+2747>: test $0x40,%al > 0x000000000065a06d <+2749>: jne 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > >896 && !CALL_EXPR_OPERATOR_SYNTAX (*expr_p)) >897 { >898 /* If flag_strong_eval_order, evaluate the object argument first. */ >899 tree fntype = TREE_TYPE (CALL_EXPR_FN (*expr_p)); > 0x000000000065a073 <+2755>: mov 0x8(%rdx),%rdx > >900 if (INDIRECT_TYPE_P (fntype)) > 0x000000000065a077 <+2759>: movzwl (%rdx),%eax > 0x000000000065a07a <+2762>: lea -0xa(%rax),%ecx > 0x000000000065a07d <+2765>: cmp $0x1,%cx > 0x000000000065a081 <+2769>: ja 0x65a08a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2778> > >901 fntype = TREE_TYPE (fntype); > 0x000000000065a083 <+2771>: mov 0x8(%rdx),%rax > 0x000000000065a087 <+2775>: movzwl (%rax),%eax > >902 if (TREE_CODE (fntype) == METHOD_TYPE) > 0x000000000065a08a <+2778>: cmp $0x16,%ax > 0x000000000065a08e <+2782>: jne 0x659d9f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2031> > >903 { >904 enum gimplify_status t > 0x000000000065a094 <+2788>: lea 0x30(%r15),%rdi > 0x000000000065a098 <+2792>: jmpq 0x659d8a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2010> > >740 TREE_OPERAND (*expr_p, 1) = build1 (VIEW_CONVERT_EXPR, > 0x000000000065a09d <+2797>: mov 0x8(%rcx),%rsi > 0x000000000065a0a1 <+2801>: mov (%r14),%rbp > 0x000000000065a0a4 <+2804>: mov %r13,%rdx > 0x000000000065a0a7 <+2807>: mov $0x34,%edi > 0x000000000065a0ac <+2812>: xor %r13d,%r13d > 0x000000000065a0af <+2815>: callq 0xece6e0 <build1(tree_code, tree_node*, tree_node*)> > 0x000000000065a0b4 <+2820>: mov %rax,0x20(%rbp) > 0x000000000065a0b8 <+2824>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > >502 warn_if_unused_value (stmt, input_location); > 0x000000000065a0bd <+2829>: mov 0x326be35(%rip),%esi # 0x38c5ef8 <input_location> > 0x000000000065a0c3 <+2835>: mov %rbp,%rdi > 0x000000000065a0c6 <+2838>: callq 0x807280 <warn_if_unused_value(tree_node const*, unsigned int)> > >503 } >504 >505 if (stmt == NULL_TREE) > 0x000000000065a0cb <+2843>: jmpq 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x000000000065a0d0 <+2848>: mov (%r14),%rdi > 0x000000000065a0d3 <+2851>: jmpq 0x659f2d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2429> > 0x000000000065a0d8 <+2856>: cmp $0x14,%dx > 0x000000000065a0dc <+2860>: jne 0x659a8f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1247> > 0x000000000065a0e2 <+2866>: mov 0x18(%rbp),%rdi > 0x000000000065a0e6 <+2870>: callq 0xeccdc0 <integer_zerop(tree_node const*)> > 0x000000000065a0eb <+2875>: test %al,%al > 0x000000000065a0ed <+2877>: jne 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x000000000065a0f3 <+2883>: mov 0x8(%rbp),%rax > 0x000000000065a0f7 <+2887>: movzwl (%rax),%edx > 0x000000000065a0fa <+2890>: jmpq 0x659a85 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1237> > >756 && (REFERENCE_CLASS_P (op1) || DECL_P (op1))) >757 op1 = build_fold_addr_expr (op1); > 0x000000000065a0ff <+2895>: mov %r13,%rsi > 0x000000000065a102 <+2898>: xor %edi,%edi > 0x000000000065a104 <+2900>: callq 0x9941c0 <build_fold_addr_expr_loc(unsigned int, tree_node*)> > 0x000000000065a109 <+2905>: mov %rax,%r13 > 0x000000000065a10c <+2908>: jmpq 0x659921 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+881> > 0x000000000065a111 <+2913>: mov 0x20(%rcx),%rax > 0x000000000065a115 <+2917>: testb $0x1,0x2(%rax) > 0x000000000065a119 <+2921>: je 0x65982a <cp_gimplify_expr(tree_node**, gimple**, gimple**)+634> > 0x000000000065a11f <+2927>: jmpq 0x659864 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+692> > 0x000000000065a124 <+2932>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000065a12f <+2943>: nop > >499 warning (OPT_Wunused_value, "statement with no effect"); > 0x000000000065a130 <+2944>: mov $0x163865e,%esi > 0x000000000065a135 <+2949>: mov $0x2d6,%edi > 0x000000000065a13a <+2954>: xor %eax,%eax > 0x000000000065a13c <+2956>: callq 0x15b0b80 <warning(int, char const*, ...)> > 0x000000000065a141 <+2961>: jmpq 0x659aa0 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1264> > 0x000000000065a146 <+2966>: mov (%r14),%r15 > 0x000000000065a149 <+2969>: xor %edx,%edx > 0x000000000065a14b <+2971>: mov $0x1,%r8d > 0x000000000065a151 <+2977>: mov $0x9c3810,%ecx > 0x000000000065a156 <+2982>: mov %rbp,%rsi > 0x000000000065a159 <+2985>: mov %r11d,0x10(%rsp) > >854 && CALL_EXPR_FN (*expr_p) >855 && cp_get_callee_fndecl_nofold (*expr_p) == NULL_TREE) >856 { >857 tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p)); > 0x000000000065a15e <+2990>: mov 0x20(%r15),%rax > 0x000000000065a162 <+2994>: lea 0x20(%r15),%rdi > 0x000000000065a166 <+2998>: mov 0x8(%rax),%r12 > >858 enum gimplify_status t > 0x000000000065a16a <+3002>: callq 0x9f4820 <gimplify_expr(tree_node**, gimple**, gimple**, bool (*)(tree_node*), int)> > 0x000000000065a16f <+3007>: cmp $0xfffffffe,%eax > 0x000000000065a172 <+3010>: mov 0x10(%rsp),%r11d > 0x000000000065a177 <+3015>: mov %eax,%r13d > >657 if (t == GS_ERROR) > 0x000000000065a17a <+3018>: je 0x65a233 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3203> > >658 return GS_ERROR; >659 else if (is_gimple_variable (*expr_p) && TREE_CODE (*expr_p) != SSA_NAME) > 0x000000000065a180 <+3024>: mov 0x20(%r15),%rdi > 0x000000000065a184 <+3028>: movzwl (%rdi),%eax > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimple-expr.h: >84 return (TREE_CODE (t) == VAR_DECL > 0x000000000065a187 <+3031>: cmp $0x98,%ax > 0x000000000065a18b <+3035>: sete %dl > 0x000000000065a18e <+3038>: cmp $0x25,%ax > 0x000000000065a192 <+3042>: sete %cl > 0x000000000065a195 <+3045>: or %ecx,%edx > 0x000000000065a197 <+3047>: and $0x1,%edx > 0x000000000065a19a <+3050>: jne 0x65a1a7 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3063> > 0x000000000065a19c <+3052>: mov %eax,%edx > 0x000000000065a19e <+3054>: and $0xfffffffb,%edx > 0x000000000065a1a1 <+3057>: cmp $0x23,%dx > 0x000000000065a1a5 <+3061>: jne 0x65a1ca <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3098> > 0x000000000065a1a7 <+3063>: cmp $0x98,%ax > 0x000000000065a1ab <+3067>: je 0x65a1ca <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3098> > 0x000000000065a1ad <+3069>: mov $0x1,%ecx > 0x000000000065a1b2 <+3074>: xor %edx,%edx > 0x000000000065a1b4 <+3076>: mov %rbp,%rsi > 0x000000000065a1b7 <+3079>: mov %r11d,0x10(%rsp) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >660 *expr_p = get_initialized_tmp_var (*expr_p, pre_p); > 0x000000000065a1bc <+3084>: callq 0x9faf50 <get_initialized_tmp_var(tree_node*, gimple**, gimple**, bool)> > 0x000000000065a1c1 <+3089>: mov 0x10(%rsp),%r11d > 0x000000000065a1c6 <+3094>: mov %rax,0x20(%r15) > >859 = gimplify_to_rvalue (&CALL_EXPR_FN (*expr_p), pre_p, NULL, >860 is_gimple_call_addr); >861 if (t == GS_ERROR) >862 ret = GS_ERROR; >863 /* GIMPLE considers most pointer conversion useless, but for >864 calls we actually care about the exact function pointer type. */ >865 else if (TREE_TYPE (CALL_EXPR_FN (*expr_p)) != fnptrtype) > 0x000000000065a1ca <+3098>: mov (%r14),%r15 > 0x000000000065a1cd <+3101>: xor %r13d,%r13d > 0x000000000065a1d0 <+3104>: mov 0x20(%r15),%rdx > 0x000000000065a1d4 <+3108>: cmp %r12,0x8(%rdx) > 0x000000000065a1d8 <+3112>: je 0x659d63 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1971> > 0x000000000065a1de <+3118>: mov $0x7e,%edi > 0x000000000065a1e3 <+3123>: mov %r12,%rsi > 0x000000000065a1e6 <+3126>: mov %r11d,0x10(%rsp) > >866 CALL_EXPR_FN (*expr_p) > 0x000000000065a1eb <+3131>: callq 0xece6e0 <build1(tree_code, tree_node*, tree_node*)> > 0x000000000065a1f0 <+3136>: xor %r13d,%r13d > 0x000000000065a1f3 <+3139>: mov %rax,0x20(%r15) > >867 = build1 (NOP_EXPR, fnptrtype, CALL_EXPR_FN (*expr_p)); >868 } >869 if (!CALL_EXPR_FN (*expr_p)) > 0x000000000065a1f7 <+3143>: mov (%r14),%r15 > 0x000000000065a1fa <+3146>: mov 0x20(%r15),%rdx > 0x000000000065a1fe <+3150>: mov %r15,%rdi > 0x000000000065a201 <+3153>: test %rdx,%rdx > 0x000000000065a204 <+3156>: je 0x659f2d <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2429> > 0x000000000065a20a <+3162>: mov 0x10(%rsp),%r11d > 0x000000000065a20f <+3167>: jmpq 0x659d63 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1971> > >642 return TREE_SIDE_EFFECTS (TREE_OPERAND (e, 0)); > 0x000000000065a214 <+3172>: mov 0x18(%rcx),%rax > 0x000000000065a218 <+3176>: movzbl 0x2(%rax),%eax > 0x000000000065a21c <+3180>: and $0x1,%eax > 0x000000000065a21f <+3183>: jmpq 0x65985c <cp_gimplify_expr(tree_node**, gimple**, gimple**)+684> > >914 && fndecl_built_in_p (decl, CP_BUILT_IN_IS_CONSTANT_EVALUATED, >915 BUILT_IN_FRONTEND)) >916 *expr_p = boolean_false_node; > 0x000000000065a224 <+3188>: mov 0x32433fd(%rip),%rax # 0x389d628 <global_trees+264> > 0x000000000065a22b <+3195>: mov %rax,(%r14) > 0x000000000065a22e <+3198>: jmpq 0x65968f <cp_gimplify_expr(tree_node**, gimple**, gimple**)+223> > >869 if (!CALL_EXPR_FN (*expr_p)) > 0x000000000065a233 <+3203>: mov (%r14),%r15 > 0x000000000065a236 <+3206>: mov 0x20(%r15),%rdx > 0x000000000065a23a <+3210>: test %rdx,%rdx > 0x000000000065a23d <+3213>: jne 0x659d63 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1971> > 0x000000000065a243 <+3219>: jmpq 0x659da9 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2041> > 0x000000000065a248 <+3224>: cmp $0x11,%ax > 0x000000000065a24c <+3228>: je 0x65a269 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+3257> > 0x000000000065a24e <+3230>: cmp $0xc,%ax > 0x000000000065a252 <+3234>: jne 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x000000000065a258 <+3240>: jmpq 0x659886 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+726> > 0x000000000065a25d <+3245>: callq 0x5be820 <__stack_chk_fail@plt> > 0x000000000065a262 <+3250>: xor %edi,%edi > 0x000000000065a264 <+3252>: jmpq 0x659f94 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+2532> > 0x000000000065a269 <+3257>: testb $0x8,0x37(%rdx) > 0x000000000065a26d <+3261>: jne 0x659886 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+726> > 0x000000000065a273 <+3267>: jmpq 0x659b91 <cp_gimplify_expr(tree_node**, gimple**, gimple**)+1505> > 0x000000000065a278 <+3272>: jmpq 0x5c079a <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626198> > 0x000000000065a27d <+3277>: jmpq 0x5c079a <cp_gimplify_expr(tree_node**, gimple**, gimple**)-626198> >Address range 0x5c0772 to 0x5c07d6: >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c: >817 case USING_STMT: >818 gcc_unreachable (); > 0x00000000005c0772 <-626238>: mov $0x163864d,%edx > 0x00000000005c0777 <-626233>: mov $0x332,%esi > 0x00000000005c077c <-626228>: mov $0x1638678,%edi > 0x00000000005c0781 <-626223>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > >819 >820 case FOR_STMT: >821 case WHILE_STMT: >822 case DO_STMT: >823 case SWITCH_STMT: >824 case CONTINUE_STMT: >825 case BREAK_STMT: >826 gcc_unreachable (); > 0x00000000005c0786 <-626218>: mov $0x163864d,%edx > 0x00000000005c078b <-626213>: mov $0x33a,%esi > 0x00000000005c0790 <-626208>: mov $0x1638678,%edi > 0x00000000005c0795 <-626203>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c079a <-626198>: mov $0x163864d,%edx > 0x00000000005c079f <-626193>: mov $0x2b5,%esi > 0x00000000005c07a4 <-626188>: mov $0x1638678,%edi > 0x00000000005c07a9 <-626183>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c07ae <-626178>: mov $0x163864d,%edx > 0x00000000005c07b3 <-626173>: mov $0x36c,%esi > 0x00000000005c07b8 <-626168>: mov $0x1638678,%edi > 0x00000000005c07bd <-626163>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> > 0x00000000005c07c2 <-626158>: mov $0x163864d,%edx > 0x00000000005c07c7 <-626153>: mov $0x36b,%esi > 0x00000000005c07cc <-626148>: mov $0x1638678,%edi > 0x00000000005c07d1 <-626143>: callq 0x5fcf53 <fancy_abort(char const*, int, char const*)> >End of assembler dump. >(gdb) bt >#0 0x00000000006595ea in cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-tree.h:7696 >#1 0x00000000009f49fc in gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=<optimized out>, post_p=<optimized out>, gimple_test_f=<optimized out>, fallback=<optimized out>) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:13516 >#2 0x00000000009f98d9 in gimplify_stmt (seq_p=0x7fffffffd118, stmt_p=0x7fffee1a87c0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:6825 >#3 gimplify_body (fndecl=0x7fffee1a8700, do_parms=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:14857 >#4 0x00000000009f9d16 in gimplify_function_tree (fndecl=fndecl@entry=0x7fffee1a8700) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:15030 >#5 0x0000000000885968 in cgraph_node::analyze (this=0x7fffee569870) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:670 >#6 0x0000000000888288 in analyze_functions (first_time=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:1227 >#7 0x0000000000888ed3 in symbol_table::finalize_compilation_unit (this=0x7ffff7950100) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cgraphunit.c:2974 >#8 0x0000000000c76321 in compile_file () at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:483 >#9 0x00000000006005e5 in do_compile () at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:2277 >#10 toplev::main (this=this@entry=0x7fffffffd406, argc=<optimized out>, argc@entry=32, argv=<optimized out>, argv@entry=0x7fffffffd508) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/toplev.c:2416 >#11 0x00000000006040cc in main (argc=32, argv=0x7fffffffd508) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/main.c:39 >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 0 >c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:225 >225 enum tree_code code = TREE_CODE (*expr_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = 1 >0x00000000007e1d82 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:225 >225 enum tree_code code = TREE_CODE (*expr_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = 140737488343312 >0x00000000007e1d84 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:225 >225 enum tree_code code = TREE_CODE (*expr_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343312 >New value = 140737188118656 >0x00000000007e1d86 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:225 >225 enum tree_code code = TREE_CODE (*expr_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188118656 >New value = 65771872 >0x00000000007e1d87 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:225 >225 enum tree_code code = TREE_CODE (*expr_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 65771872 >New value = 3 >0x00000000007e1d88 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:225 >225 enum tree_code code = TREE_CODE (*expr_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 3 >New value = 65771872 >0x00000000007e1e24 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:250 >250 *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 65771872 >New value = 140737188118656 >0x00000000007e1e2a in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:250 >250 *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188118656 >New value = 140737488343312 >0x00000000007e1e2c in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:250 >250 *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343312 >New value = 1 >0x00000000007e1e2e in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:250 >250 *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = 0 >0x00000000007e1e30 in c_gimplify_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118, post_p=post_p@entry=0x7fffffffd008) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/c-family/c-gimplify.c:250 >250 *op1_p = unshare_expr (convert (unsigned_type_node, *op1_p)); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = -6399947259967866368 >0x000000000065968c in cp_gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=0x7fffffffd118, post_p=0x7fffffffd008) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:944 >944 ret = (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 0 >0x00000000006596bb in cp_gimplify_expr (expr_p=<optimized out>, pre_p=<optimized out>, post_p=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:949 >949 if (STATEMENT_CODE_P (code)) >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = 12884901888 >0x00000000006596c8 in cp_gimplify_expr (expr_p=<optimized out>, pre_p=<optimized out>, post_p=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/cp/cp-gimplify.c:949 >949 if (STATEMENT_CODE_P (code)) >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 12884901888 >New value = 3 >0x00000000009f49fc in gimplify_expr (expr_p=0x7fffee1a87c0, pre_p=<optimized out>, post_p=<optimized out>, gimple_test_f=<optimized out>, fallback=<optimized out>) > at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:13516 >13516 ret = ((enum gimplify_status) >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 3 >New value = 12884901888 >gimplify_bind_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1331 >1331 { >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 12884901888 >New value = 0 >0x00000000009fcd42 in gimplify_bind_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1331 >1331 { >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = 140737488343048 >0x00000000009fcd51 in gimplify_bind_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1331 >1331 { >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343048 >New value = 140737488343320 >voidify_wrapper_expr (wrapper=0x7fffedb1fdb0, temp=0x0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1097 >1097 tree type = TREE_TYPE (wrapper); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343320 >New value = 140737188104128 >0x00000000009ecc42 in voidify_wrapper_expr (wrapper=0x7fffedb1fdb0, temp=0x0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1097 >1097 tree type = TREE_TYPE (wrapper); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188104128 >New value = 48 >0x00000000009ecc43 in voidify_wrapper_expr (wrapper=0x7fffedb1fdb0, temp=0x0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1097 >1097 tree type = TREE_TYPE (wrapper); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 48 >New value = -6399947259967866368 >0x00000000009ecc44 in voidify_wrapper_expr (wrapper=0x7fffedb1fdb0, temp=0x0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1097 >1097 tree type = TREE_TYPE (wrapper); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 1 >0x00000000009ecc48 in voidify_wrapper_expr (wrapper=0x7fffedb1fdb0, temp=0x0) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1097 >1097 tree type = TREE_TYPE (wrapper); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = -6399947259967866368 >0x00000000009ece23 in voidify_wrapper_expr (wrapper=<optimized out>, temp=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1172 >1172 *p = temp; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 48 >0x00000000009ece27 in voidify_wrapper_expr (wrapper=<optimized out>, temp=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1172 >1172 *p = temp; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 48 >New value = 140737188104128 >0x00000000009ece2b in voidify_wrapper_expr (wrapper=<optimized out>, temp=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1172 >1172 *p = temp; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188104128 >New value = 140737488343320 >0x00000000009ece2d in voidify_wrapper_expr (wrapper=<optimized out>, temp=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1172 >1172 *p = temp; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343320 >New value = 140737488343048 >0x00000000009fcd8e in gimplify_bind_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1342 >1342 tree temp = voidify_wrapper_expr (bind_expr, NULL); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343048 >New value = 140737488343320 >gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=0x7fffedb0cc00) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc.h:321 >321 return (gimple *) ggc_internal_cleared_alloc (s PASS_MEM_STAT); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343320 >New value = 140737188104128 >gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=0x7fffedb0cc00) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimple.c:585 >585 gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0)); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188104128 >New value = 48 >0x00000000009bd798 in gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=0x7fffedb0cc00) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc.h:321 >321 return (gimple *) ggc_internal_cleared_alloc (s PASS_MEM_STAT); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 48 >New value = -6399947259967866368 >0x00000000009bd79c in gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=0x7fffedb0cc00) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc.h:321 >321 return (gimple *) ggc_internal_cleared_alloc (s PASS_MEM_STAT); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 0 >ggc_internal_cleared_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-common.c:117 >117 void *buf = ggc_internal_alloc (size, f, s, n PASS_MEM_STAT); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = 1 >0x00000000009b9702 in ggc_internal_cleared_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-common.c:117 >117 void *buf = ggc_internal_alloc (size, f, s, n PASS_MEM_STAT); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = 140737488343312 >ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343312 >New value = 140737188118656 >0x000000000080de72 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188118656 >New value = 65771872 >0x000000000080de74 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 65771872 >New value = 0 >0x000000000080de76 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = 1 >0x000000000080de78 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = -6399947259967866368 >0x000000000080de79 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) l >1278 { >1279 size_t order, word, bit, object_offset, object_size; >1280 struct page_entry *entry; >1281 void *result; >1282 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >1284 >1285 /* If there are non-full pages for this size allocation, they are at >1286 the head of the list. */ >1287 entry = G.pages[order]; >(gdb) disassemble /s >Dump of assembler code for function ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long): >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c: >1218 ggc_round_alloc_size_1 (size_t requested_size, >1219 size_t *size_order, >1220 size_t *alloced_size) >1221 { >1222 size_t order, object_size; >1223 >1224 if (requested_size < NUM_SIZE_LOOKUP) >1225 { >1226 order = size_lookup[requested_size]; >1227 object_size = OBJECT_SIZE (order); >1228 } >1229 else >1230 { >1231 order = 10; >1232 while (requested_size > (object_size = OBJECT_SIZE (order))) >1233 order++; >1234 } >1235 >1236 if (size_order) >1237 *size_order = order; >1238 if (alloced_size) >1239 *alloced_size = object_size; >1240 } >1241 >1242 /* For a given size of memory requested for allocation, return the >1243 actual size that is going to be allocated. */ >1244 >1245 size_t >1246 ggc_round_alloc_size (size_t requested_size) >1247 { >1248 size_t size = 0; >1249 >1250 ggc_round_alloc_size_1 (requested_size, NULL, &size); >1251 return size; >1252 } >1253 >1254 /* Push a finalizer onto the appropriate vec. */ >1255 >1256 static void >1257 add_finalizer (void *result, void (*f)(void *), size_t s, size_t n) >1258 { >1259 if (f == NULL) >1260 /* No finalizer. */; >1261 else if (n == 1) >1262 { >1263 finalizer fin (result, f); >1264 G.finalizers[G.context_depth].safe_push (fin); >1265 } >1266 else >1267 { >1268 vec_finalizer fin (reinterpret_cast<uintptr_t> (result), f, s, n); >1269 G.vec_finalizers[G.context_depth].safe_push (fin); >1270 } >1271 } >1272 >1273 /* Allocate a chunk of memory of SIZE bytes. Its contents are undefined. */ >1274 >1275 void * >1276 ggc_internal_alloc (size_t size, void (*f)(void *), size_t s, size_t n >1277 MEM_STAT_DECL) >1278 { >1279 size_t order, word, bit, object_offset, object_size; >1280 struct page_entry *entry; >1281 void *result; >1282 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); > 0x000000000080de70 <+0>: push %r15 > 0x000000000080de72 <+2>: push %r14 > 0x000000000080de74 <+4>: push %r13 > 0x000000000080de76 <+6>: push %r12 > 0x000000000080de78 <+8>: push %rbp >=> 0x000000000080de79 <+9>: push %rbx > 0x000000000080de7a <+10>: sub $0x58,%rsp > 0x000000000080de7e <+14>: mov %rsi,(%rsp) > 0x000000000080de82 <+18>: mov %rdx,0x10(%rsp) > 0x000000000080de87 <+23>: mov %rcx,0x8(%rsp) > 0x000000000080de8c <+28>: cmp $0x1ff,%rdi > 0x000000000080de93 <+35>: ja 0x80e0c0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+592> > >1226 order = size_lookup[requested_size]; > 0x000000000080de99 <+41>: movzbl 0x2085000(%rdi),%ebx > >1227 object_size = OBJECT_SIZE (order); > 0x000000000080dea0 <+48>: mov 0x2092b60(,%rbx,8),%rbp > >1284 >1285 /* If there are non-full pages for this size allocation, they are at >1286 the head of the list. */ >1287 entry = G.pages[order]; > 0x000000000080dea8 <+56>: mov 0x2091ac0(,%rbx,8),%r12 > >1288 >1289 /* If there is no page for this object size, or all pages in this >1290 context are full, allocate a new page. */ >1291 if (entry == NULL || entry->num_free_objects == 0) > 0x000000000080deb0 <+64>: test %r12,%r12 > 0x000000000080deb3 <+67>: je 0x80dec4 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+84> > 0x000000000080deb5 <+69>: movzwl 0x2a(%r12),%esi > 0x000000000080debb <+75>: test %si,%si > 0x000000000080debe <+78>: jne 0x80e110 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+672> > >1292 { >1293 struct page_entry *new_entry; >1294 new_entry = alloc_page (order); > 0x000000000080dec4 <+84>: mov %ebx,%edx > 0x000000000080dec6 <+86>: mov 0x188413b(%rip),%rsi # 0x2092008 <_ZL1G+1352> > 0x000000000080decd <+93>: mov 0x1884174(%rip),%r11 # 0x2092048 <_ZL1G+1416> > 0x000000000080ded4 <+100>: mov %ebx,%edi > >774 num_objects = OBJECTS_PER_PAGE (order); > 0x000000000080ded6 <+102>: mov 0x2092e00(,%rdx,4),%ecx > 0x000000000080dedd <+109>: mov %rsi,%r10 > 0x000000000080dee0 <+112>: lea 0x40(%rcx),%rax > 0x000000000080dee4 <+116>: mov %ecx,0x24(%rsp) > 0x000000000080dee8 <+120>: mov %rcx,0x28(%rsp) > >775 bitmap_size = BITMAP_SIZE (num_objects + 1); >776 page_entry_size = sizeof (page_entry) - sizeof (long) + bitmap_size; > 0x000000000080deed <+125>: shr $0x6,%rax > 0x000000000080def1 <+129>: lea 0x30(,%rax,8),%rax > 0x000000000080def9 <+137>: mov %rax,0x18(%rsp) > >777 entry_size = num_objects * OBJECT_SIZE (order); > 0x000000000080defe <+142>: mov 0x2092b60(,%rdx,8),%rax > 0x000000000080df06 <+150>: imul %rcx,%rax > >778 if (entry_size < G.pagesize) >779 entry_size = G.pagesize; >780 entry_size = PAGE_ALIGN (entry_size); > 0x000000000080df0a <+154>: cmp %rsi,%rax > 0x000000000080df0d <+157>: cmovb %rsi,%rax > 0x000000000080df11 <+161>: neg %r10 > 0x000000000080df14 <+164>: lea -0x1(%rsi,%rax,1),%rax > 0x000000000080df19 <+169>: and %rax,%r10 > 0x000000000080df1c <+172>: mov %r10,%r14 > >781 >782 entry = NULL; >783 page = NULL; >784 >785 /* Check the list of free pages for one we can use. */ >786 for (pp = &G.free_pages, p = *pp; p; pp = &p->next, p = *pp) > 0x000000000080df1f <+175>: test %r11,%r11 > 0x000000000080df22 <+178>: je 0x80e350 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1248> > 0x000000000080df28 <+184>: mov %r11,%rax > 0x000000000080df2b <+187>: mov $0x2092048,%ecx > 0x000000000080df30 <+192>: jmp 0x80df4c <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+220> > 0x000000000080df32 <+194>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080df3d <+205>: nopl (%rax) > 0x000000000080df40 <+208>: mov %r15,%rcx > 0x000000000080df43 <+211>: test %rax,%rax > 0x000000000080df46 <+214>: je 0x80e350 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1248> > >787 if (p->bytes == entry_size) > 0x000000000080df4c <+220>: mov 0x10(%rax),%rdx > 0x000000000080df50 <+224>: mov %rax,%r15 > 0x000000000080df53 <+227>: mov (%rax),%rax > 0x000000000080df56 <+230>: cmp %rdx,%r14 > 0x000000000080df59 <+233>: jne 0x80df40 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+208> > >788 break; >789 >790 if (p != NULL) >791 { >792 if (p->discarded) > 0x000000000080df5b <+235>: cmpb $0x0,0x2f(%r15) > 0x000000000080df60 <+240>: je 0x80df69 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+249> > >793 G.bytes_mapped += p->bytes; > 0x000000000080df62 <+242>: add %r14,0x18840bf(%rip) # 0x2092028 <_ZL1G+1384> > >794 p->discarded = false; > 0x000000000080df69 <+249>: movb $0x0,0x2f(%r15) > >795 >796 /* Recycle the allocated memory from this page ... */ >797 *pp = p->next; > 0x000000000080df6e <+254>: mov 0x18(%r15),%r13 > 0x000000000080df72 <+258>: mov %rax,(%rcx) > >798 page = p->page; >799 >800 #ifdef USING_MALLOC_PAGE_GROUPS >801 group = p->group; >802 #endif >803 >804 /* ... and, if possible, the page entry itself. */ >805 if (p->order == order) > 0x000000000080df75 <+261>: mov %bl,0x30(%rsp) > 0x000000000080df79 <+265>: movzbl 0x2e(%r15),%eax > 0x000000000080df7e <+270>: cmp %eax,%edi > 0x000000000080df80 <+272>: je 0x80e3b0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1344> > >806 { >807 entry = p; >808 memset (entry, 0, page_entry_size); >809 } >810 else >811 free (p); > 0x000000000080df86 <+278>: mov %r15,%rdi > 0x000000000080df89 <+281>: callq 0x5be8c0 <free@plt> > >918 entry = XCNEWVAR (struct page_entry, page_entry_size); > 0x000000000080df8e <+286>: mov 0x18(%rsp),%rsi > 0x000000000080df93 <+291>: mov $0x1,%edi > 0x000000000080df98 <+296>: callq 0x161a130 <xcalloc> > 0x000000000080df9d <+301>: mov %rax,%r15 > >919 >920 entry->bytes = entry_size; > 0x000000000080dfa0 <+304>: movzbl 0x30(%rsp),%eax > 0x000000000080dfa5 <+309>: movzwl 0x1884094(%rip),%edx # 0x2092040 <_ZL1G+1408> > 0x000000000080dfac <+316>: mov %r14,0x10(%r15) > >921 entry->page = page; > 0x000000000080dfb0 <+320>: mov %r13,0x18(%r15) > >922 entry->context_depth = G.context_depth; > 0x000000000080dfb4 <+324>: movw $0x1,0x2c(%r15) > 0x000000000080dfbb <+331>: mov %r15,%rsi > 0x000000000080dfbe <+334>: mov 0x24(%rsp),%edi > 0x000000000080dfc2 <+338>: mov %al,0x2e(%r15) > 0x000000000080dfc6 <+342>: mov $0x1,%eax > 0x000000000080dfcb <+347>: mov %dx,0x28(%r15) > >923 entry->order = order; >924 entry->num_free_objects = num_objects; > 0x000000000080dfd0 <+352>: shlx %rdx,%rax,%rdx > 0x000000000080dfd5 <+357>: mov %di,0x2a(%r15) > >925 entry->next_bit_hint = 1; >926 >927 G.context_depth_allocations |= (unsigned long)1 << G.context_depth; > 0x000000000080dfda <+362>: or %rdx,0x188404f(%rip) # 0x2092030 <_ZL1G+1392> > >928 >929 #ifdef USING_MALLOC_PAGE_GROUPS >930 entry->group = group; >931 set_page_group_in_use (group, page); >932 #endif >933 >934 /* Set the one-past-the-end in-use bit. This acts as a sentry as we >935 increment the hint. */ >936 entry->in_use_p[num_objects / HOST_BITS_PER_LONG] > 0x000000000080dfe1 <+369>: mov 0x28(%rsp),%rdx > 0x000000000080dfe6 <+374>: shlx %rdi,%rax,%rax > 0x000000000080dfeb <+379>: mov %r13,%rdi > 0x000000000080dfee <+382>: shr $0x6,%rdx > 0x000000000080dff2 <+386>: mov %rax,0x30(%r15,%rdx,8) > >937 = (unsigned long) 1 << (num_objects % HOST_BITS_PER_LONG); >938 >939 set_page_table_entry (page, entry); > 0x000000000080dff7 <+391>: callq 0x80d5e0 <set_page_table_entry(void*, page_entry*)> > >1295 >1296 new_entry->index_by_depth = G.by_depth_in_use; > 0x000000000080dffc <+396>: mov 0x1884066(%rip),%eax # 0x2092068 <_ZL1G+1448> > 0x000000000080e002 <+402>: mov 0x1884064(%rip),%ecx # 0x209206c <_ZL1G+1452> > 0x000000000080e008 <+408>: mov %rax,%rdx > 0x000000000080e00b <+411>: mov %rax,0x20(%r15) > >1297 push_by_depth (new_entry, 0); > 0x000000000080e00f <+415>: cmp %ecx,%eax > 0x000000000080e011 <+417>: jae 0x80e2f0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1152> > 0x000000000080e017 <+423>: mov 0x188405a(%rip),%rcx # 0x2092078 <_ZL1G+1464> > >567 G.by_depth[G.by_depth_in_use] = p; > 0x000000000080e01e <+430>: mov 0x188404b(%rip),%rsi # 0x2092070 <_ZL1G+1456> > 0x000000000080e025 <+437>: shl $0x3,%rax > 0x000000000080e029 <+441>: inc %edx > 0x000000000080e02b <+443>: mov %r15,(%rsi,%rax,1) > >568 G.save_in_use[G.by_depth_in_use++] = s; > 0x000000000080e02f <+447>: mov %edx,0x1884033(%rip) # 0x2092068 <_ZL1G+1448> > 0x000000000080e035 <+453>: movq $0x0,(%rcx,%rax,1) > >1298 >1299 /* We can skip context depths, if we do, make sure we go all the >1300 way to the new depth. */ >1301 while (new_entry->context_depth >= G.depth_in_use) > 0x000000000080e03d <+461>: mov 0x1884015(%rip),%eax # 0x2092058 <_ZL1G+1432> > 0x000000000080e043 <+467>: movzwl 0x28(%r15),%ecx > 0x000000000080e048 <+472>: cmp %eax,%ecx > 0x000000000080e04a <+474>: jb 0x80e1a0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+816> > 0x000000000080e050 <+480>: mov 0x1884009(%rip),%rdi # 0x2092060 <_ZL1G+1440> > 0x000000000080e057 <+487>: mov %edx,%r13d > 0x000000000080e05a <+490>: jmp 0x80e082 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+530> > 0x000000000080e05c <+492>: nopl 0x0(%rax) > >552 G.depth[G.depth_in_use++] = i; > 0x000000000080e060 <+496>: lea 0x1(%rax),%edx > 0x000000000080e063 <+499>: mov %edx,0x1883fef(%rip) # 0x2092058 <_ZL1G+1432> > 0x000000000080e069 <+505>: mov %r13d,(%rdi,%rax,4) > >1298 >1299 /* We can skip context depths, if we do, make sure we go all the >1300 way to the new depth. */ >1301 while (new_entry->context_depth >= G.depth_in_use) > 0x000000000080e06d <+509>: mov 0x1883fe5(%rip),%eax # 0x2092058 <_ZL1G+1432> > 0x000000000080e073 <+515>: cmp %eax,%ecx > 0x000000000080e075 <+517>: jb 0x80e1a0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+816> > 0x000000000080e07b <+523>: mov 0x1883fe6(%rip),%r13d # 0x2092068 <_ZL1G+1448> > >1302 push_depth (G.by_depth_in_use-1); > 0x000000000080e082 <+530>: mov 0x1883fd4(%rip),%esi # 0x209205c <_ZL1G+1436> > 0x000000000080e088 <+536>: dec %r13d > >547 if (G.depth_in_use >= G.depth_max) > 0x000000000080e08b <+539>: cmp %eax,%esi > 0x000000000080e08d <+541>: ja 0x80e060 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+496> > >548 { >549 G.depth_max *= 2; > 0x000000000080e08f <+543>: add %esi,%esi > 0x000000000080e091 <+545>: mov %esi,0x1883fc5(%rip) # 0x209205c <_ZL1G+1436> > >550 G.depth = XRESIZEVEC (unsigned int, G.depth, G.depth_max); > 0x000000000080e097 <+551>: shl $0x2,%rsi > 0x000000000080e09b <+555>: callq 0x161a190 <xrealloc> > 0x000000000080e0a0 <+560>: mov %rax,%rdi > 0x000000000080e0a3 <+563>: mov %rax,0x1883fb6(%rip) # 0x2092060 <_ZL1G+1440> > 0x000000000080e0aa <+570>: movzwl 0x28(%r15),%ecx > 0x000000000080e0af <+575>: mov 0x1883fa3(%rip),%eax # 0x2092058 <_ZL1G+1432> > 0x000000000080e0b5 <+581>: jmp 0x80e060 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+496> > 0x000000000080e0b7 <+583>: nopw 0x0(%rax,%rax,1) > >1228 } >1229 else >1230 { >1231 order = 10; >1232 while (requested_size > (object_size = OBJECT_SIZE (order))) > 0x000000000080e0c0 <+592>: mov 0x1884ae9(%rip),%rbp # 0x2092bb0 <_ZL17object_size_table+80> > 0x000000000080e0c7 <+599>: mov $0xa,%ebx > 0x000000000080e0cc <+604>: cmp %rbp,%rdi > 0x000000000080e0cf <+607>: jbe 0x80dea8 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+56> > 0x000000000080e0d5 <+613>: data16 nopw %cs:0x0(%rax,%rax,1) > >1233 order++; > 0x000000000080e0e0 <+624>: inc %rbx > >1232 while (requested_size > (object_size = OBJECT_SIZE (order))) > 0x000000000080e0e3 <+627>: mov 0x2092b60(,%rbx,8),%rbp > 0x000000000080e0eb <+635>: cmp %rbp,%rdi > 0x000000000080e0ee <+638>: jbe 0x80dea8 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+56> > >1233 order++; > 0x000000000080e0f4 <+644>: inc %rbx > >1232 while (requested_size > (object_size = OBJECT_SIZE (order))) > 0x000000000080e0f7 <+647>: mov 0x2092b60(,%rbx,8),%rbp > 0x000000000080e0ff <+655>: cmp %rbp,%rdi > 0x000000000080e102 <+658>: ja 0x80e0e0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+624> > 0x000000000080e104 <+660>: jmpq 0x80dea8 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+56> > 0x000000000080e109 <+665>: nopl 0x0(%rax) > >1325 } >1326 else >1327 { >1328 /* First try to use the hint left from the previous allocation >1329 to locate a clear bit in the in-use bitmap. We've made sure >1330 that the one-past-the-end bit is always set, so if the hint >1331 has run over, this test will fail. */ >1332 unsigned hint = entry->next_bit_hint; > 0x000000000080e110 <+672>: movzwl 0x2c(%r12),%ecx > 0x000000000080e116 <+678>: mov %ecx,%edx > 0x000000000080e118 <+680>: mov %ecx,%r8d > 0x000000000080e11b <+683>: mov %ecx,%edi > >1333 word = hint / HOST_BITS_PER_LONG; > 0x000000000080e11d <+685>: shr $0x6,%edx > >1334 bit = hint % HOST_BITS_PER_LONG; >1335 >1336 /* If the hint didn't work, scan the bitmap from the beginning. */ >1337 if ((entry->in_use_p[word] >> bit) & 1) > 0x000000000080e120 <+688>: and $0x3f,%r8d > 0x000000000080e124 <+692>: add $0x4,%rdx > 0x000000000080e128 <+696>: mov 0x10(%r12,%rdx,8),%rax > 0x000000000080e12d <+701>: bt %rcx,%rax > 0x000000000080e131 <+705>: jae 0x80e177 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+775> > >1338 { >1339 word = bit = 0; >1340 while (~entry->in_use_p[word] == 0) > 0x000000000080e133 <+707>: mov 0x30(%r12),%rax > 0x000000000080e138 <+712>: cmp $0xffffffffffffffff,%rax > 0x000000000080e13c <+716>: jne 0x80e6de <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2158> > 0x000000000080e142 <+722>: xor %edx,%edx > 0x000000000080e144 <+724>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e14f <+735>: nop > >1341 ++word; > 0x000000000080e150 <+736>: inc %rdx > >1340 while (~entry->in_use_p[word] == 0) > 0x000000000080e153 <+739>: mov 0x30(%r12,%rdx,8),%rax > 0x000000000080e158 <+744>: cmp $0xffffffffffffffff,%rax > 0x000000000080e15c <+748>: je 0x80e150 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+736> > 0x000000000080e15e <+750>: mov %edx,%ecx > 0x000000000080e160 <+752>: shl $0x6,%ecx > >1342 >1343 #if GCC_VERSION >= 3004 >1344 bit = __builtin_ctzl (~entry->in_use_p[word]); > 0x000000000080e163 <+755>: mov %rax,%r8 > 0x000000000080e166 <+758>: add $0x4,%rdx > 0x000000000080e16a <+762>: not %r8 > 0x000000000080e16d <+765>: tzcnt %r8,%r8 > >1345 #else >1346 while ((entry->in_use_p[word] >> bit) & 1) >1347 ++bit; >1348 #endif >1349 >1350 hint = word * HOST_BITS_PER_LONG + bit; > 0x000000000080e172 <+770>: add %r8d,%ecx > 0x000000000080e175 <+773>: mov %ecx,%edi > >1351 } >1352 >1353 /* Next time, try the next bit. */ >1354 entry->next_bit_hint = hint + 1; > 0x000000000080e177 <+775>: inc %edi > 0x000000000080e179 <+777>: mov %ecx,%ecx > 0x000000000080e17b <+779>: mov %r12,%r15 > 0x000000000080e17e <+782>: mov %di,0x2c(%r12) > >1355 >1356 object_offset = hint * object_size; > 0x000000000080e184 <+788>: imul %rbp,%rcx > 0x000000000080e188 <+792>: mov $0x1,%edi > 0x000000000080e18d <+797>: shlx %r8,%rdi,%rdi > 0x000000000080e192 <+802>: jmp 0x80e1dd <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+877> > 0x000000000080e194 <+804>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e19f <+815>: nop > >1307 if (entry == NULL) > 0x000000000080e1a0 <+816>: test %r12,%r12 > 0x000000000080e1a3 <+819>: je 0x80e3a0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1328> > >1309 else >1310 entry->prev = new_entry; > 0x000000000080e1a9 <+825>: mov %r15,0x8(%r12) > >1311 >1312 /* Put new pages at the head of the page list. By definition the >1313 entry at the head of the list always has a NULL pointer. */ >1314 new_entry->next = entry; > 0x000000000080e1ae <+830>: mov 0x30(%r15),%rax > 0x000000000080e1b2 <+834>: mov %r12,(%r15) > >1315 new_entry->prev = NULL; > 0x000000000080e1b5 <+837>: movq $0x0,0x8(%r15) > >1316 entry = new_entry; >1317 G.pages[order] = new_entry; > 0x000000000080e1bd <+845>: mov $0x1,%edi > 0x000000000080e1c2 <+850>: mov %r15,0x2091ac0(,%rbx,8) > >1318 >1319 /* For a new page, we know the word and bit positions (in the >1320 in_use bitmap) of the first available object -- they're zero. */ >1321 new_entry->next_bit_hint = 1; > 0x000000000080e1ca <+858>: xor %ecx,%ecx > 0x000000000080e1cc <+860>: movw $0x1,0x2c(%r15) > >1322 word = 0; >1323 bit = 0; >1324 object_offset = 0; > 0x000000000080e1d3 <+867>: mov $0x4,%edx > 0x000000000080e1d8 <+872>: movzwl 0x2a(%r15),%esi > >1357 } >1358 >1359 /* Set the in-use bit. */ >1360 entry->in_use_p[word] |= ((unsigned long) 1 << bit); > 0x000000000080e1dd <+877>: or %rdi,%rax > 0x000000000080e1e0 <+880>: dec %esi > 0x000000000080e1e2 <+882>: mov %rax,0x10(%r15,%rdx,8) > >1361 >1362 /* Keep a running total of the number of free objects. If this page >1363 fills up, we may have to move it to the end of the list if the >1364 next page isn't full. If the next page is full, all subsequent >1365 pages are full, so there's no need to move it. */ >1366 if (--entry->num_free_objects == 0 > 0x000000000080e1e7 <+887>: mov %si,0x2a(%r15) > 0x000000000080e1ec <+892>: test %si,%si > 0x000000000080e1ef <+895>: jne 0x80e210 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+928> > 0x000000000080e1f1 <+897>: mov (%r15),%rax > 0x000000000080e1f4 <+900>: test %rax,%rax > 0x000000000080e1f7 <+903>: je 0x80e210 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+928> > 0x000000000080e1f9 <+905>: cmpw $0x0,0x2a(%rax) > 0x000000000080e1fe <+910>: jne 0x80e2b0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1088> > 0x000000000080e204 <+916>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e20f <+927>: nop > >1383 } >1384 >1385 /* Calculate the object's address. */ >1386 result = entry->page + object_offset; > 0x000000000080e210 <+928>: add 0x18(%r15),%rcx > 0x000000000080e214 <+932>: add %rbp,0x3087b35(%rip) # 0x3895d50 <timevar_ggc_mem_total> > 0x000000000080e21b <+939>: add %rbp,0x1883df6(%rip) # 0x2092018 <_ZL1G+1368> > 0x000000000080e222 <+946>: cmpq $0x0,(%rsp) > 0x000000000080e227 <+951>: mov %rcx,%r12 > >1387 if (GATHER_STATISTICS) >1388 ggc_record_overhead (OBJECT_SIZE (order), OBJECT_SIZE (order) - size, >1389 result FINAL_PASS_MEM_STAT); >1390 >1391 #ifdef ENABLE_GC_CHECKING >1392 /* Keep poisoning-by-writing-0xaf the object, in an attempt to keep the >1393 exact same semantics in presence of memory bugs, regardless of >1394 ENABLE_VALGRIND_CHECKING. We override this request below. Drop the >1395 handle to avoid handle leak. */ >1396 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (result, object_size)); >1397 >1398 /* `Poison' the entire allocated object, including any padding at >1399 the end. */ >1400 memset (result, 0xaf, object_size); >1401 >1402 /* Make the bytes after the end of the object unaccessible. Discard the >1403 handle to avoid handle leak. */ >1404 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_NOACCESS ((char *) result + size, >1405 object_size - size)); >1406 #endif >1407 >1408 /* Tell Valgrind that the memory is there, but its content isn't >1409 defined. The bytes at the end of the object are still marked >1410 unaccessible. */ >1411 VALGRIND_DISCARD (VALGRIND_MAKE_MEM_UNDEFINED (result, size)); >1412 >1413 /* Keep track of how many bytes are being allocated. This >1414 information is used in deciding when to collect. */ >1415 G.allocated += object_size; >1416 >1417 /* For timevar statistics. */ >1418 timevar_ggc_mem_total += object_size; >1419 >1420 if (f) > 0x000000000080e22a <+954>: je 0x80e295 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1061> > >1421 add_finalizer (result, f, s, n); > 0x000000000080e22c <+956>: cmpq $0x1,0x8(%rsp) > 0x000000000080e232 <+962>: movzwl 0x1883e06(%rip),%r13d # 0x2092040 <_ZL1G+1408> > 0x000000000080e23a <+970>: je 0x80e3d0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1376> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/vec.h: >1432 T &operator[] (unsigned ix) > 0x000000000080e240 <+976>: mov 0x1883e41(%rip),%r15 # 0x2092088 <_ZL1G+1480> > >1831 { >1832 return m_vec->quick_push (obj); >1833 } >1834 >1835 >1836 /* Push a new element OBJ onto the end of this vector. Reallocates >1837 the embedded vector, if needed. Return a pointer to the slot where >1838 OBJ was inserted. */ >1839 >1840 template<typename T> >1841 inline T * >1842 vec<T, va_heap, vl_ptr>::safe_push (const T &obj MEM_STAT_DECL) > 0x000000000080e247 <+983>: mov 0x8(%r15,%r13,8),%rbx > 0x000000000080e24c <+988>: test %rbx,%rbx > 0x000000000080e24f <+991>: je 0x80e62d <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1981> > >891 vec<T, A, vl_embed>::space (unsigned nelems) const > 0x000000000080e255 <+997>: mov (%rbx),%eax > 0x000000000080e257 <+999>: mov 0x4(%rbx),%ebp > 0x000000000080e25a <+1002>: and $0x7fffffff,%eax > 0x000000000080e25f <+1007>: lea 0x1(%rbp),%r14d > 0x000000000080e263 <+1011>: cmp %ebp,%eax > 0x000000000080e265 <+1013>: je 0x80e420 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1456> > >1433 { return (*m_vec)[ix]; } >1434 >1435 T &last (void) >1436 { return m_vec->last (); } >1437 >1438 bool space (int nelems) const >1439 { return m_vec ? m_vec->space (nelems) : nelems == 0; } >1440 >1441 bool iterate (unsigned ix, T *p) const; >1442 bool iterate (unsigned ix, T **p) const; >1443 vec copy (ALONE_CXX_MEM_STAT_INFO) const; >1444 bool reserve (unsigned, bool = false CXX_MEM_STAT_INFO); >1445 bool reserve_exact (unsigned CXX_MEM_STAT_INFO); >1446 void splice (const vec &); >1447 void safe_splice (const vec & CXX_MEM_STAT_INFO); >1448 T *quick_push (const T &); >1449 T *safe_push (const T &CXX_MEM_STAT_INFO); >1450 T &pop (void); >1451 void truncate (unsigned); >1452 void safe_grow (unsigned CXX_MEM_STAT_INFO); >1453 void safe_grow_cleared (unsigned CXX_MEM_STAT_INFO); >1454 void quick_grow (unsigned); >1455 void quick_grow_cleared (unsigned); >1456 void quick_insert (unsigned, const T &); >1457 void safe_insert (unsigned, const T & CXX_MEM_STAT_INFO); >1458 void ordered_remove (unsigned); >1459 void unordered_remove (unsigned); >1460 void block_remove (unsigned, unsigned); >1461 void qsort (int (*) (const void *, const void *)); >1462 void sort (int (*) (const void *, const void *, void *), void *); >1463 T *bsearch (const void *key, int (*compar)(const void *, const void *)); >1464 T *bsearch (const void *key, >1465 int (*compar)(const void *, const void *, void *), void *); >1466 unsigned lower_bound (T, bool (*)(const T &, const T &)) const; >1467 bool contains (const T &search) const; >1468 void reverse (void); >1469 >1470 bool using_auto_storage () const; >1471 >1472 /* FIXME - This field should be private, but we need to cater to >1473 compilers that have stricter notions of PODness for types. */ >1474 vec<T, va_heap, vl_embed> *m_vec; >1475 }; >1476 >1477 >1478 /* auto_vec is a subclass of vec that automatically manages creating and >1479 releasing the internal vector. If N is non zero then it has N elements of >1480 internal storage. The default is no internal storage, and you probably only >1481 want to ask for internal storage for vectors on the stack because if the >1482 size of the vector is larger than the internal storage that space is wasted. >1483 */ >1484 template<typename T, size_t N = 0> >1485 class auto_vec : public vec<T, va_heap> >1486 { >1487 public: >1488 auto_vec () >1489 { >1490 m_auto.embedded_init (MAX (N, 2), 0, 1); >1491 this->m_vec = &m_auto; >1492 } >1493 >1494 auto_vec (size_t s) >1495 { >1496 if (s > N) >1497 { >1498 this->create (s); >1499 return; >1500 } >1501 >1502 m_auto.embedded_init (MAX (N, 2), 0, 1); >1503 this->m_vec = &m_auto; >1504 } >1505 >1506 ~auto_vec () >1507 { >1508 this->release (); >1509 } >1510 >1511 private: >1512 vec<T, va_heap, vl_embed> m_auto; >1513 T m_data[MAX (N - 1, 1)]; >1514 }; >1515 >1516 /* auto_vec is a sub class of vec whose storage is released when it is >1517 destroyed. */ >1518 template<typename T> >1519 class auto_vec<T, 0> : public vec<T, va_heap> >1520 { >1521 public: >1522 auto_vec () { this->m_vec = NULL; } >1523 auto_vec (size_t n) { this->create (n); } >1524 ~auto_vec () { this->release (); } >1525 }; >1526 >1527 >1528 /* Allocate heap memory for pointer V and create the internal vector >1529 with space for NELEMS elements. If NELEMS is 0, the internal >1530 vector is initialized to empty. */ >1531 >1532 template<typename T> >1533 inline void >1534 vec_alloc (vec<T> *&v, unsigned nelems CXX_MEM_STAT_INFO) >1535 { >1536 v = new vec<T>; >1537 v->create (nelems PASS_MEM_STAT); >1538 } >1539 >1540 >1541 /* A subclass of auto_vec <char *> that frees all of its elements on >1542 deletion. */ >1543 >1544 class auto_string_vec : public auto_vec <char *> >1545 { >1546 public: >1547 ~auto_string_vec (); >1548 }; >1549 >1550 /* A subclass of auto_vec <T *> that deletes all of its elements on >1551 destruction. >1552 >1553 This is a crude way for a vec to "own" the objects it points to >1554 and clean up automatically. >1555 >1556 For example, no attempt is made to delete elements when an item >1557 within the vec is overwritten. >1558 >1559 We can't rely on gnu::unique_ptr within a container, >1560 since we can't rely on move semantics in C++98. */ >1561 >1562 template <typename T> >1563 class auto_delete_vec : public auto_vec <T *> >1564 { >1565 public: >1566 auto_delete_vec () {} >1567 auto_delete_vec (size_t s) : auto_vec <T *> (s) {} >1568 >1569 ~auto_delete_vec (); >1570 >1571 private: >1572 DISABLE_COPY_AND_ASSIGN(auto_delete_vec<T>); >1573 }; >1574 >1575 /* Conditionally allocate heap memory for VEC and its internal vector. */ >1576 >1577 template<typename T> >1578 inline void >1579 vec_check_alloc (vec<T, va_heap> *&vec, unsigned nelems CXX_MEM_STAT_INFO) >1580 { >1581 if (!vec) >1582 vec_alloc (vec, nelems PASS_MEM_STAT); >1583 } >1584 >1585 >1586 /* Free the heap memory allocated by vector V and set it to NULL. */ >1587 >1588 template<typename T> >1589 inline void >1590 vec_free (vec<T> *&v) >1591 { >1592 if (v == NULL) >1593 return; >1594 >1595 v->release (); >1596 delete v; >1597 v = NULL; >1598 } >1599 >1600 >1601 /* Return iteration condition and update PTR to point to the IX'th >1602 element of this vector. Use this to iterate over the elements of a >1603 vector as follows, >1604 >1605 for (ix = 0; v.iterate (ix, &ptr); ix++) >1606 continue; */ >1607 >1608 template<typename T> >1609 inline bool >1610 vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T *ptr) const >1611 { >1612 if (m_vec) >1613 return m_vec->iterate (ix, ptr); >1614 else >1615 { >1616 *ptr = 0; >1617 return false; >1618 } >1619 } >1620 >1621 >1622 /* Return iteration condition and update *PTR to point to the >1623 IX'th element of this vector. Use this to iterate over the >1624 elements of a vector as follows, >1625 >1626 for (ix = 0; v->iterate (ix, &ptr); ix++) >1627 continue; >1628 >1629 This variant is for vectors of objects. */ >1630 >1631 template<typename T> >1632 inline bool >1633 vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T **ptr) const >1634 { >1635 if (m_vec) >1636 return m_vec->iterate (ix, ptr); >1637 else >1638 { >1639 *ptr = 0; >1640 return false; >1641 } >1642 } >1643 >1644 >1645 /* Convenience macro for forward iteration. */ >1646 #define FOR_EACH_VEC_ELT(V, I, P) \ >1647 for (I = 0; (V).iterate ((I), &(P)); ++(I)) >1648 >1649 #define FOR_EACH_VEC_SAFE_ELT(V, I, P) \ >1650 for (I = 0; vec_safe_iterate ((V), (I), &(P)); ++(I)) >1651 >1652 /* Likewise, but start from FROM rather than 0. */ >1653 #define FOR_EACH_VEC_ELT_FROM(V, I, P, FROM) \ >1654 for (I = (FROM); (V).iterate ((I), &(P)); ++(I)) >1655 >1656 /* Convenience macro for reverse iteration. */ >1657 #define FOR_EACH_VEC_ELT_REVERSE(V, I, P) \ >1658 for (I = (V).length () - 1; \ >1659 (V).iterate ((I), &(P)); \ >1660 (I)--) >1661 >1662 #define FOR_EACH_VEC_SAFE_ELT_REVERSE(V, I, P) \ >1663 for (I = vec_safe_length (V) - 1; \ >1664 vec_safe_iterate ((V), (I), &(P)); \ >1665 (I)--) >1666 >1667 /* auto_string_vec's dtor, freeing all contained strings, automatically >1668 chaining up to ~auto_vec <char *>, which frees the internal buffer. */ >1669 >1670 inline >1671 auto_string_vec::~auto_string_vec () >1672 { >1673 int i; >1674 char *str; >1675 FOR_EACH_VEC_ELT (*this, i, str) >1676 free (str); >1677 } >1678 >1679 /* auto_delete_vec's dtor, deleting all contained items, automatically >1680 chaining up to ~auto_vec <T*>, which frees the internal buffer. */ >1681 >1682 template <typename T> >1683 inline >1684 auto_delete_vec<T>::~auto_delete_vec () >1685 { >1686 int i; >1687 T *item; >1688 FOR_EACH_VEC_ELT (*this, i, item) >1689 delete item; >1690 } >1691 >1692 >1693 /* Return a copy of this vector. */ >1694 >1695 template<typename T> >1696 inline vec<T, va_heap, vl_ptr> >1697 vec<T, va_heap, vl_ptr>::copy (ALONE_MEM_STAT_DECL) const >1698 { >1699 vec<T, va_heap, vl_ptr> new_vec = vNULL; >1700 if (length ()) >1701 new_vec.m_vec = m_vec->copy (); >1702 return new_vec; >1703 } >1704 >1705 >1706 /* Ensure that the vector has at least RESERVE slots available (if >1707 EXACT is false), or exactly RESERVE slots available (if EXACT is >1708 true). >1709 >1710 This may create additional headroom if EXACT is false. >1711 >1712 Note that this can cause the embedded vector to be reallocated. >1713 Returns true iff reallocation actually occurred. */ >1714 >1715 template<typename T> >1716 inline bool >1717 vec<T, va_heap, vl_ptr>::reserve (unsigned nelems, bool exact MEM_STAT_DECL) >1718 { >1719 if (space (nelems)) >1720 return false; >1721 >1722 /* For now play a game with va_heap::reserve to hide our auto storage if any, >1723 this is necessary because it doesn't have enough information to know the >1724 embedded vector is in auto storage, and so should not be freed. */ >1725 vec<T, va_heap, vl_embed> *oldvec = m_vec; >1726 unsigned int oldsize = 0; >1727 bool handle_auto_vec = m_vec && using_auto_storage (); >1728 if (handle_auto_vec) >1729 { >1730 m_vec = NULL; >1731 oldsize = oldvec->length (); >1732 nelems += oldsize; >1733 } >1734 >1735 va_heap::reserve (m_vec, nelems, exact PASS_MEM_STAT); >1736 if (handle_auto_vec) >1737 { >1738 vec_copy_construct (m_vec->address (), oldvec->address (), oldsize); >1739 m_vec->m_vecpfx.m_num = oldsize; >1740 } >1741 >1742 return true; >1743 } >1744 >1745 >1746 /* Ensure that this vector has exactly NELEMS slots available. This >1747 will not create additional headroom. Note this can cause the >1748 embedded vector to be reallocated. Returns true iff reallocation >1749 actually occurred. */ >1750 >1751 template<typename T> >1752 inline bool >1753 vec<T, va_heap, vl_ptr>::reserve_exact (unsigned nelems MEM_STAT_DECL) >1754 { >1755 return reserve (nelems, true PASS_MEM_STAT); >1756 } >1757 >1758 >1759 /* Create the internal vector and reserve NELEMS for it. This is >1760 exactly like vec::reserve, but the internal vector is >1761 unconditionally allocated from scratch. The old one, if it >1762 existed, is lost. */ >1763 >1764 template<typename T> >1765 inline void >1766 vec<T, va_heap, vl_ptr>::create (unsigned nelems MEM_STAT_DECL) >1767 { >1768 m_vec = NULL; >1769 if (nelems > 0) >1770 reserve_exact (nelems PASS_MEM_STAT); >1771 } >1772 >1773 >1774 /* Free the memory occupied by the embedded vector. */ >1775 >1776 template<typename T> >1777 inline void >1778 vec<T, va_heap, vl_ptr>::release (void) >1779 { >1780 if (!m_vec) >1781 return; >1782 >1783 if (using_auto_storage ()) >1784 { >1785 m_vec->m_vecpfx.m_num = 0; >1786 return; >1787 } >1788 >1789 va_heap::release (m_vec); >1790 } >1791 >1792 /* Copy the elements from SRC to the end of this vector as if by memcpy. >1793 SRC and this vector must be allocated with the same memory >1794 allocation mechanism. This vector is assumed to have sufficient >1795 headroom available. */ >1796 >1797 template<typename T> >1798 inline void >1799 vec<T, va_heap, vl_ptr>::splice (const vec<T, va_heap, vl_ptr> &src) >1800 { >1801 if (src.length ()) >1802 m_vec->splice (*(src.m_vec)); >1803 } >1804 >1805 >1806 /* Copy the elements in SRC to the end of this vector as if by memcpy. >1807 SRC and this vector must be allocated with the same mechanism. >1808 If there is not enough headroom in this vector, it will be reallocated >1809 as needed. */ >1810 >1811 template<typename T> >1812 inline void >1813 vec<T, va_heap, vl_ptr>::safe_splice (const vec<T, va_heap, vl_ptr> &src >1814 MEM_STAT_DECL) >1815 { >1816 if (src.length ()) >1817 { >1818 reserve_exact (src.length ()); >1819 splice (src); >1820 } >1821 } >1822 >1823 >1824 /* Push OBJ (a new element) onto the end of the vector. There must be >1825 sufficient space in the vector. Return a pointer to the slot >1826 where OBJ was inserted. */ >1827 >1828 template<typename T> >1829 inline T * >1830 vec<T, va_heap, vl_ptr>::quick_push (const T &obj) > 0x000000000080e26b <+1019>: shl $0x5,%rbp > 0x000000000080e26f <+1023>: mov %r14d,0x4(%rbx) > 0x000000000080e273 <+1027>: lea (%rbx,%rbp,1),%rax > 0x000000000080e277 <+1031>: mov (%rsp),%rbx > 0x000000000080e27b <+1035>: mov %r12,0x8(%rax) > 0x000000000080e27f <+1039>: mov %rbx,0x10(%rax) > 0x000000000080e283 <+1043>: mov 0x10(%rsp),%rbx > 0x000000000080e288 <+1048>: mov %rbx,0x18(%rax) > 0x000000000080e28c <+1052>: mov 0x8(%rsp),%rbx > 0x000000000080e291 <+1057>: mov %rbx,0x20(%rax) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c: >1455 return result; > 0x000000000080e295 <+1061>: add $0x58,%rsp > 0x000000000080e299 <+1065>: mov %r12,%rax > 0x000000000080e29c <+1068>: pop %rbx > 0x000000000080e29d <+1069>: pop %rbp > 0x000000000080e29e <+1070>: pop %r12 > 0x000000000080e2a0 <+1072>: pop %r13 > 0x000000000080e2a2 <+1074>: pop %r14 > 0x000000000080e2a4 <+1076>: pop %r15 > 0x000000000080e2a6 <+1078>: retq > 0x000000000080e2a7 <+1079>: nopw 0x0(%rax,%rax,1) > >1371 G.pages[order] = entry->next; > 0x000000000080e2b0 <+1088>: mov %rax,0x2091ac0(,%rbx,8) > >1372 >1373 /* We are moving ENTRY to the end of the page table list. >1374 The new page at the head of the list will have NULL in >1375 its PREV field and ENTRY will have NULL in its NEXT field. */ >1376 entry->next->prev = NULL; > 0x000000000080e2b8 <+1096>: add $0x54,%rbx > 0x000000000080e2bc <+1100>: movq $0x0,0x8(%rax) > >1377 entry->next = NULL; > 0x000000000080e2c4 <+1108>: movq $0x0,(%r15) > >1378 >1379 /* Append ENTRY to the tail of the list. */ >1380 entry->prev = G.page_tails[order]; > 0x000000000080e2cb <+1115>: mov 0x2091ac0(,%rbx,8),%rax > 0x000000000080e2d3 <+1123>: mov %rax,0x8(%r15) > >1381 G.page_tails[order]->next = entry; > 0x000000000080e2d7 <+1127>: mov %r15,(%rax) > >1382 G.page_tails[order] = entry; > 0x000000000080e2da <+1130>: mov %r15,0x2091ac0(,%rbx,8) > 0x000000000080e2e2 <+1138>: jmpq 0x80e210 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+928> > 0x000000000080e2e7 <+1143>: nopw 0x0(%rax,%rax,1) > >562 G.by_depth_max *= 2; > 0x000000000080e2f0 <+1152>: mov 0x1883d79(%rip),%rdi # 0x2092070 <_ZL1G+1456> > 0x000000000080e2f7 <+1159>: add %ecx,%ecx > 0x000000000080e2f9 <+1161>: lea 0x0(,%rcx,8),%rsi > 0x000000000080e301 <+1169>: mov %ecx,0x1883d65(%rip) # 0x209206c <_ZL1G+1452> > >563 G.by_depth = XRESIZEVEC (page_entry *, G.by_depth, G.by_depth_max); > 0x000000000080e307 <+1175>: callq 0x161a190 <xrealloc> > 0x000000000080e30c <+1180>: mov 0x1883d5a(%rip),%esi # 0x209206c <_ZL1G+1452> > 0x000000000080e312 <+1186>: mov 0x1883d5f(%rip),%rdi # 0x2092078 <_ZL1G+1464> > 0x000000000080e319 <+1193>: mov %rax,0x1883d50(%rip) # 0x2092070 <_ZL1G+1456> > >564 G.save_in_use = XRESIZEVEC (unsigned long *, G.save_in_use, > 0x000000000080e320 <+1200>: shl $0x3,%rsi > 0x000000000080e324 <+1204>: callq 0x161a190 <xrealloc> > 0x000000000080e329 <+1209>: mov %rax,%rcx > 0x000000000080e32c <+1212>: mov %rax,0x1883d45(%rip) # 0x2092078 <_ZL1G+1464> > 0x000000000080e333 <+1219>: mov 0x1883d2f(%rip),%eax # 0x2092068 <_ZL1G+1448> > 0x000000000080e339 <+1225>: mov %rax,%rdx > 0x000000000080e33c <+1228>: jmpq 0x80e01e <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+430> > 0x000000000080e341 <+1233>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e34c <+1244>: nopl 0x0(%rax) > >812 } >813 #ifdef USING_MMAP >814 else if (entry_size == G.pagesize) > 0x000000000080e350 <+1248>: cmp %r14,%rsi > 0x000000000080e353 <+1251>: je 0x80e500 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1680> > >842 } >843 else >844 page = alloc_anon (NULL, entry_size, true); > 0x000000000080e359 <+1257>: xor %r9d,%r9d > 0x000000000080e35c <+1260>: mov $0xffffffff,%r8d > 0x000000000080e362 <+1266>: mov $0x22,%ecx > 0x000000000080e367 <+1271>: mov $0x3,%edx > 0x000000000080e36c <+1276>: mov %r14,%rsi > 0x000000000080e36f <+1279>: xor %edi,%edi > 0x000000000080e371 <+1281>: callq 0x5bee20 <mmap@plt> > 0x000000000080e376 <+1286>: mov %rax,%r13 > >714 if (page == (char *) MAP_FAILED) > 0x000000000080e379 <+1289>: cmp $0xffffffffffffffff,%rax > 0x000000000080e37d <+1293>: je 0x80e72e <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2238> > >717 return NULL; >718 perror ("virtual memory exhausted"); >719 exit (FATAL_EXIT_CODE); >720 } >721 >722 /* Remember that we allocated this memory. */ >723 G.bytes_mapped += size; > 0x000000000080e383 <+1299>: add %r14,0x1883c9e(%rip) # 0x2092028 <_ZL1G+1384> > >845 #endif >846 #ifdef USING_MALLOC_PAGE_GROUPS >847 else >848 { >849 /* Allocate a large block of memory and serve out the aligned >850 pages therein. This results in much less memory wastage >851 than the traditional implementation of valloc. */ >852 >853 char *allocation, *a, *enda; >854 size_t alloc_size, head_slop, tail_slop; >855 int multiple_pages = (entry_size == G.pagesize); >856 >857 if (multiple_pages) >858 alloc_size = GGC_QUIRE_SIZE * G.pagesize; >859 else >860 alloc_size = entry_size + G.pagesize - 1; >861 allocation = XNEWVEC (char, alloc_size); >862 >863 page = (char *) (((uintptr_t) allocation + G.pagesize - 1) & -G.pagesize); >864 head_slop = page - allocation; >865 if (multiple_pages) >866 tail_slop = ((size_t) allocation + alloc_size) & (G.pagesize - 1); >867 else >868 tail_slop = alloc_size - entry_size - head_slop; >869 enda = allocation + alloc_size - tail_slop; >870 >871 /* We allocated N pages, which are likely not aligned, leaving >872 us with N-1 usable pages. We plan to place the page_group >873 structure somewhere in the slop. */ >874 if (head_slop >= sizeof (page_group)) >875 group = (page_group *)page - 1; >876 else >877 { >878 /* We magically got an aligned allocation. Too bad, we have >879 to waste a page anyway. */ >880 if (tail_slop == 0) >881 { >882 enda -= G.pagesize; >883 tail_slop += G.pagesize; >884 } >885 gcc_assert (tail_slop >= sizeof (page_group)); >886 group = (page_group *)enda; >887 tail_slop -= sizeof (page_group); >888 } >889 >890 /* Remember that we allocated this memory. */ >891 group->next = G.page_groups; >892 group->allocation = allocation; >893 group->alloc_size = alloc_size; >894 group->in_use = 0; >895 G.page_groups = group; >896 G.bytes_mapped += alloc_size; >897 >898 /* If we allocated multiple pages, put the rest on the free list. */ >899 if (multiple_pages) >900 { >901 struct page_entry *e, *f = G.free_pages; >902 for (a = enda - G.pagesize; a != page; a -= G.pagesize) >903 { >904 e = XCNEWVAR (struct page_entry, page_entry_size); >905 e->order = order; >906 e->bytes = G.pagesize; >907 e->page = a; >908 e->group = group; >909 e->next = f; >910 f = e; >911 } >912 G.free_pages = f; >913 } >914 } >915 #endif >916 >917 if (entry == NULL) > 0x000000000080e38a <+1306>: mov %bl,0x30(%rsp) > 0x000000000080e38e <+1310>: jmpq 0x80df8e <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+286> > 0x000000000080e393 <+1315>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e39e <+1326>: xchg %ax,%ax > >1308 G.page_tails[order] = new_entry; > 0x000000000080e3a0 <+1328>: mov %r15,0x2091d60(,%rbx,8) > 0x000000000080e3a8 <+1336>: jmpq 0x80e1ae <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+830> > 0x000000000080e3ad <+1341>: nopl (%rax) > >/usr/include/bits/string_fortified.h: >71 return __builtin___memset_chk (__dest, __ch, __len, __bos0 (__dest)); > 0x000000000080e3b0 <+1344>: mov 0x18(%rsp),%rdx > 0x000000000080e3b5 <+1349>: xor %esi,%esi > 0x000000000080e3b7 <+1351>: mov %r15,%rdi > 0x000000000080e3ba <+1354>: callq 0x5be370 <memset@plt> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c: >917 if (entry == NULL) > 0x000000000080e3bf <+1359>: jmpq 0x80dfa0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+304> > 0x000000000080e3c4 <+1364>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e3cf <+1375>: nop > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/vec.h: >1432 T &operator[] (unsigned ix) > 0x000000000080e3d0 <+1376>: mov 0x1883ca9(%rip),%r15 # 0x2092080 <_ZL1G+1472> > >1831 { >1832 return m_vec->quick_push (obj); >1833 } >1834 >1835 >1836 /* Push a new element OBJ onto the end of this vector. Reallocates >1837 the embedded vector, if needed. Return a pointer to the slot where >1838 OBJ was inserted. */ >1839 >1840 template<typename T> >1841 inline T * >1842 vec<T, va_heap, vl_ptr>::safe_push (const T &obj MEM_STAT_DECL) > 0x000000000080e3d7 <+1383>: mov 0x8(%r15,%r13,8),%rbx > 0x000000000080e3dc <+1388>: test %rbx,%rbx > 0x000000000080e3df <+1391>: je 0x80e733 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2243> > >891 vec<T, A, vl_embed>::space (unsigned nelems) const > 0x000000000080e3e5 <+1397>: mov (%rbx),%eax > 0x000000000080e3e7 <+1399>: mov 0x4(%rbx),%ebp > 0x000000000080e3ea <+1402>: and $0x7fffffff,%eax > 0x000000000080e3ef <+1407>: lea 0x1(%rbp),%r14d > 0x000000000080e3f3 <+1411>: cmp %ebp,%eax > 0x000000000080e3f5 <+1413>: je 0x80e5da <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1898> > >1433 { return (*m_vec)[ix]; } >1434 >1435 T &last (void) >1436 { return m_vec->last (); } >1437 >1438 bool space (int nelems) const >1439 { return m_vec ? m_vec->space (nelems) : nelems == 0; } >1440 >1441 bool iterate (unsigned ix, T *p) const; >1442 bool iterate (unsigned ix, T **p) const; >1443 vec copy (ALONE_CXX_MEM_STAT_INFO) const; >1444 bool reserve (unsigned, bool = false CXX_MEM_STAT_INFO); >1445 bool reserve_exact (unsigned CXX_MEM_STAT_INFO); >1446 void splice (const vec &); >1447 void safe_splice (const vec & CXX_MEM_STAT_INFO); >1448 T *quick_push (const T &); >1449 T *safe_push (const T &CXX_MEM_STAT_INFO); >1450 T &pop (void); >1451 void truncate (unsigned); >1452 void safe_grow (unsigned CXX_MEM_STAT_INFO); >1453 void safe_grow_cleared (unsigned CXX_MEM_STAT_INFO); >1454 void quick_grow (unsigned); >1455 void quick_grow_cleared (unsigned); >1456 void quick_insert (unsigned, const T &); >1457 void safe_insert (unsigned, const T & CXX_MEM_STAT_INFO); >1458 void ordered_remove (unsigned); >1459 void unordered_remove (unsigned); >1460 void block_remove (unsigned, unsigned); >1461 void qsort (int (*) (const void *, const void *)); >1462 void sort (int (*) (const void *, const void *, void *), void *); >1463 T *bsearch (const void *key, int (*compar)(const void *, const void *)); >1464 T *bsearch (const void *key, >1465 int (*compar)(const void *, const void *, void *), void *); >1466 unsigned lower_bound (T, bool (*)(const T &, const T &)) const; >1467 bool contains (const T &search) const; >1468 void reverse (void); >1469 >1470 bool using_auto_storage () const; >1471 >1472 /* FIXME - This field should be private, but we need to cater to >1473 compilers that have stricter notions of PODness for types. */ >1474 vec<T, va_heap, vl_embed> *m_vec; >1475 }; >1476 >1477 >1478 /* auto_vec is a subclass of vec that automatically manages creating and >1479 releasing the internal vector. If N is non zero then it has N elements of >1480 internal storage. The default is no internal storage, and you probably only >1481 want to ask for internal storage for vectors on the stack because if the >1482 size of the vector is larger than the internal storage that space is wasted. >1483 */ >1484 template<typename T, size_t N = 0> >1485 class auto_vec : public vec<T, va_heap> >1486 { >1487 public: >1488 auto_vec () >1489 { >1490 m_auto.embedded_init (MAX (N, 2), 0, 1); >1491 this->m_vec = &m_auto; >1492 } >1493 >1494 auto_vec (size_t s) >1495 { >1496 if (s > N) >1497 { >1498 this->create (s); >1499 return; >1500 } >1501 >1502 m_auto.embedded_init (MAX (N, 2), 0, 1); >1503 this->m_vec = &m_auto; >1504 } >1505 >1506 ~auto_vec () >1507 { >1508 this->release (); >1509 } >1510 >1511 private: >1512 vec<T, va_heap, vl_embed> m_auto; >1513 T m_data[MAX (N - 1, 1)]; >1514 }; >1515 >1516 /* auto_vec is a sub class of vec whose storage is released when it is >1517 destroyed. */ >1518 template<typename T> >1519 class auto_vec<T, 0> : public vec<T, va_heap> >1520 { >1521 public: >1522 auto_vec () { this->m_vec = NULL; } >1523 auto_vec (size_t n) { this->create (n); } >1524 ~auto_vec () { this->release (); } >1525 }; >1526 >1527 >1528 /* Allocate heap memory for pointer V and create the internal vector >1529 with space for NELEMS elements. If NELEMS is 0, the internal >1530 vector is initialized to empty. */ >1531 >1532 template<typename T> >1533 inline void >1534 vec_alloc (vec<T> *&v, unsigned nelems CXX_MEM_STAT_INFO) >1535 { >1536 v = new vec<T>; >1537 v->create (nelems PASS_MEM_STAT); >1538 } >1539 >1540 >1541 /* A subclass of auto_vec <char *> that frees all of its elements on >1542 deletion. */ >1543 >1544 class auto_string_vec : public auto_vec <char *> >1545 { >1546 public: >1547 ~auto_string_vec (); >1548 }; >1549 >1550 /* A subclass of auto_vec <T *> that deletes all of its elements on >1551 destruction. >1552 >1553 This is a crude way for a vec to "own" the objects it points to >1554 and clean up automatically. >1555 >1556 For example, no attempt is made to delete elements when an item >1557 within the vec is overwritten. >1558 >1559 We can't rely on gnu::unique_ptr within a container, >1560 since we can't rely on move semantics in C++98. */ >1561 >1562 template <typename T> >1563 class auto_delete_vec : public auto_vec <T *> >1564 { >1565 public: >1566 auto_delete_vec () {} >1567 auto_delete_vec (size_t s) : auto_vec <T *> (s) {} >1568 >1569 ~auto_delete_vec (); >1570 >1571 private: >1572 DISABLE_COPY_AND_ASSIGN(auto_delete_vec<T>); >1573 }; >1574 >1575 /* Conditionally allocate heap memory for VEC and its internal vector. */ >1576 >1577 template<typename T> >1578 inline void >1579 vec_check_alloc (vec<T, va_heap> *&vec, unsigned nelems CXX_MEM_STAT_INFO) >1580 { >1581 if (!vec) >1582 vec_alloc (vec, nelems PASS_MEM_STAT); >1583 } >1584 >1585 >1586 /* Free the heap memory allocated by vector V and set it to NULL. */ >1587 >1588 template<typename T> >1589 inline void >1590 vec_free (vec<T> *&v) >1591 { >1592 if (v == NULL) >1593 return; >1594 >1595 v->release (); >1596 delete v; >1597 v = NULL; >1598 } >1599 >1600 >1601 /* Return iteration condition and update PTR to point to the IX'th >1602 element of this vector. Use this to iterate over the elements of a >1603 vector as follows, >1604 >1605 for (ix = 0; v.iterate (ix, &ptr); ix++) >1606 continue; */ >1607 >1608 template<typename T> >1609 inline bool >1610 vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T *ptr) const >1611 { >1612 if (m_vec) >1613 return m_vec->iterate (ix, ptr); >1614 else >1615 { >1616 *ptr = 0; >1617 return false; >1618 } >1619 } >1620 >1621 >1622 /* Return iteration condition and update *PTR to point to the >1623 IX'th element of this vector. Use this to iterate over the >1624 elements of a vector as follows, >1625 >1626 for (ix = 0; v->iterate (ix, &ptr); ix++) >1627 continue; >1628 >1629 This variant is for vectors of objects. */ >1630 >1631 template<typename T> >1632 inline bool >1633 vec<T, va_heap, vl_ptr>::iterate (unsigned ix, T **ptr) const >1634 { >1635 if (m_vec) >1636 return m_vec->iterate (ix, ptr); >1637 else >1638 { >1639 *ptr = 0; >1640 return false; >1641 } >1642 } >1643 >1644 >1645 /* Convenience macro for forward iteration. */ >1646 #define FOR_EACH_VEC_ELT(V, I, P) \ >1647 for (I = 0; (V).iterate ((I), &(P)); ++(I)) >1648 >1649 #define FOR_EACH_VEC_SAFE_ELT(V, I, P) \ >1650 for (I = 0; vec_safe_iterate ((V), (I), &(P)); ++(I)) >1651 >1652 /* Likewise, but start from FROM rather than 0. */ >1653 #define FOR_EACH_VEC_ELT_FROM(V, I, P, FROM) \ >1654 for (I = (FROM); (V).iterate ((I), &(P)); ++(I)) >1655 >1656 /* Convenience macro for reverse iteration. */ >1657 #define FOR_EACH_VEC_ELT_REVERSE(V, I, P) \ >1658 for (I = (V).length () - 1; \ >1659 (V).iterate ((I), &(P)); \ >1660 (I)--) >1661 >1662 #define FOR_EACH_VEC_SAFE_ELT_REVERSE(V, I, P) \ >1663 for (I = vec_safe_length (V) - 1; \ >1664 vec_safe_iterate ((V), (I), &(P)); \ >1665 (I)--) >1666 >1667 /* auto_string_vec's dtor, freeing all contained strings, automatically >1668 chaining up to ~auto_vec <char *>, which frees the internal buffer. */ >1669 >1670 inline >1671 auto_string_vec::~auto_string_vec () >1672 { >1673 int i; >1674 char *str; >1675 FOR_EACH_VEC_ELT (*this, i, str) >1676 free (str); >1677 } >1678 >1679 /* auto_delete_vec's dtor, deleting all contained items, automatically >1680 chaining up to ~auto_vec <T*>, which frees the internal buffer. */ >1681 >1682 template <typename T> >1683 inline >1684 auto_delete_vec<T>::~auto_delete_vec () >1685 { >1686 int i; >1687 T *item; >1688 FOR_EACH_VEC_ELT (*this, i, item) >1689 delete item; >1690 } >1691 >1692 >1693 /* Return a copy of this vector. */ >1694 >1695 template<typename T> >1696 inline vec<T, va_heap, vl_ptr> >1697 vec<T, va_heap, vl_ptr>::copy (ALONE_MEM_STAT_DECL) const >1698 { >1699 vec<T, va_heap, vl_ptr> new_vec = vNULL; >1700 if (length ()) >1701 new_vec.m_vec = m_vec->copy (); >1702 return new_vec; >1703 } >1704 >1705 >1706 /* Ensure that the vector has at least RESERVE slots available (if >1707 EXACT is false), or exactly RESERVE slots available (if EXACT is >1708 true). >1709 >1710 This may create additional headroom if EXACT is false. >1711 >1712 Note that this can cause the embedded vector to be reallocated. >1713 Returns true iff reallocation actually occurred. */ >1714 >1715 template<typename T> >1716 inline bool >1717 vec<T, va_heap, vl_ptr>::reserve (unsigned nelems, bool exact MEM_STAT_DECL) >1718 { >1719 if (space (nelems)) >1720 return false; >1721 >1722 /* For now play a game with va_heap::reserve to hide our auto storage if any, >1723 this is necessary because it doesn't have enough information to know the >1724 embedded vector is in auto storage, and so should not be freed. */ >1725 vec<T, va_heap, vl_embed> *oldvec = m_vec; >1726 unsigned int oldsize = 0; >1727 bool handle_auto_vec = m_vec && using_auto_storage (); >1728 if (handle_auto_vec) >1729 { >1730 m_vec = NULL; >1731 oldsize = oldvec->length (); >1732 nelems += oldsize; >1733 } >1734 >1735 va_heap::reserve (m_vec, nelems, exact PASS_MEM_STAT); >1736 if (handle_auto_vec) >1737 { >1738 vec_copy_construct (m_vec->address (), oldvec->address (), oldsize); >1739 m_vec->m_vecpfx.m_num = oldsize; >1740 } >1741 >1742 return true; >1743 } >1744 >1745 >1746 /* Ensure that this vector has exactly NELEMS slots available. This >1747 will not create additional headroom. Note this can cause the >1748 embedded vector to be reallocated. Returns true iff reallocation >1749 actually occurred. */ >1750 >1751 template<typename T> >1752 inline bool >1753 vec<T, va_heap, vl_ptr>::reserve_exact (unsigned nelems MEM_STAT_DECL) >1754 { >1755 return reserve (nelems, true PASS_MEM_STAT); >1756 } >1757 >1758 >1759 /* Create the internal vector and reserve NELEMS for it. This is >1760 exactly like vec::reserve, but the internal vector is >1761 unconditionally allocated from scratch. The old one, if it >1762 existed, is lost. */ >1763 >1764 template<typename T> >1765 inline void >1766 vec<T, va_heap, vl_ptr>::create (unsigned nelems MEM_STAT_DECL) >1767 { >1768 m_vec = NULL; >1769 if (nelems > 0) >1770 reserve_exact (nelems PASS_MEM_STAT); >1771 } >1772 >1773 >1774 /* Free the memory occupied by the embedded vector. */ >1775 >1776 template<typename T> >1777 inline void >1778 vec<T, va_heap, vl_ptr>::release (void) >1779 { >1780 if (!m_vec) >1781 return; >1782 >1783 if (using_auto_storage ()) >1784 { >1785 m_vec->m_vecpfx.m_num = 0; >1786 return; >1787 } >1788 >1789 va_heap::release (m_vec); >1790 } >1791 >1792 /* Copy the elements from SRC to the end of this vector as if by memcpy. >1793 SRC and this vector must be allocated with the same memory >1794 allocation mechanism. This vector is assumed to have sufficient >1795 headroom available. */ >1796 >1797 template<typename T> >1798 inline void >1799 vec<T, va_heap, vl_ptr>::splice (const vec<T, va_heap, vl_ptr> &src) >1800 { >1801 if (src.length ()) >1802 m_vec->splice (*(src.m_vec)); >1803 } >1804 >1805 >1806 /* Copy the elements in SRC to the end of this vector as if by memcpy. >1807 SRC and this vector must be allocated with the same mechanism. >1808 If there is not enough headroom in this vector, it will be reallocated >1809 as needed. */ >1810 >1811 template<typename T> >1812 inline void >1813 vec<T, va_heap, vl_ptr>::safe_splice (const vec<T, va_heap, vl_ptr> &src >1814 MEM_STAT_DECL) >1815 { >1816 if (src.length ()) >1817 { >1818 reserve_exact (src.length ()); >1819 splice (src); >1820 } >1821 } >1822 >1823 >1824 /* Push OBJ (a new element) onto the end of the vector. There must be >1825 sufficient space in the vector. Return a pointer to the slot >1826 where OBJ was inserted. */ >1827 >1828 template<typename T> >1829 inline T * >1830 vec<T, va_heap, vl_ptr>::quick_push (const T &obj) > 0x000000000080e3fb <+1419>: shl $0x4,%rbp > 0x000000000080e3ff <+1423>: mov %r14d,0x4(%rbx) > 0x000000000080e403 <+1427>: lea (%rbx,%rbp,1),%rax > 0x000000000080e407 <+1431>: mov (%rsp),%rbx > 0x000000000080e40b <+1435>: mov %r12,0x8(%rax) > 0x000000000080e40f <+1439>: mov %rbx,0x10(%rax) > 0x000000000080e413 <+1443>: jmpq 0x80e295 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1061> > 0x000000000080e418 <+1448>: nopl 0x0(%rax,%rax,1) > >1843 { >1844 reserve (1, false PASS_MEM_STAT); >1845 return quick_push (obj); >1846 } >1847 >1848 >1849 /* Pop and return the last element off the end of the vector. */ >1850 >1851 template<typename T> >1852 inline T & >1853 vec<T, va_heap, vl_ptr>::pop (void) >1854 { >1855 return m_vec->pop (); >1856 } >1857 >1858 >1859 /* Set the length of the vector to LEN. The new length must be less >1860 than or equal to the current length. This is an O(1) operation. */ >1861 >1862 template<typename T> >1863 inline void >1864 vec<T, va_heap, vl_ptr>::truncate (unsigned size) >1865 { >1866 if (m_vec) >1867 m_vec->truncate (size); >1868 else >1869 gcc_checking_assert (size == 0); >1870 } >1871 >1872 >1873 /* Grow the vector to a specific length. LEN must be as long or >1874 longer than the current length. The new elements are >1875 uninitialized. Reallocate the internal vector, if needed. */ >1876 >1877 template<typename T> >1878 inline void >1879 vec<T, va_heap, vl_ptr>::safe_grow (unsigned len MEM_STAT_DECL) >1880 { >1881 unsigned oldlen = length (); >1882 gcc_checking_assert (oldlen <= len); >1883 reserve_exact (len - oldlen PASS_MEM_STAT); >1884 if (m_vec) >1885 m_vec->quick_grow (len); >1886 else >1887 gcc_checking_assert (len == 0); >1888 } >1889 >1890 >1891 /* Grow the embedded vector to a specific length. LEN must be as >1892 long or longer than the current length. The new elements are >1893 initialized to zero. Reallocate the internal vector, if needed. */ >1894 >1895 template<typename T> >1896 inline void >1897 vec<T, va_heap, vl_ptr>::safe_grow_cleared (unsigned len MEM_STAT_DECL) >1898 { >1899 unsigned oldlen = length (); >1900 size_t growby = len - oldlen; >1901 safe_grow (len PASS_MEM_STAT); >1902 if (growby != 0) >1903 vec_default_construct (address () + oldlen, growby); >1904 } >1905 >1906 >1907 /* Same as vec::safe_grow but without reallocation of the internal vector. >1908 If the vector cannot be extended, a runtime assertion will be triggered. */ >1909 >1910 template<typename T> >1911 inline void >1912 vec<T, va_heap, vl_ptr>::quick_grow (unsigned len) >1913 { >1914 gcc_checking_assert (m_vec); >1915 m_vec->quick_grow (len); >1916 } >1917 >1918 >1919 /* Same as vec::quick_grow_cleared but without reallocation of the >1920 internal vector. If the vector cannot be extended, a runtime >1921 assertion will be triggered. */ >1922 >1923 template<typename T> >1924 inline void >1925 vec<T, va_heap, vl_ptr>::quick_grow_cleared (unsigned len) >1926 { >1927 gcc_checking_assert (m_vec); >1928 m_vec->quick_grow_cleared (len); >1929 } >1930 >1931 >1932 /* Insert an element, OBJ, at the IXth position of this vector. There >1933 must be sufficient space. */ >1934 >1935 template<typename T> >1936 inline void >1937 vec<T, va_heap, vl_ptr>::quick_insert (unsigned ix, const T &obj) >1938 { >1939 m_vec->quick_insert (ix, obj); >1940 } >1941 >1942 >1943 /* Insert an element, OBJ, at the IXth position of the vector. >1944 Reallocate the embedded vector, if necessary. */ >1945 >1946 template<typename T> >1947 inline void >1948 vec<T, va_heap, vl_ptr>::safe_insert (unsigned ix, const T &obj MEM_STAT_DECL) >1949 { >1950 reserve (1, false PASS_MEM_STAT); >1951 quick_insert (ix, obj); >1952 } >1953 >1954 >1955 /* Remove an element from the IXth position of this vector. Ordering of >1956 remaining elements is preserved. This is an O(N) operation due to >1957 a memmove. */ >1958 >1959 template<typename T> >1960 inline void >1961 vec<T, va_heap, vl_ptr>::ordered_remove (unsigned ix) >1962 { >1963 m_vec->ordered_remove (ix); >1964 } >1965 >1966 >1967 /* Remove an element from the IXth position of this vector. Ordering >1968 of remaining elements is destroyed. This is an O(1) operation. */ >1969 >1970 template<typename T> >1971 inline void >1972 vec<T, va_heap, vl_ptr>::unordered_remove (unsigned ix) >1973 { >1974 m_vec->unordered_remove (ix); >1975 } >1976 >1977 >1978 /* Remove LEN elements starting at the IXth. Ordering is retained. >1979 This is an O(N) operation due to memmove. */ >1980 >1981 template<typename T> >1982 inline void >1983 vec<T, va_heap, vl_ptr>::block_remove (unsigned ix, unsigned len) >1984 { >1985 m_vec->block_remove (ix, len); >1986 } >1987 >1988 >1989 /* Sort the contents of this vector with qsort. CMP is the comparison >1990 function to pass to qsort. */ >1991 >1992 template<typename T> >1993 inline void >1994 vec<T, va_heap, vl_ptr>::qsort (int (*cmp) (const void *, const void *)) >1995 { >1996 if (m_vec) >1997 m_vec->qsort (cmp); >1998 } >1999 >2000 /* Sort the contents of this vector with qsort. CMP is the comparison >2001 function to pass to qsort. */ >2002 >2003 template<typename T> >2004 inline void >2005 vec<T, va_heap, vl_ptr>::sort (int (*cmp) (const void *, const void *, >2006 void *), void *data) >2007 { >2008 if (m_vec) >2009 m_vec->sort (cmp, data); >2010 } >2011 >2012 >2013 /* Search the contents of the sorted vector with a binary search. >2014 CMP is the comparison function to pass to bsearch. */ >2015 >2016 template<typename T> >2017 inline T * >2018 vec<T, va_heap, vl_ptr>::bsearch (const void *key, >2019 int (*cmp) (const void *, const void *)) >2020 { >2021 if (m_vec) >2022 return m_vec->bsearch (key, cmp); >2023 return NULL; >2024 } >2025 >2026 /* Search the contents of the sorted vector with a binary search. >2027 CMP is the comparison function to pass to bsearch. */ >2028 >2029 template<typename T> >2030 inline T * >2031 vec<T, va_heap, vl_ptr>::bsearch (const void *key, >2032 int (*cmp) (const void *, const void *, >2033 void *), void *data) >2034 { >2035 if (m_vec) >2036 return m_vec->bsearch (key, cmp, data); >2037 return NULL; >2038 } >2039 >2040 >2041 /* Find and return the first position in which OBJ could be inserted >2042 without changing the ordering of this vector. LESSTHAN is a >2043 function that returns true if the first argument is strictly less >2044 than the second. */ >2045 >2046 template<typename T> >2047 inline unsigned >2048 vec<T, va_heap, vl_ptr>::lower_bound (T obj, >2049 bool (*lessthan)(const T &, const T &)) >2050 const >2051 { >2052 return m_vec ? m_vec->lower_bound (obj, lessthan) : 0; >2053 } >2054 >2055 /* Return true if SEARCH is an element of V. Note that this is O(N) in the >2056 size of the vector and so should be used with care. */ >2057 >2058 template<typename T> >2059 inline bool >2060 vec<T, va_heap, vl_ptr>::contains (const T &search) const >2061 { >2062 return m_vec ? m_vec->contains (search) : false; >2063 } >2064 >2065 /* Reverse content of the vector. */ >2066 >2067 template<typename T> >2068 inline void >2069 vec<T, va_heap, vl_ptr>::reverse (void) >2070 { >2071 unsigned l = length (); >2072 T *ptr = address (); >2073 >2074 for (unsigned i = 0; i < l / 2; i++) >2075 std::swap (ptr[i], ptr[l - i - 1]); >2076 } >2077 >2078 template<typename T> >2079 inline bool >2080 vec<T, va_heap, vl_ptr>::using_auto_storage () const > 0x000000000080e420 <+1456>: testb $0x80,0x3(%rbx) > 0x000000000080e424 <+1460>: jne 0x80e46f <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1535> > >276 va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact > 0x000000000080e426 <+1462>: mov %r14d,%esi > 0x000000000080e429 <+1465>: mov %ebp,%edi > 0x000000000080e42b <+1467>: xor %ebp,%ebp > 0x000000000080e42d <+1469>: callq 0x15a9810 <vec_prefix::calculate_allocation_1(unsigned int, unsigned int)> > 0x000000000080e432 <+1474>: mov 0x8(%r15,%r13,8),%rdi > 0x000000000080e437 <+1479>: mov %eax,%esi > 0x000000000080e439 <+1481>: mov %rsi,%r14 > >892 { >893 return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems; >894 } >895 >896 >897 /* Return iteration condition and update PTR to point to the IX'th >898 element of this vector. Use this to iterate over the elements of a >899 vector as follows, >900 >901 for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++) >902 continue; */ >903 >904 template<typename T, typename A> >905 inline bool >906 vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const >907 { >908 if (ix < m_vecpfx.m_num) >909 { >910 *ptr = m_vecdata[ix]; >911 return true; >912 } >913 else >914 { >915 *ptr = 0; >916 return false; >917 } >918 } >919 >920 >921 /* Return iteration condition and update *PTR to point to the >922 IX'th element of this vector. Use this to iterate over the >923 elements of a vector as follows, >924 >925 for (ix = 0; v->iterate (ix, &ptr); ix++) >926 continue; >927 >928 This variant is for vectors of objects. */ >929 >930 template<typename T, typename A> >931 inline bool >932 vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const >933 { >934 if (ix < m_vecpfx.m_num) >935 { >936 *ptr = CONST_CAST (T *, &m_vecdata[ix]); >937 return true; >938 } >939 else >940 { >941 *ptr = 0; >942 return false; >943 } >944 } >945 >946 >947 /* Return a pointer to a copy of this vector. */ >948 >949 template<typename T, typename A> >950 inline vec<T, A, vl_embed> * >951 vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECL) const >952 { >953 vec<T, A, vl_embed> *new_vec = NULL; >954 unsigned len = length (); >955 if (len) >956 { >957 vec_alloc (new_vec, len PASS_MEM_STAT); >958 new_vec->embedded_init (len, len); >959 vec_copy_construct (new_vec->address (), m_vecdata, len); >960 } >961 return new_vec; >962 } >963 >964 >965 /* Copy the elements from SRC to the end of this vector as if by memcpy. >966 The vector must have sufficient headroom available. */ >967 >968 template<typename T, typename A> >969 inline void >970 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src) >971 { >972 unsigned len = src.length (); >973 if (len) >974 { >975 gcc_checking_assert (space (len)); >976 vec_copy_construct (end (), src.address (), len); >977 m_vecpfx.m_num += len; >978 } >979 } >980 >981 template<typename T, typename A> >982 inline void >983 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src) >984 { >985 if (src) >986 splice (*src); >987 } >988 >989 >990 /* Push OBJ (a new element) onto the end of the vector. There must be >991 sufficient space in the vector. Return a pointer to the slot >992 where OBJ was inserted. */ >993 >994 template<typename T, typename A> >995 inline T * >996 vec<T, A, vl_embed>::quick_push (const T &obj) >997 { >998 gcc_checking_assert (space (1)); >999 T *slot = &m_vecdata[m_vecpfx.m_num++]; >1000 *slot = obj; >1001 return slot; >1002 } >1003 >1004 >1005 /* Pop and return the last element off the end of the vector. */ >1006 >1007 template<typename T, typename A> >1008 inline T & >1009 vec<T, A, vl_embed>::pop (void) >1010 { >1011 gcc_checking_assert (length () > 0); >1012 return m_vecdata[--m_vecpfx.m_num]; >1013 } >1014 >1015 >1016 /* Set the length of the vector to SIZE. The new length must be less >1017 than or equal to the current length. This is an O(1) operation. */ >1018 >1019 template<typename T, typename A> >1020 inline void >1021 vec<T, A, vl_embed>::truncate (unsigned size) >1022 { >1023 gcc_checking_assert (length () >= size); >1024 m_vecpfx.m_num = size; >1025 } >1026 >1027 >1028 /* Insert an element, OBJ, at the IXth position of this vector. There >1029 must be sufficient space. */ >1030 >1031 template<typename T, typename A> >1032 inline void >1033 vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj) >1034 { >1035 gcc_checking_assert (length () < allocated ()); >1036 gcc_checking_assert (ix <= length ()); >1037 T *slot = &m_vecdata[ix]; >1038 memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T)); >1039 *slot = obj; >1040 } >1041 >1042 >1043 /* Remove an element from the IXth position of this vector. Ordering of >1044 remaining elements is preserved. This is an O(N) operation due to >1045 memmove. */ >1046 >1047 template<typename T, typename A> >1048 inline void >1049 vec<T, A, vl_embed>::ordered_remove (unsigned ix) >1050 { >1051 gcc_checking_assert (ix < length ()); >1052 T *slot = &m_vecdata[ix]; >1053 memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T)); >1054 } >1055 >1056 >1057 /* Remove elements in [START, END) from VEC for which COND holds. Ordering of >1058 remaining elements is preserved. This is an O(N) operation. */ >1059 >1060 #define VEC_ORDERED_REMOVE_IF_FROM_TO(vec, read_index, write_index, \ >1061 elem_ptr, start, end, cond) \ >1062 { \ >1063 gcc_assert ((end) <= (vec).length ()); \ >1064 for (read_index = write_index = (start); read_index < (end); \ >1065 ++read_index) \ >1066 { \ >1067 elem_ptr = &(vec)[read_index]; \ >1068 bool remove_p = (cond); \ >1069 if (remove_p) \ >1070 continue; \ >1071 \ >1072 if (read_index != write_index) \ >1073 (vec)[write_index] = (vec)[read_index]; \ >1074 \ >1075 write_index++; \ >1076 } \ >1077 \ >1078 if (read_index - write_index > 0) \ >1079 (vec).block_remove (write_index, read_index - write_index); \ >1080 } >1081 >1082 >1083 /* Remove elements from VEC for which COND holds. Ordering of remaining >1084 elements is preserved. This is an O(N) operation. */ >1085 >1086 #define VEC_ORDERED_REMOVE_IF(vec, read_index, write_index, elem_ptr, \ >1087 cond) \ >1088 VEC_ORDERED_REMOVE_IF_FROM_TO ((vec), read_index, write_index, \ >1089 elem_ptr, 0, (vec).length (), (cond)) >1090 >1091 /* Remove an element from the IXth position of this vector. Ordering of >1092 remaining elements is destroyed. This is an O(1) operation. */ >1093 >1094 template<typename T, typename A> >1095 inline void >1096 vec<T, A, vl_embed>::unordered_remove (unsigned ix) >1097 { >1098 gcc_checking_assert (ix < length ()); >1099 m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num]; >1100 } >1101 >1102 >1103 /* Remove LEN elements starting at the IXth. Ordering is retained. >1104 This is an O(N) operation due to memmove. */ >1105 >1106 template<typename T, typename A> >1107 inline void >1108 vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len) >1109 { >1110 gcc_checking_assert (ix + len <= length ()); >1111 T *slot = &m_vecdata[ix]; >1112 m_vecpfx.m_num -= len; >1113 memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T)); >1114 } >1115 >1116 >1117 /* Sort the contents of this vector with qsort. CMP is the comparison >1118 function to pass to qsort. */ >1119 >1120 template<typename T, typename A> >1121 inline void >1122 vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *)) >1123 { >1124 if (length () > 1) >1125 gcc_qsort (address (), length (), sizeof (T), cmp); >1126 } >1127 >1128 /* Sort the contents of this vector with qsort. CMP is the comparison >1129 function to pass to qsort. */ >1130 >1131 template<typename T, typename A> >1132 inline void >1133 vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *), >1134 void *data) >1135 { >1136 if (length () > 1) >1137 gcc_sort_r (address (), length (), sizeof (T), cmp, data); >1138 } >1139 >1140 >1141 /* Search the contents of the sorted vector with a binary search. >1142 CMP is the comparison function to pass to bsearch. */ >1143 >1144 template<typename T, typename A> >1145 inline T * >1146 vec<T, A, vl_embed>::bsearch (const void *key, >1147 int (*compar) (const void *, const void *)) >1148 { >1149 const void *base = this->address (); >1150 size_t nmemb = this->length (); >1151 size_t size = sizeof (T); >1152 /* The following is a copy of glibc stdlib-bsearch.h. */ >1153 size_t l, u, idx; >1154 const void *p; >1155 int comparison; >1156 >1157 l = 0; >1158 u = nmemb; >1159 while (l < u) >1160 { >1161 idx = (l + u) / 2; >1162 p = (const void *) (((const char *) base) + (idx * size)); >1163 comparison = (*compar) (key, p); >1164 if (comparison < 0) >1165 u = idx; >1166 else if (comparison > 0) >1167 l = idx + 1; >1168 else >1169 return (T *)const_cast<void *>(p); >1170 } >1171 >1172 return NULL; >1173 } >1174 >1175 /* Search the contents of the sorted vector with a binary search. >1176 CMP is the comparison function to pass to bsearch. */ >1177 >1178 template<typename T, typename A> >1179 inline T * >1180 vec<T, A, vl_embed>::bsearch (const void *key, >1181 int (*compar) (const void *, const void *, >1182 void *), void *data) >1183 { >1184 const void *base = this->address (); >1185 size_t nmemb = this->length (); >1186 size_t size = sizeof (T); >1187 /* The following is a copy of glibc stdlib-bsearch.h. */ >1188 size_t l, u, idx; >1189 const void *p; >1190 int comparison; >1191 >1192 l = 0; >1193 u = nmemb; >1194 while (l < u) >1195 { >1196 idx = (l + u) / 2; >1197 p = (const void *) (((const char *) base) + (idx * size)); >1198 comparison = (*compar) (key, p, data); >1199 if (comparison < 0) >1200 u = idx; >1201 else if (comparison > 0) >1202 l = idx + 1; >1203 else >1204 return (T *)const_cast<void *>(p); >1205 } >1206 >1207 return NULL; >1208 } >1209 >1210 /* Return true if SEARCH is an element of V. Note that this is O(N) in the >1211 size of the vector and so should be used with care. */ >1212 >1213 template<typename T, typename A> >1214 inline bool >1215 vec<T, A, vl_embed>::contains (const T &search) const >1216 { >1217 unsigned int len = length (); >1218 for (unsigned int i = 0; i < len; i++) >1219 if ((*this)[i] == search) >1220 return true; >1221 >1222 return false; >1223 } >1224 >1225 /* Find and return the first position in which OBJ could be inserted >1226 without changing the ordering of this vector. LESSTHAN is a >1227 function that returns true if the first argument is strictly less >1228 than the second. */ >1229 >1230 template<typename T, typename A> >1231 unsigned >1232 vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &)) >1233 const >1234 { >1235 unsigned int len = length (); >1236 unsigned int half, middle; >1237 unsigned int first = 0; >1238 while (len > 0) >1239 { >1240 half = len / 2; >1241 middle = first; >1242 middle += half; >1243 T middle_elem = (*this)[middle]; >1244 if (lessthan (middle_elem, obj)) >1245 { >1246 first = middle; >1247 ++first; >1248 len = len - half - 1; >1249 } >1250 else >1251 len = half; >1252 } >1253 return first; >1254 } >1255 >1256 >1257 /* Return the number of bytes needed to embed an instance of an >1258 embeddable vec inside another data structure. >1259 >1260 Use these methods to determine the required size and initialization >1261 of a vector V of type T embedded within another structure (as the >1262 final member): >1263 >1264 size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc); >1265 void v->embedded_init (unsigned alloc, unsigned num); >1266 >1267 These allow the caller to perform the memory allocation. */ >1268 >1269 template<typename T, typename A> >1270 inline size_t >1271 vec<T, A, vl_embed>::embedded_size (unsigned alloc) > 0x000000000080e43c <+1484>: shl $0x5,%rsi > 0x000000000080e440 <+1488>: add $0x8,%rsi > 0x000000000080e444 <+1492>: test %rdi,%rdi > 0x000000000080e447 <+1495>: je 0x80e44c <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1500> > >579 unsigned length (void) const { return m_vecpfx.m_num; } > 0x000000000080e449 <+1497>: mov 0x4(%rdi),%ebp > 0x000000000080e44c <+1500>: callq 0x161a190 <xrealloc> > 0x000000000080e451 <+1505>: and $0x7fffffff,%r14d > 0x000000000080e458 <+1512>: mov %rax,0x8(%r15,%r13,8) > >1272 { >1273 typedef vec<T, A, vl_embed> vec_embedded; >1274 return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T); >1275 } >1276 >1277 >1278 /* Initialize the vector to contain room for ALLOC elements and >1279 NUM active elements. */ >1280 >1281 template<typename T, typename A> >1282 inline void >1283 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut) > 0x000000000080e45d <+1517>: mov %rax,%rbx > 0x000000000080e460 <+1520>: mov %r14d,(%rax) > 0x000000000080e463 <+1523>: mov %ebp,0x4(%rax) > 0x000000000080e466 <+1526>: lea 0x1(%rbp),%r14d > 0x000000000080e46a <+1530>: jmpq 0x80e26b <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1019> > 0x000000000080e46f <+1535>: mov $0x4,%ecx > 0x000000000080e474 <+1540>: movq $0x0,0x8(%r15,%r13,8) > >276 va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact > 0x000000000080e47d <+1549>: cmp %ecx,%r14d > 0x000000000080e480 <+1552>: cmovae %r14d,%ecx > >892 { >893 return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems; >894 } >895 >896 >897 /* Return iteration condition and update PTR to point to the IX'th >898 element of this vector. Use this to iterate over the elements of a >899 vector as follows, >900 >901 for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++) >902 continue; */ >903 >904 template<typename T, typename A> >905 inline bool >906 vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const >907 { >908 if (ix < m_vecpfx.m_num) >909 { >910 *ptr = m_vecdata[ix]; >911 return true; >912 } >913 else >914 { >915 *ptr = 0; >916 return false; >917 } >918 } >919 >920 >921 /* Return iteration condition and update *PTR to point to the >922 IX'th element of this vector. Use this to iterate over the >923 elements of a vector as follows, >924 >925 for (ix = 0; v->iterate (ix, &ptr); ix++) >926 continue; >927 >928 This variant is for vectors of objects. */ >929 >930 template<typename T, typename A> >931 inline bool >932 vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const >933 { >934 if (ix < m_vecpfx.m_num) >935 { >936 *ptr = CONST_CAST (T *, &m_vecdata[ix]); >937 return true; >938 } >939 else >940 { >941 *ptr = 0; >942 return false; >943 } >944 } >945 >946 >947 /* Return a pointer to a copy of this vector. */ >948 >949 template<typename T, typename A> >950 inline vec<T, A, vl_embed> * >951 vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECL) const >952 { >953 vec<T, A, vl_embed> *new_vec = NULL; >954 unsigned len = length (); >955 if (len) >956 { >957 vec_alloc (new_vec, len PASS_MEM_STAT); >958 new_vec->embedded_init (len, len); >959 vec_copy_construct (new_vec->address (), m_vecdata, len); >960 } >961 return new_vec; >962 } >963 >964 >965 /* Copy the elements from SRC to the end of this vector as if by memcpy. >966 The vector must have sufficient headroom available. */ >967 >968 template<typename T, typename A> >969 inline void >970 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src) >971 { >972 unsigned len = src.length (); >973 if (len) >974 { >975 gcc_checking_assert (space (len)); >976 vec_copy_construct (end (), src.address (), len); >977 m_vecpfx.m_num += len; >978 } >979 } >980 >981 template<typename T, typename A> >982 inline void >983 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src) >984 { >985 if (src) >986 splice (*src); >987 } >988 >989 >990 /* Push OBJ (a new element) onto the end of the vector. There must be >991 sufficient space in the vector. Return a pointer to the slot >992 where OBJ was inserted. */ >993 >994 template<typename T, typename A> >995 inline T * >996 vec<T, A, vl_embed>::quick_push (const T &obj) >997 { >998 gcc_checking_assert (space (1)); >999 T *slot = &m_vecdata[m_vecpfx.m_num++]; >1000 *slot = obj; >1001 return slot; >1002 } >1003 >1004 >1005 /* Pop and return the last element off the end of the vector. */ >1006 >1007 template<typename T, typename A> >1008 inline T & >1009 vec<T, A, vl_embed>::pop (void) >1010 { >1011 gcc_checking_assert (length () > 0); >1012 return m_vecdata[--m_vecpfx.m_num]; >1013 } >1014 >1015 >1016 /* Set the length of the vector to SIZE. The new length must be less >1017 than or equal to the current length. This is an O(1) operation. */ >1018 >1019 template<typename T, typename A> >1020 inline void >1021 vec<T, A, vl_embed>::truncate (unsigned size) >1022 { >1023 gcc_checking_assert (length () >= size); >1024 m_vecpfx.m_num = size; >1025 } >1026 >1027 >1028 /* Insert an element, OBJ, at the IXth position of this vector. There >1029 must be sufficient space. */ >1030 >1031 template<typename T, typename A> >1032 inline void >1033 vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj) >1034 { >1035 gcc_checking_assert (length () < allocated ()); >1036 gcc_checking_assert (ix <= length ()); >1037 T *slot = &m_vecdata[ix]; >1038 memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T)); >1039 *slot = obj; >1040 } >1041 >1042 >1043 /* Remove an element from the IXth position of this vector. Ordering of >1044 remaining elements is preserved. This is an O(N) operation due to >1045 memmove. */ >1046 >1047 template<typename T, typename A> >1048 inline void >1049 vec<T, A, vl_embed>::ordered_remove (unsigned ix) >1050 { >1051 gcc_checking_assert (ix < length ()); >1052 T *slot = &m_vecdata[ix]; >1053 memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T)); >1054 } >1055 >1056 >1057 /* Remove elements in [START, END) from VEC for which COND holds. Ordering of >1058 remaining elements is preserved. This is an O(N) operation. */ >1059 >1060 #define VEC_ORDERED_REMOVE_IF_FROM_TO(vec, read_index, write_index, \ >1061 elem_ptr, start, end, cond) \ >1062 { \ >1063 gcc_assert ((end) <= (vec).length ()); \ >1064 for (read_index = write_index = (start); read_index < (end); \ >1065 ++read_index) \ >1066 { \ >1067 elem_ptr = &(vec)[read_index]; \ >1068 bool remove_p = (cond); \ >1069 if (remove_p) \ >1070 continue; \ >1071 \ >1072 if (read_index != write_index) \ >1073 (vec)[write_index] = (vec)[read_index]; \ >1074 \ >1075 write_index++; \ >1076 } \ >1077 \ >1078 if (read_index - write_index > 0) \ >1079 (vec).block_remove (write_index, read_index - write_index); \ >1080 } >1081 >1082 >1083 /* Remove elements from VEC for which COND holds. Ordering of remaining >1084 elements is preserved. This is an O(N) operation. */ >1085 >1086 #define VEC_ORDERED_REMOVE_IF(vec, read_index, write_index, elem_ptr, \ >1087 cond) \ >1088 VEC_ORDERED_REMOVE_IF_FROM_TO ((vec), read_index, write_index, \ >1089 elem_ptr, 0, (vec).length (), (cond)) >1090 >1091 /* Remove an element from the IXth position of this vector. Ordering of >1092 remaining elements is destroyed. This is an O(1) operation. */ >1093 >1094 template<typename T, typename A> >1095 inline void >1096 vec<T, A, vl_embed>::unordered_remove (unsigned ix) >1097 { >1098 gcc_checking_assert (ix < length ()); >1099 m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num]; >1100 } >1101 >1102 >1103 /* Remove LEN elements starting at the IXth. Ordering is retained. >1104 This is an O(N) operation due to memmove. */ >1105 >1106 template<typename T, typename A> >1107 inline void >1108 vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len) >1109 { >1110 gcc_checking_assert (ix + len <= length ()); >1111 T *slot = &m_vecdata[ix]; >1112 m_vecpfx.m_num -= len; >1113 memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T)); >1114 } >1115 >1116 >1117 /* Sort the contents of this vector with qsort. CMP is the comparison >1118 function to pass to qsort. */ >1119 >1120 template<typename T, typename A> >1121 inline void >1122 vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *)) >1123 { >1124 if (length () > 1) >1125 gcc_qsort (address (), length (), sizeof (T), cmp); >1126 } >1127 >1128 /* Sort the contents of this vector with qsort. CMP is the comparison >1129 function to pass to qsort. */ >1130 >1131 template<typename T, typename A> >1132 inline void >1133 vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *), >1134 void *data) >1135 { >1136 if (length () > 1) >1137 gcc_sort_r (address (), length (), sizeof (T), cmp, data); >1138 } >1139 >1140 >1141 /* Search the contents of the sorted vector with a binary search. >1142 CMP is the comparison function to pass to bsearch. */ >1143 >1144 template<typename T, typename A> >1145 inline T * >1146 vec<T, A, vl_embed>::bsearch (const void *key, >1147 int (*compar) (const void *, const void *)) >1148 { >1149 const void *base = this->address (); >1150 size_t nmemb = this->length (); >1151 size_t size = sizeof (T); >1152 /* The following is a copy of glibc stdlib-bsearch.h. */ >1153 size_t l, u, idx; >1154 const void *p; >1155 int comparison; >1156 >1157 l = 0; >1158 u = nmemb; >1159 while (l < u) >1160 { >1161 idx = (l + u) / 2; >1162 p = (const void *) (((const char *) base) + (idx * size)); >1163 comparison = (*compar) (key, p); >1164 if (comparison < 0) >1165 u = idx; >1166 else if (comparison > 0) >1167 l = idx + 1; >1168 else >1169 return (T *)const_cast<void *>(p); >1170 } >1171 >1172 return NULL; >1173 } >1174 >1175 /* Search the contents of the sorted vector with a binary search. >1176 CMP is the comparison function to pass to bsearch. */ >1177 >1178 template<typename T, typename A> >1179 inline T * >1180 vec<T, A, vl_embed>::bsearch (const void *key, >1181 int (*compar) (const void *, const void *, >1182 void *), void *data) >1183 { >1184 const void *base = this->address (); >1185 size_t nmemb = this->length (); >1186 size_t size = sizeof (T); >1187 /* The following is a copy of glibc stdlib-bsearch.h. */ >1188 size_t l, u, idx; >1189 const void *p; >1190 int comparison; >1191 >1192 l = 0; >1193 u = nmemb; >1194 while (l < u) >1195 { >1196 idx = (l + u) / 2; >1197 p = (const void *) (((const char *) base) + (idx * size)); >1198 comparison = (*compar) (key, p, data); >1199 if (comparison < 0) >1200 u = idx; >1201 else if (comparison > 0) >1202 l = idx + 1; >1203 else >1204 return (T *)const_cast<void *>(p); >1205 } >1206 >1207 return NULL; >1208 } >1209 >1210 /* Return true if SEARCH is an element of V. Note that this is O(N) in the >1211 size of the vector and so should be used with care. */ >1212 >1213 template<typename T, typename A> >1214 inline bool >1215 vec<T, A, vl_embed>::contains (const T &search) const >1216 { >1217 unsigned int len = length (); >1218 for (unsigned int i = 0; i < len; i++) >1219 if ((*this)[i] == search) >1220 return true; >1221 >1222 return false; >1223 } >1224 >1225 /* Find and return the first position in which OBJ could be inserted >1226 without changing the ordering of this vector. LESSTHAN is a >1227 function that returns true if the first argument is strictly less >1228 than the second. */ >1229 >1230 template<typename T, typename A> >1231 unsigned >1232 vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &)) >1233 const >1234 { >1235 unsigned int len = length (); >1236 unsigned int half, middle; >1237 unsigned int first = 0; >1238 while (len > 0) >1239 { >1240 half = len / 2; >1241 middle = first; >1242 middle += half; >1243 T middle_elem = (*this)[middle]; >1244 if (lessthan (middle_elem, obj)) >1245 { >1246 first = middle; >1247 ++first; >1248 len = len - half - 1; >1249 } >1250 else >1251 len = half; >1252 } >1253 return first; >1254 } >1255 >1256 >1257 /* Return the number of bytes needed to embed an instance of an >1258 embeddable vec inside another data structure. >1259 >1260 Use these methods to determine the required size and initialization >1261 of a vector V of type T embedded within another structure (as the >1262 final member): >1263 >1264 size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc); >1265 void v->embedded_init (unsigned alloc, unsigned num); >1266 >1267 These allow the caller to perform the memory allocation. */ >1268 >1269 template<typename T, typename A> >1270 inline size_t >1271 vec<T, A, vl_embed>::embedded_size (unsigned alloc) > 0x000000000080e484 <+1556>: xor %edi,%edi > 0x000000000080e486 <+1558>: mov %ecx,%esi > 0x000000000080e488 <+1560>: mov %ecx,0x18(%rsp) > 0x000000000080e48c <+1564>: shl $0x5,%rsi > 0x000000000080e490 <+1568>: add $0x8,%rsi > 0x000000000080e494 <+1572>: callq 0x161a190 <xrealloc> > 0x000000000080e499 <+1577>: mov 0x18(%rsp),%ecx > 0x000000000080e49d <+1581>: mov %rax,%rdx > 0x000000000080e4a0 <+1584>: mov %rax,0x8(%r15,%r13,8) > >1272 { >1273 typedef vec<T, A, vl_embed> vec_embedded; >1274 return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T); >1275 } >1276 >1277 >1278 /* Initialize the vector to contain room for ALLOC elements and >1279 NUM active elements. */ >1280 >1281 template<typename T, typename A> >1282 inline void >1283 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut) > 0x000000000080e4a5 <+1589>: and $0x7fffffff,%ecx > 0x000000000080e4ab <+1595>: mov %ecx,%eax > 0x000000000080e4ad <+1597>: mov %rax,(%rdx) > >530 for ( ; n; ++dst, ++src, --n) > 0x000000000080e4b0 <+1600>: test %ebp,%ebp > 0x000000000080e4b2 <+1602>: je 0x80e4ef <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1663> > 0x000000000080e4b4 <+1604>: lea -0x1(%rbp),%ecx > 0x000000000080e4b7 <+1607>: mov $0x8,%eax > 0x000000000080e4bc <+1612>: shl $0x5,%rcx > 0x000000000080e4c0 <+1616>: add $0x28,%rcx > 0x000000000080e4c4 <+1620>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e4cf <+1631>: nop > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/libstdc++-v3/libsupc++/new: >175 { return __p; } > 0x000000000080e4d0 <+1632>: vmovdqu (%rbx,%rax,1),%xmm0 > 0x000000000080e4d5 <+1637>: vmovdqu %xmm0,(%rdx,%rax,1) > 0x000000000080e4da <+1642>: vmovdqu 0x10(%rbx,%rax,1),%xmm1 > 0x000000000080e4e0 <+1648>: vmovdqu %xmm1,0x10(%rdx,%rax,1) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/vec.h: >530 for ( ; n; ++dst, ++src, --n) > 0x000000000080e4e6 <+1654>: add $0x20,%rax > 0x000000000080e4ea <+1658>: cmp %rax,%rcx > 0x000000000080e4ed <+1661>: jne 0x80e4d0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1632> > 0x000000000080e4ef <+1663>: mov %ebp,0x4(%rdx) > 0x000000000080e4f2 <+1666>: mov %rdx,%rbx > 0x000000000080e4f5 <+1669>: jmpq 0x80e26b <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1019> > 0x000000000080e4fa <+1674>: nopw 0x0(%rax,%rax,1) > 0x000000000080e500 <+1680>: mov %r14,%r15 > 0x000000000080e503 <+1683>: xor %r9d,%r9d > 0x000000000080e506 <+1686>: xor %edi,%edi > 0x000000000080e508 <+1688>: mov $0xffffffff,%r8d > 0x000000000080e50e <+1694>: shl $0x9,%r15 > 0x000000000080e512 <+1698>: mov $0x22,%ecx > 0x000000000080e517 <+1703>: mov $0x3,%edx > 0x000000000080e51c <+1708>: mov %r11,0x30(%rsp) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c: >822 page = alloc_anon (NULL, G.pagesize * GGC_QUIRE_SIZE, false); > 0x000000000080e521 <+1713>: mov %r15,%rsi > 0x000000000080e524 <+1716>: callq 0x5bee20 <mmap@plt> > 0x000000000080e529 <+1721>: mov 0x30(%rsp),%r11 > 0x000000000080e52e <+1726>: cmp $0xffffffffffffffff,%rax > 0x000000000080e532 <+1730>: mov %rax,%r13 > >714 if (page == (char *) MAP_FAILED) > 0x000000000080e535 <+1733>: je 0x80e6e7 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2167> > >717 return NULL; >718 perror ("virtual memory exhausted"); >719 exit (FATAL_EXIT_CODE); >720 } >721 >722 /* Remember that we allocated this memory. */ >723 G.bytes_mapped += size; > 0x000000000080e53b <+1739>: add %r15,0x1883ae6(%rip) # 0x2092028 <_ZL1G+1384> > >823 if (page == NULL) > 0x000000000080e542 <+1746>: test %rax,%rax > 0x000000000080e545 <+1749>: je 0x80e6e7 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2167> > >826 entries = 1; >827 } >828 >829 /* This loop counts down so that the chain will be in ascending >830 memory order. */ >831 for (i = entries - 1; i >= 1; i--) > 0x000000000080e54b <+1755>: mov $0x1ff,%r15d > 0x000000000080e551 <+1761>: mov %ebx,%edi > 0x000000000080e553 <+1763>: mov %bl,0x30(%rsp) > 0x000000000080e557 <+1767>: mov %rbx,0x48(%rsp) > 0x000000000080e55c <+1772>: mov %r15d,%ebx > 0x000000000080e55f <+1775>: mov %rbp,0x40(%rsp) > 0x000000000080e564 <+1780>: mov %r11,%rax > 0x000000000080e567 <+1783>: mov %r12,0x38(%rsp) > 0x000000000080e56c <+1788>: mov %edi,%ebp > 0x000000000080e56e <+1790>: mov 0x18(%rsp),%r15 > 0x000000000080e573 <+1795>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e57e <+1806>: xchg %ax,%ax > >832 { >833 e = XCNEWVAR (struct page_entry, page_entry_size); > 0x000000000080e580 <+1808>: mov %r15,%rsi > 0x000000000080e583 <+1811>: mov $0x1,%edi > 0x000000000080e588 <+1816>: mov %rax,%r12 > 0x000000000080e58b <+1819>: callq 0x161a130 <xcalloc> > >834 e->order = order; > 0x000000000080e590 <+1824>: mov 0x1883a71(%rip),%rdx # 0x2092008 <_ZL1G+1352> > 0x000000000080e597 <+1831>: mov %bpl,0x2e(%rax) > >835 e->bytes = G.pagesize; > 0x000000000080e59b <+1835>: mov %r12,(%rax) > 0x000000000080e59e <+1838>: mov %rdx,0x10(%rax) > >836 e->page = page + (i << G.lg_pagesize); > 0x000000000080e5a2 <+1842>: mov 0x1883a67(%rip),%rdx # 0x2092010 <_ZL1G+1360> > 0x000000000080e5a9 <+1849>: shlx %edx,%ebx,%edx > 0x000000000080e5ae <+1854>: movslq %edx,%rdx > 0x000000000080e5b1 <+1857>: add %r13,%rdx > 0x000000000080e5b4 <+1860>: dec %ebx > 0x000000000080e5b6 <+1862>: mov %rdx,0x18(%rax) > >837 e->next = f; >838 f = e; > 0x000000000080e5ba <+1866>: jne 0x80e580 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1808> > 0x000000000080e5bc <+1868>: mov 0x38(%rsp),%r12 > 0x000000000080e5c1 <+1873>: mov %rax,%r11 > 0x000000000080e5c4 <+1876>: mov 0x40(%rsp),%rbp > 0x000000000080e5c9 <+1881>: mov 0x48(%rsp),%rbx > >839 } >840 >841 G.free_pages = f; > 0x000000000080e5ce <+1886>: mov %r11,0x1883a73(%rip) # 0x2092048 <_ZL1G+1416> > >845 #endif >846 #ifdef USING_MALLOC_PAGE_GROUPS >847 else >848 { >849 /* Allocate a large block of memory and serve out the aligned >850 pages therein. This results in much less memory wastage >851 than the traditional implementation of valloc. */ >852 >853 char *allocation, *a, *enda; >854 size_t alloc_size, head_slop, tail_slop; >855 int multiple_pages = (entry_size == G.pagesize); >856 >857 if (multiple_pages) >858 alloc_size = GGC_QUIRE_SIZE * G.pagesize; >859 else >860 alloc_size = entry_size + G.pagesize - 1; >861 allocation = XNEWVEC (char, alloc_size); >862 >863 page = (char *) (((uintptr_t) allocation + G.pagesize - 1) & -G.pagesize); >864 head_slop = page - allocation; >865 if (multiple_pages) >866 tail_slop = ((size_t) allocation + alloc_size) & (G.pagesize - 1); >867 else >868 tail_slop = alloc_size - entry_size - head_slop; >869 enda = allocation + alloc_size - tail_slop; >870 >871 /* We allocated N pages, which are likely not aligned, leaving >872 us with N-1 usable pages. We plan to place the page_group >873 structure somewhere in the slop. */ >874 if (head_slop >= sizeof (page_group)) >875 group = (page_group *)page - 1; >876 else >877 { >878 /* We magically got an aligned allocation. Too bad, we have >879 to waste a page anyway. */ >880 if (tail_slop == 0) >881 { >882 enda -= G.pagesize; >883 tail_slop += G.pagesize; >884 } >885 gcc_assert (tail_slop >= sizeof (page_group)); >886 group = (page_group *)enda; >887 tail_slop -= sizeof (page_group); >888 } >889 >890 /* Remember that we allocated this memory. */ >891 group->next = G.page_groups; >892 group->allocation = allocation; >893 group->alloc_size = alloc_size; >894 group->in_use = 0; >895 G.page_groups = group; >896 G.bytes_mapped += alloc_size; >897 >898 /* If we allocated multiple pages, put the rest on the free list. */ >899 if (multiple_pages) >900 { >901 struct page_entry *e, *f = G.free_pages; >902 for (a = enda - G.pagesize; a != page; a -= G.pagesize) >903 { >904 e = XCNEWVAR (struct page_entry, page_entry_size); >905 e->order = order; >906 e->bytes = G.pagesize; >907 e->page = a; >908 e->group = group; >909 e->next = f; >910 f = e; >911 } >912 G.free_pages = f; >913 } >914 } >915 #endif >916 >917 if (entry == NULL) > 0x000000000080e5d5 <+1893>: jmpq 0x80df8e <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+286> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/vec.h: >2080 vec<T, va_heap, vl_ptr>::using_auto_storage () const > 0x000000000080e5da <+1898>: testb $0x80,0x3(%rbx) > 0x000000000080e5de <+1902>: jne 0x80e660 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2032> > >276 va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact > 0x000000000080e5e4 <+1908>: mov %r14d,%esi > 0x000000000080e5e7 <+1911>: mov %ebp,%edi > 0x000000000080e5e9 <+1913>: xor %ebp,%ebp > 0x000000000080e5eb <+1915>: callq 0x15a9810 <vec_prefix::calculate_allocation_1(unsigned int, unsigned int)> > 0x000000000080e5f0 <+1920>: mov 0x8(%r15,%r13,8),%rdi > 0x000000000080e5f5 <+1925>: mov %eax,%r14d > >892 { >893 return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems; >894 } >895 >896 >897 /* Return iteration condition and update PTR to point to the IX'th >898 element of this vector. Use this to iterate over the elements of a >899 vector as follows, >900 >901 for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++) >902 continue; */ >903 >904 template<typename T, typename A> >905 inline bool >906 vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const >907 { >908 if (ix < m_vecpfx.m_num) >909 { >910 *ptr = m_vecdata[ix]; >911 return true; >912 } >913 else >914 { >915 *ptr = 0; >916 return false; >917 } >918 } >919 >920 >921 /* Return iteration condition and update *PTR to point to the >922 IX'th element of this vector. Use this to iterate over the >923 elements of a vector as follows, >924 >925 for (ix = 0; v->iterate (ix, &ptr); ix++) >926 continue; >927 >928 This variant is for vectors of objects. */ >929 >930 template<typename T, typename A> >931 inline bool >932 vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const >933 { >934 if (ix < m_vecpfx.m_num) >935 { >936 *ptr = CONST_CAST (T *, &m_vecdata[ix]); >937 return true; >938 } >939 else >940 { >941 *ptr = 0; >942 return false; >943 } >944 } >945 >946 >947 /* Return a pointer to a copy of this vector. */ >948 >949 template<typename T, typename A> >950 inline vec<T, A, vl_embed> * >951 vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECL) const >952 { >953 vec<T, A, vl_embed> *new_vec = NULL; >954 unsigned len = length (); >955 if (len) >956 { >957 vec_alloc (new_vec, len PASS_MEM_STAT); >958 new_vec->embedded_init (len, len); >959 vec_copy_construct (new_vec->address (), m_vecdata, len); >960 } >961 return new_vec; >962 } >963 >964 >965 /* Copy the elements from SRC to the end of this vector as if by memcpy. >966 The vector must have sufficient headroom available. */ >967 >968 template<typename T, typename A> >969 inline void >970 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src) >971 { >972 unsigned len = src.length (); >973 if (len) >974 { >975 gcc_checking_assert (space (len)); >976 vec_copy_construct (end (), src.address (), len); >977 m_vecpfx.m_num += len; >978 } >979 } >980 >981 template<typename T, typename A> >982 inline void >983 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src) >984 { >985 if (src) >986 splice (*src); >987 } >988 >989 >990 /* Push OBJ (a new element) onto the end of the vector. There must be >991 sufficient space in the vector. Return a pointer to the slot >992 where OBJ was inserted. */ >993 >994 template<typename T, typename A> >995 inline T * >996 vec<T, A, vl_embed>::quick_push (const T &obj) >997 { >998 gcc_checking_assert (space (1)); >999 T *slot = &m_vecdata[m_vecpfx.m_num++]; >1000 *slot = obj; >1001 return slot; >1002 } >1003 >1004 >1005 /* Pop and return the last element off the end of the vector. */ >1006 >1007 template<typename T, typename A> >1008 inline T & >1009 vec<T, A, vl_embed>::pop (void) >1010 { >1011 gcc_checking_assert (length () > 0); >1012 return m_vecdata[--m_vecpfx.m_num]; >1013 } >1014 >1015 >1016 /* Set the length of the vector to SIZE. The new length must be less >1017 than or equal to the current length. This is an O(1) operation. */ >1018 >1019 template<typename T, typename A> >1020 inline void >1021 vec<T, A, vl_embed>::truncate (unsigned size) >1022 { >1023 gcc_checking_assert (length () >= size); >1024 m_vecpfx.m_num = size; >1025 } >1026 >1027 >1028 /* Insert an element, OBJ, at the IXth position of this vector. There >1029 must be sufficient space. */ >1030 >1031 template<typename T, typename A> >1032 inline void >1033 vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj) >1034 { >1035 gcc_checking_assert (length () < allocated ()); >1036 gcc_checking_assert (ix <= length ()); >1037 T *slot = &m_vecdata[ix]; >1038 memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T)); >1039 *slot = obj; >1040 } >1041 >1042 >1043 /* Remove an element from the IXth position of this vector. Ordering of >1044 remaining elements is preserved. This is an O(N) operation due to >1045 memmove. */ >1046 >1047 template<typename T, typename A> >1048 inline void >1049 vec<T, A, vl_embed>::ordered_remove (unsigned ix) >1050 { >1051 gcc_checking_assert (ix < length ()); >1052 T *slot = &m_vecdata[ix]; >1053 memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T)); >1054 } >1055 >1056 >1057 /* Remove elements in [START, END) from VEC for which COND holds. Ordering of >1058 remaining elements is preserved. This is an O(N) operation. */ >1059 >1060 #define VEC_ORDERED_REMOVE_IF_FROM_TO(vec, read_index, write_index, \ >1061 elem_ptr, start, end, cond) \ >1062 { \ >1063 gcc_assert ((end) <= (vec).length ()); \ >1064 for (read_index = write_index = (start); read_index < (end); \ >1065 ++read_index) \ >1066 { \ >1067 elem_ptr = &(vec)[read_index]; \ >1068 bool remove_p = (cond); \ >1069 if (remove_p) \ >1070 continue; \ >1071 \ >1072 if (read_index != write_index) \ >1073 (vec)[write_index] = (vec)[read_index]; \ >1074 \ >1075 write_index++; \ >1076 } \ >1077 \ >1078 if (read_index - write_index > 0) \ >1079 (vec).block_remove (write_index, read_index - write_index); \ >1080 } >1081 >1082 >1083 /* Remove elements from VEC for which COND holds. Ordering of remaining >1084 elements is preserved. This is an O(N) operation. */ >1085 >1086 #define VEC_ORDERED_REMOVE_IF(vec, read_index, write_index, elem_ptr, \ >1087 cond) \ >1088 VEC_ORDERED_REMOVE_IF_FROM_TO ((vec), read_index, write_index, \ >1089 elem_ptr, 0, (vec).length (), (cond)) >1090 >1091 /* Remove an element from the IXth position of this vector. Ordering of >1092 remaining elements is destroyed. This is an O(1) operation. */ >1093 >1094 template<typename T, typename A> >1095 inline void >1096 vec<T, A, vl_embed>::unordered_remove (unsigned ix) >1097 { >1098 gcc_checking_assert (ix < length ()); >1099 m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num]; >1100 } >1101 >1102 >1103 /* Remove LEN elements starting at the IXth. Ordering is retained. >1104 This is an O(N) operation due to memmove. */ >1105 >1106 template<typename T, typename A> >1107 inline void >1108 vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len) >1109 { >1110 gcc_checking_assert (ix + len <= length ()); >1111 T *slot = &m_vecdata[ix]; >1112 m_vecpfx.m_num -= len; >1113 memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T)); >1114 } >1115 >1116 >1117 /* Sort the contents of this vector with qsort. CMP is the comparison >1118 function to pass to qsort. */ >1119 >1120 template<typename T, typename A> >1121 inline void >1122 vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *)) >1123 { >1124 if (length () > 1) >1125 gcc_qsort (address (), length (), sizeof (T), cmp); >1126 } >1127 >1128 /* Sort the contents of this vector with qsort. CMP is the comparison >1129 function to pass to qsort. */ >1130 >1131 template<typename T, typename A> >1132 inline void >1133 vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *), >1134 void *data) >1135 { >1136 if (length () > 1) >1137 gcc_sort_r (address (), length (), sizeof (T), cmp, data); >1138 } >1139 >1140 >1141 /* Search the contents of the sorted vector with a binary search. >1142 CMP is the comparison function to pass to bsearch. */ >1143 >1144 template<typename T, typename A> >1145 inline T * >1146 vec<T, A, vl_embed>::bsearch (const void *key, >1147 int (*compar) (const void *, const void *)) >1148 { >1149 const void *base = this->address (); >1150 size_t nmemb = this->length (); >1151 size_t size = sizeof (T); >1152 /* The following is a copy of glibc stdlib-bsearch.h. */ >1153 size_t l, u, idx; >1154 const void *p; >1155 int comparison; >1156 >1157 l = 0; >1158 u = nmemb; >1159 while (l < u) >1160 { >1161 idx = (l + u) / 2; >1162 p = (const void *) (((const char *) base) + (idx * size)); >1163 comparison = (*compar) (key, p); >1164 if (comparison < 0) >1165 u = idx; >1166 else if (comparison > 0) >1167 l = idx + 1; >1168 else >1169 return (T *)const_cast<void *>(p); >1170 } >1171 >1172 return NULL; >1173 } >1174 >1175 /* Search the contents of the sorted vector with a binary search. >1176 CMP is the comparison function to pass to bsearch. */ >1177 >1178 template<typename T, typename A> >1179 inline T * >1180 vec<T, A, vl_embed>::bsearch (const void *key, >1181 int (*compar) (const void *, const void *, >1182 void *), void *data) >1183 { >1184 const void *base = this->address (); >1185 size_t nmemb = this->length (); >1186 size_t size = sizeof (T); >1187 /* The following is a copy of glibc stdlib-bsearch.h. */ >1188 size_t l, u, idx; >1189 const void *p; >1190 int comparison; >1191 >1192 l = 0; >1193 u = nmemb; >1194 while (l < u) >1195 { >1196 idx = (l + u) / 2; >1197 p = (const void *) (((const char *) base) + (idx * size)); >1198 comparison = (*compar) (key, p, data); >1199 if (comparison < 0) >1200 u = idx; >1201 else if (comparison > 0) >1202 l = idx + 1; >1203 else >1204 return (T *)const_cast<void *>(p); >1205 } >1206 >1207 return NULL; >1208 } >1209 >1210 /* Return true if SEARCH is an element of V. Note that this is O(N) in the >1211 size of the vector and so should be used with care. */ >1212 >1213 template<typename T, typename A> >1214 inline bool >1215 vec<T, A, vl_embed>::contains (const T &search) const >1216 { >1217 unsigned int len = length (); >1218 for (unsigned int i = 0; i < len; i++) >1219 if ((*this)[i] == search) >1220 return true; >1221 >1222 return false; >1223 } >1224 >1225 /* Find and return the first position in which OBJ could be inserted >1226 without changing the ordering of this vector. LESSTHAN is a >1227 function that returns true if the first argument is strictly less >1228 than the second. */ >1229 >1230 template<typename T, typename A> >1231 unsigned >1232 vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &)) >1233 const >1234 { >1235 unsigned int len = length (); >1236 unsigned int half, middle; >1237 unsigned int first = 0; >1238 while (len > 0) >1239 { >1240 half = len / 2; >1241 middle = first; >1242 middle += half; >1243 T middle_elem = (*this)[middle]; >1244 if (lessthan (middle_elem, obj)) >1245 { >1246 first = middle; >1247 ++first; >1248 len = len - half - 1; >1249 } >1250 else >1251 len = half; >1252 } >1253 return first; >1254 } >1255 >1256 >1257 /* Return the number of bytes needed to embed an instance of an >1258 embeddable vec inside another data structure. >1259 >1260 Use these methods to determine the required size and initialization >1261 of a vector V of type T embedded within another structure (as the >1262 final member): >1263 >1264 size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc); >1265 void v->embedded_init (unsigned alloc, unsigned num); >1266 >1267 These allow the caller to perform the memory allocation. */ >1268 >1269 template<typename T, typename A> >1270 inline size_t >1271 vec<T, A, vl_embed>::embedded_size (unsigned alloc) > 0x000000000080e5f8 <+1928>: mov %eax,%eax > 0x000000000080e5fa <+1930>: shl $0x4,%rax > 0x000000000080e5fe <+1934>: lea 0x8(%rax),%rsi > 0x000000000080e602 <+1938>: test %rdi,%rdi > 0x000000000080e605 <+1941>: je 0x80e60a <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1946> > >579 unsigned length (void) const { return m_vecpfx.m_num; } > 0x000000000080e607 <+1943>: mov 0x4(%rdi),%ebp > 0x000000000080e60a <+1946>: callq 0x161a190 <xrealloc> > 0x000000000080e60f <+1951>: and $0x7fffffff,%r14d > 0x000000000080e616 <+1958>: mov %rax,0x8(%r15,%r13,8) > >1272 { >1273 typedef vec<T, A, vl_embed> vec_embedded; >1274 return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T); >1275 } >1276 >1277 >1278 /* Initialize the vector to contain room for ALLOC elements and >1279 NUM active elements. */ >1280 >1281 template<typename T, typename A> >1282 inline void >1283 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut) > 0x000000000080e61b <+1963>: mov %rax,%rbx > 0x000000000080e61e <+1966>: mov %r14d,(%rax) > 0x000000000080e621 <+1969>: mov %ebp,0x4(%rax) > 0x000000000080e624 <+1972>: lea 0x1(%rbp),%r14d > 0x000000000080e628 <+1976>: jmpq 0x80e3fb <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1419> > >1271 vec<T, A, vl_embed>::embedded_size (unsigned alloc) > 0x000000000080e62d <+1981>: mov $0x88,%esi > 0x000000000080e632 <+1986>: xor %edi,%edi > 0x000000000080e634 <+1988>: xor %ebp,%ebp > 0x000000000080e636 <+1990>: mov $0x1,%r14d > 0x000000000080e63c <+1996>: callq 0x161a190 <xrealloc> > 0x000000000080e641 <+2001>: mov %rax,0x8(%r15,%r13,8) > >1272 { >1273 typedef vec<T, A, vl_embed> vec_embedded; >1274 return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T); >1275 } >1276 >1277 >1278 /* Initialize the vector to contain room for ALLOC elements and >1279 NUM active elements. */ >1280 >1281 template<typename T, typename A> >1282 inline void >1283 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut) > 0x000000000080e646 <+2006>: mov %rax,%rbx > 0x000000000080e649 <+2009>: movq $0x4,(%rax) > 0x000000000080e650 <+2016>: jmpq 0x80e26b <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1019> > 0x000000000080e655 <+2021>: data16 nopw %cs:0x0(%rax,%rax,1) > 0x000000000080e660 <+2032>: mov $0x4,%ecx > 0x000000000080e665 <+2037>: movq $0x0,0x8(%r15,%r13,8) > >276 va_heap::reserve (vec<T, va_heap, vl_embed> *&v, unsigned reserve, bool exact > 0x000000000080e66e <+2046>: cmp %ecx,%r14d > 0x000000000080e671 <+2049>: cmovae %r14d,%ecx > >892 { >893 return m_vecpfx.m_alloc - m_vecpfx.m_num >= nelems; >894 } >895 >896 >897 /* Return iteration condition and update PTR to point to the IX'th >898 element of this vector. Use this to iterate over the elements of a >899 vector as follows, >900 >901 for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++) >902 continue; */ >903 >904 template<typename T, typename A> >905 inline bool >906 vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const >907 { >908 if (ix < m_vecpfx.m_num) >909 { >910 *ptr = m_vecdata[ix]; >911 return true; >912 } >913 else >914 { >915 *ptr = 0; >916 return false; >917 } >918 } >919 >920 >921 /* Return iteration condition and update *PTR to point to the >922 IX'th element of this vector. Use this to iterate over the >923 elements of a vector as follows, >924 >925 for (ix = 0; v->iterate (ix, &ptr); ix++) >926 continue; >927 >928 This variant is for vectors of objects. */ >929 >930 template<typename T, typename A> >931 inline bool >932 vec<T, A, vl_embed>::iterate (unsigned ix, T **ptr) const >933 { >934 if (ix < m_vecpfx.m_num) >935 { >936 *ptr = CONST_CAST (T *, &m_vecdata[ix]); >937 return true; >938 } >939 else >940 { >941 *ptr = 0; >942 return false; >943 } >944 } >945 >946 >947 /* Return a pointer to a copy of this vector. */ >948 >949 template<typename T, typename A> >950 inline vec<T, A, vl_embed> * >951 vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECL) const >952 { >953 vec<T, A, vl_embed> *new_vec = NULL; >954 unsigned len = length (); >955 if (len) >956 { >957 vec_alloc (new_vec, len PASS_MEM_STAT); >958 new_vec->embedded_init (len, len); >959 vec_copy_construct (new_vec->address (), m_vecdata, len); >960 } >961 return new_vec; >962 } >963 >964 >965 /* Copy the elements from SRC to the end of this vector as if by memcpy. >966 The vector must have sufficient headroom available. */ >967 >968 template<typename T, typename A> >969 inline void >970 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> &src) >971 { >972 unsigned len = src.length (); >973 if (len) >974 { >975 gcc_checking_assert (space (len)); >976 vec_copy_construct (end (), src.address (), len); >977 m_vecpfx.m_num += len; >978 } >979 } >980 >981 template<typename T, typename A> >982 inline void >983 vec<T, A, vl_embed>::splice (const vec<T, A, vl_embed> *src) >984 { >985 if (src) >986 splice (*src); >987 } >988 >989 >990 /* Push OBJ (a new element) onto the end of the vector. There must be >991 sufficient space in the vector. Return a pointer to the slot >992 where OBJ was inserted. */ >993 >994 template<typename T, typename A> >995 inline T * >996 vec<T, A, vl_embed>::quick_push (const T &obj) >997 { >998 gcc_checking_assert (space (1)); >999 T *slot = &m_vecdata[m_vecpfx.m_num++]; >1000 *slot = obj; >1001 return slot; >1002 } >1003 >1004 >1005 /* Pop and return the last element off the end of the vector. */ >1006 >1007 template<typename T, typename A> >1008 inline T & >1009 vec<T, A, vl_embed>::pop (void) >1010 { >1011 gcc_checking_assert (length () > 0); >1012 return m_vecdata[--m_vecpfx.m_num]; >1013 } >1014 >1015 >1016 /* Set the length of the vector to SIZE. The new length must be less >1017 than or equal to the current length. This is an O(1) operation. */ >1018 >1019 template<typename T, typename A> >1020 inline void >1021 vec<T, A, vl_embed>::truncate (unsigned size) >1022 { >1023 gcc_checking_assert (length () >= size); >1024 m_vecpfx.m_num = size; >1025 } >1026 >1027 >1028 /* Insert an element, OBJ, at the IXth position of this vector. There >1029 must be sufficient space. */ >1030 >1031 template<typename T, typename A> >1032 inline void >1033 vec<T, A, vl_embed>::quick_insert (unsigned ix, const T &obj) >1034 { >1035 gcc_checking_assert (length () < allocated ()); >1036 gcc_checking_assert (ix <= length ()); >1037 T *slot = &m_vecdata[ix]; >1038 memmove (slot + 1, slot, (m_vecpfx.m_num++ - ix) * sizeof (T)); >1039 *slot = obj; >1040 } >1041 >1042 >1043 /* Remove an element from the IXth position of this vector. Ordering of >1044 remaining elements is preserved. This is an O(N) operation due to >1045 memmove. */ >1046 >1047 template<typename T, typename A> >1048 inline void >1049 vec<T, A, vl_embed>::ordered_remove (unsigned ix) >1050 { >1051 gcc_checking_assert (ix < length ()); >1052 T *slot = &m_vecdata[ix]; >1053 memmove (slot, slot + 1, (--m_vecpfx.m_num - ix) * sizeof (T)); >1054 } >1055 >1056 >1057 /* Remove elements in [START, END) from VEC for which COND holds. Ordering of >1058 remaining elements is preserved. This is an O(N) operation. */ >1059 >1060 #define VEC_ORDERED_REMOVE_IF_FROM_TO(vec, read_index, write_index, \ >1061 elem_ptr, start, end, cond) \ >1062 { \ >1063 gcc_assert ((end) <= (vec).length ()); \ >1064 for (read_index = write_index = (start); read_index < (end); \ >1065 ++read_index) \ >1066 { \ >1067 elem_ptr = &(vec)[read_index]; \ >1068 bool remove_p = (cond); \ >1069 if (remove_p) \ >1070 continue; \ >1071 \ >1072 if (read_index != write_index) \ >1073 (vec)[write_index] = (vec)[read_index]; \ >1074 \ >1075 write_index++; \ >1076 } \ >1077 \ >1078 if (read_index - write_index > 0) \ >1079 (vec).block_remove (write_index, read_index - write_index); \ >1080 } >1081 >1082 >1083 /* Remove elements from VEC for which COND holds. Ordering of remaining >1084 elements is preserved. This is an O(N) operation. */ >1085 >1086 #define VEC_ORDERED_REMOVE_IF(vec, read_index, write_index, elem_ptr, \ >1087 cond) \ >1088 VEC_ORDERED_REMOVE_IF_FROM_TO ((vec), read_index, write_index, \ >1089 elem_ptr, 0, (vec).length (), (cond)) >1090 >1091 /* Remove an element from the IXth position of this vector. Ordering of >1092 remaining elements is destroyed. This is an O(1) operation. */ >1093 >1094 template<typename T, typename A> >1095 inline void >1096 vec<T, A, vl_embed>::unordered_remove (unsigned ix) >1097 { >1098 gcc_checking_assert (ix < length ()); >1099 m_vecdata[ix] = m_vecdata[--m_vecpfx.m_num]; >1100 } >1101 >1102 >1103 /* Remove LEN elements starting at the IXth. Ordering is retained. >1104 This is an O(N) operation due to memmove. */ >1105 >1106 template<typename T, typename A> >1107 inline void >1108 vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len) >1109 { >1110 gcc_checking_assert (ix + len <= length ()); >1111 T *slot = &m_vecdata[ix]; >1112 m_vecpfx.m_num -= len; >1113 memmove (slot, slot + len, (m_vecpfx.m_num - ix) * sizeof (T)); >1114 } >1115 >1116 >1117 /* Sort the contents of this vector with qsort. CMP is the comparison >1118 function to pass to qsort. */ >1119 >1120 template<typename T, typename A> >1121 inline void >1122 vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *)) >1123 { >1124 if (length () > 1) >1125 gcc_qsort (address (), length (), sizeof (T), cmp); >1126 } >1127 >1128 /* Sort the contents of this vector with qsort. CMP is the comparison >1129 function to pass to qsort. */ >1130 >1131 template<typename T, typename A> >1132 inline void >1133 vec<T, A, vl_embed>::sort (int (*cmp) (const void *, const void *, void *), >1134 void *data) >1135 { >1136 if (length () > 1) >1137 gcc_sort_r (address (), length (), sizeof (T), cmp, data); >1138 } >1139 >1140 >1141 /* Search the contents of the sorted vector with a binary search. >1142 CMP is the comparison function to pass to bsearch. */ >1143 >1144 template<typename T, typename A> >1145 inline T * >1146 vec<T, A, vl_embed>::bsearch (const void *key, >1147 int (*compar) (const void *, const void *)) >1148 { >1149 const void *base = this->address (); >1150 size_t nmemb = this->length (); >1151 size_t size = sizeof (T); >1152 /* The following is a copy of glibc stdlib-bsearch.h. */ >1153 size_t l, u, idx; >1154 const void *p; >1155 int comparison; >1156 >1157 l = 0; >1158 u = nmemb; >1159 while (l < u) >1160 { >1161 idx = (l + u) / 2; >1162 p = (const void *) (((const char *) base) + (idx * size)); >1163 comparison = (*compar) (key, p); >1164 if (comparison < 0) >1165 u = idx; >1166 else if (comparison > 0) >1167 l = idx + 1; >1168 else >1169 return (T *)const_cast<void *>(p); >1170 } >1171 >1172 return NULL; >1173 } >1174 >1175 /* Search the contents of the sorted vector with a binary search. >1176 CMP is the comparison function to pass to bsearch. */ >1177 >1178 template<typename T, typename A> >1179 inline T * >1180 vec<T, A, vl_embed>::bsearch (const void *key, >1181 int (*compar) (const void *, const void *, >1182 void *), void *data) >1183 { >1184 const void *base = this->address (); >1185 size_t nmemb = this->length (); >1186 size_t size = sizeof (T); >1187 /* The following is a copy of glibc stdlib-bsearch.h. */ >1188 size_t l, u, idx; >1189 const void *p; >1190 int comparison; >1191 >1192 l = 0; >1193 u = nmemb; >1194 while (l < u) >1195 { >1196 idx = (l + u) / 2; >1197 p = (const void *) (((const char *) base) + (idx * size)); >1198 comparison = (*compar) (key, p, data); >1199 if (comparison < 0) >1200 u = idx; >1201 else if (comparison > 0) >1202 l = idx + 1; >1203 else >1204 return (T *)const_cast<void *>(p); >1205 } >1206 >1207 return NULL; >1208 } >1209 >1210 /* Return true if SEARCH is an element of V. Note that this is O(N) in the >1211 size of the vector and so should be used with care. */ >1212 >1213 template<typename T, typename A> >1214 inline bool >1215 vec<T, A, vl_embed>::contains (const T &search) const >1216 { >1217 unsigned int len = length (); >1218 for (unsigned int i = 0; i < len; i++) >1219 if ((*this)[i] == search) >1220 return true; >1221 >1222 return false; >1223 } >1224 >1225 /* Find and return the first position in which OBJ could be inserted >1226 without changing the ordering of this vector. LESSTHAN is a >1227 function that returns true if the first argument is strictly less >1228 than the second. */ >1229 >1230 template<typename T, typename A> >1231 unsigned >1232 vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &)) >1233 const >1234 { >1235 unsigned int len = length (); >1236 unsigned int half, middle; >1237 unsigned int first = 0; >1238 while (len > 0) >1239 { >1240 half = len / 2; >1241 middle = first; >1242 middle += half; >1243 T middle_elem = (*this)[middle]; >1244 if (lessthan (middle_elem, obj)) >1245 { >1246 first = middle; >1247 ++first; >1248 len = len - half - 1; >1249 } >1250 else >1251 len = half; >1252 } >1253 return first; >1254 } >1255 >1256 >1257 /* Return the number of bytes needed to embed an instance of an >1258 embeddable vec inside another data structure. >1259 >1260 Use these methods to determine the required size and initialization >1261 of a vector V of type T embedded within another structure (as the >1262 final member): >1263 >1264 size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc); >1265 void v->embedded_init (unsigned alloc, unsigned num); >1266 >1267 These allow the caller to perform the memory allocation. */ >1268 >1269 template<typename T, typename A> >1270 inline size_t >1271 vec<T, A, vl_embed>::embedded_size (unsigned alloc) > 0x000000000080e675 <+2053>: xor %edi,%edi > 0x000000000080e677 <+2055>: mov %ecx,%esi > 0x000000000080e679 <+2057>: mov %ecx,0x8(%rsp) > 0x000000000080e67d <+2061>: shl $0x4,%rsi > 0x000000000080e681 <+2065>: add $0x8,%rsi > 0x000000000080e685 <+2069>: callq 0x161a190 <xrealloc> > 0x000000000080e68a <+2074>: mov 0x8(%rsp),%ecx > 0x000000000080e68e <+2078>: mov %rax,%rdx > 0x000000000080e691 <+2081>: mov %rax,0x8(%r15,%r13,8) > >1272 { >1273 typedef vec<T, A, vl_embed> vec_embedded; >1274 return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T); >1275 } >1276 >1277 >1278 /* Initialize the vector to contain room for ALLOC elements and >1279 NUM active elements. */ >1280 >1281 template<typename T, typename A> >1282 inline void >1283 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut) > 0x000000000080e696 <+2086>: and $0x7fffffff,%ecx > 0x000000000080e69c <+2092>: mov %ecx,%eax > 0x000000000080e69e <+2094>: mov %rax,(%rdx) > >530 for ( ; n; ++dst, ++src, --n) > 0x000000000080e6a1 <+2097>: test %ebp,%ebp > 0x000000000080e6a3 <+2099>: je 0x80e6d3 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2147> > 0x000000000080e6a5 <+2101>: lea -0x1(%rbp),%ecx > 0x000000000080e6a8 <+2104>: mov $0x8,%eax > 0x000000000080e6ad <+2109>: shl $0x4,%rcx > 0x000000000080e6b1 <+2113>: add $0x18,%rcx > 0x000000000080e6b5 <+2117>: data16 nopw %cs:0x0(%rax,%rax,1) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/libstdc++-v3/libsupc++/new: >175 { return __p; } > 0x000000000080e6c0 <+2128>: vmovdqu (%rbx,%rax,1),%xmm2 > 0x000000000080e6c5 <+2133>: vmovdqu %xmm2,(%rdx,%rax,1) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/vec.h: >530 for ( ; n; ++dst, ++src, --n) > 0x000000000080e6ca <+2138>: add $0x10,%rax > 0x000000000080e6ce <+2142>: cmp %rax,%rcx > 0x000000000080e6d1 <+2145>: jne 0x80e6c0 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2128> > 0x000000000080e6d3 <+2147>: mov %ebp,0x4(%rdx) > 0x000000000080e6d6 <+2150>: mov %rdx,%rbx > 0x000000000080e6d9 <+2153>: jmpq 0x80e3fb <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1419> > 0x000000000080e6de <+2158>: xor %ecx,%ecx > 0x000000000080e6e0 <+2160>: xor %edx,%edx > 0x000000000080e6e2 <+2162>: jmpq 0x80e163 <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+755> > 0x000000000080e6e7 <+2167>: mov 0x188391a(%rip),%r15 # 0x2092008 <_ZL1G+1352> > 0x000000000080e6ee <+2174>: xor %r9d,%r9d > 0x000000000080e6f1 <+2177>: xor %edi,%edi > 0x000000000080e6f3 <+2179>: mov $0xffffffff,%r8d > 0x000000000080e6f9 <+2185>: mov $0x22,%ecx > 0x000000000080e6fe <+2190>: mov $0x3,%edx > 0x000000000080e703 <+2195>: mov %r11,0x30(%rsp) > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c: >825 page = alloc_anon (NULL, G.pagesize, true); > 0x000000000080e708 <+2200>: mov %r15,%rsi > 0x000000000080e70b <+2203>: callq 0x5bee20 <mmap@plt> > 0x000000000080e710 <+2208>: mov 0x30(%rsp),%r11 > 0x000000000080e715 <+2213>: cmp $0xffffffffffffffff,%rax > 0x000000000080e719 <+2217>: mov %rax,%r13 > >714 if (page == (char *) MAP_FAILED) > 0x000000000080e71c <+2220>: je 0x80e72e <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+2238> > >717 return NULL; >718 perror ("virtual memory exhausted"); >719 exit (FATAL_EXIT_CODE); >720 } >721 >722 /* Remember that we allocated this memory. */ >723 G.bytes_mapped += size; > 0x000000000080e71e <+2222>: add %r15,0x1883903(%rip) # 0x2092028 <_ZL1G+1384> > >826 entries = 1; >827 } >828 >829 /* This loop counts down so that the chain will be in ascending >830 memory order. */ >831 for (i = entries - 1; i >= 1; i--) > 0x000000000080e725 <+2229>: mov %bl,0x30(%rsp) > 0x000000000080e729 <+2233>: jmpq 0x80e5ce <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1886> > >716 if (!check) > 0x000000000080e72e <+2238>: callq 0x80dd70 <alloc_anon(bool, size_t, char*)> > >/var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/vec.h: >1271 vec<T, A, vl_embed>::embedded_size (unsigned alloc) > 0x000000000080e733 <+2243>: mov $0x48,%esi > 0x000000000080e738 <+2248>: xor %edi,%edi > 0x000000000080e73a <+2250>: xor %ebp,%ebp > 0x000000000080e73c <+2252>: mov $0x1,%r14d > 0x000000000080e742 <+2258>: callq 0x161a190 <xrealloc> > 0x000000000080e747 <+2263>: mov %rax,0x8(%r15,%r13,8) > >1272 { >1273 typedef vec<T, A, vl_embed> vec_embedded; >1274 return offsetof (vec_embedded, m_vecdata) + alloc * sizeof (T); >1275 } >1276 >1277 >1278 /* Initialize the vector to contain room for ALLOC elements and >1279 NUM active elements. */ >1280 >1281 template<typename T, typename A> >1282 inline void >1283 vec<T, A, vl_embed>::embedded_init (unsigned alloc, unsigned num, unsigned aut) > 0x000000000080e74c <+2268>: mov %rax,%rbx > 0x000000000080e74f <+2271>: movq $0x4,(%rax) > 0x000000000080e756 <+2278>: jmpq 0x80e3fb <ggc_internal_alloc(unsigned long, void (*)(void*), unsigned long, unsigned long)+1419> >End of assembler dump. >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 281474976710664 >0x000000000080de7a in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 281474976710664 >New value = 140737181253040 >0x000000000080de7e in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1283 >1283 ggc_round_alloc_size_1 (size, &order, &object_size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737181253040 >New value = 281474976710664 >0x000000000080e299 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 281474976710664 >New value = -6399947259967866368 >0x000000000080e29d in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 1 >0x000000000080e29e in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = 0 >0x000000000080e2a0 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = 65771872 >0x000000000080e2a2 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 65771872 >New value = 140737188118656 >0x000000000080e2a4 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188118656 >New value = 140737488343312 >0x000000000080e2a6 in ggc_internal_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-page.c:1455 >1455 return result; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343312 >New value = 1 >ggc_internal_cleared_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-common.c:118 >118 memset (buf, 0, size); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = 140737488343312 >0x00000000005be370 in memset@plt () >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343312 >New value = 1 >ggc_internal_cleared_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-common.c:119 >119 return buf; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 1 >New value = 0 >0x00000000009b9719 in ggc_internal_cleared_alloc (size=size@entry=64, f=f@entry=0x0, s=s@entry=0, n=n@entry=1) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/ggc-common.c:119 >119 return buf; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 0 >New value = -6399947259967866368 >gimple_alloc (num_ops=0, code=GIMPLE_BIND) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimple.c:154 >154 gimple_init (stmt, code, num_ops); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = -6399947259967866368 >New value = 48 >0x00000000009bd7ea in gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimple.c:591 >591 return p; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 48 >New value = 140737188104128 >0x00000000009bd7eb in gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimple.c:591 >591 return p; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737188104128 >New value = 140737488343320 >0x00000000009bd7ed in gimple_build_bind (vars=0x7fffeddb8090, body=body@entry=0x0, block=<optimized out>) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimple.c:591 >591 return p; >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343320 >New value = 140737488343048 >gimplify_bind_expr (expr_p=expr_p@entry=0x7fffee1a87c0, pre_p=pre_p@entry=0x7fffffffd118) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/gcc/gimplify.c:1417 >1417 gimple_push_bind_expr (bind_stmt); >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343048 >New value = 140737488343320 >xrealloc (oldmem=oldmem@entry=0x0, size=size@entry=72) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/libiberty/xmalloc.c:171 >171 { >(gdb) c >Continuing. > >Thread 2.1 "cc1plus" hit Watchpoint 4: *(long*)($rsp+0x78) > >Old value = 140737488343320 >New value = 140737188104128 >0x000000000161a195 in xrealloc (oldmem=oldmem@entry=0x0, size=size@entry=72) at /var/tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/libiberty/xmalloc.c:174 >174 if (size == 0) >(gdb) quit >A debugging session is active. > > Inferior 2 [process 2237] will be killed. > >Quit anyway? (y or n) y
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Raw
Actions:
View
Attachments on
bug 730406
:
647330
|
650084
|
650112
|
650230
|
650246
|
650402
| 650644 |
650886
|
650896
|
651584
|
651586
|
651680
|
652808
|
652810
|
652812
|
653616
|
653939
|
656910
|
656980