From mboxrd@z Thu Jan 1 00:00:00 1970 X-Msuck: nntp://news.gmane.org/gmane.linux.lib.musl.general/7629 Path: news.gmane.org!not-for-mail From: Alex Dowad Newsgroups: gmane.linux.lib.musl.general Subject: [PATCH] First prototype of script which adds CFI directives to x86 asm Date: Tue, 12 May 2015 23:28:44 +0200 Message-ID: <1431466124-2848-1-git-send-email-alexinbeijing@gmail.com> Reply-To: musl@lists.openwall.com NNTP-Posting-Host: plane.gmane.org X-Trace: ger.gmane.org 1431466167 7018 80.91.229.3 (12 May 2015 21:29:27 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Tue, 12 May 2015 21:29:27 +0000 (UTC) To: musl@lists.openwall.com Original-X-From: musl-return-7641-gllmg-musl=m.gmane.org@lists.openwall.com Tue May 12 23:29:27 2015 Return-path: Envelope-to: gllmg-musl@m.gmane.org Original-Received: from mother.openwall.net ([195.42.179.200]) by plane.gmane.org with smtp (Exim 4.69) (envelope-from ) id 1YsHjy-0000mx-Uv for gllmg-musl@m.gmane.org; Tue, 12 May 2015 23:29:27 +0200 Original-Received: (qmail 11730 invoked by uid 550); 12 May 2015 21:29:25 -0000 Mailing-List: contact musl-help@lists.openwall.com; run by ezmlm Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: Original-Received: (qmail 11647 invoked from network); 12 May 2015 21:29:06 -0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=from:to:subject:date:message-id; bh=aMAJtbUd1gOK8sLeDWXb7lZExEW6l+7/0GFaFc67a4I=; b=QDg+hIWipqmWBe5NPvFj6spTbF6Eh57Sgg5ulCJ2VmypSIHtz1/WjnAg/YW0LrvgHN wA+KaF4rWc1Bc3a8UvIKPYM1KybitqZKHvZpeqSCa3RlDbDm6Aa5IVBItQE3U/EG51H1 FzE8bx6DS8tirhpfTb9ayXQhPMd8SGWDiUCxrEV5jjZHXRbPnFGIIs56dUjcRg7BOmQS 9rx7Pj5c8G0GuYMjKgYqZAemmOohcX1WbDMlokeP1dRuwQOcl4ftnswcg35J7xDsFxhF GoqOAKvRo016BNVYeNTB7V3a0enU36bC3ZONeqdeE+rBcUghNPfvPeYFfaB4k5iMsFGW mw3w== X-Received: by 10.194.61.171 with SMTP id q11mr32717904wjr.110.1431466134749; Tue, 12 May 2015 14:28:54 -0700 (PDT) X-Mailer: git-send-email 2.0.0.GIT Xref: news.gmane.org gmane.linux.lib.musl.general:7629 Archived-At: Some functions implemented in asm need to use EBP for purposes other than acting as a frame pointer. (Notably, it is used for the 6th argument to syscalls with 6 arguments.) Without frame pointers, GDB can only show backtraces if it gets CFI information from a .debug_frame or .eh_frame ELF section. Rather than littering our asm with ugly .cfi directives, use an awk script to insert them in the right places during the build process, so GDB can keep track of where the current stack frame is relative to the stack pointer. This means GDB can produce beautiful stack traces at any given point when single-stepping through asm functions. Additionally, when registers are saved on the stack and later overwritten, emit .cfi directives so GDB will know where they were saved relative to the stack pointer. This way, when you look back up the stack from within an asm function, you can still reliably print the values of local variables in the caller. If this awk script were to understand every possible wild and crazy contortion that an asm programmer can do with the stack and registers, and always emit the exact .cfi directives needed for GDB to know what the register values were in the preceding stack frame, it would necessarily be as complex as a full x86 emulator. That way lies madness. Hence, we assume that the stack pointer will _only_ ever be adjusted using push/pop or else add/sub with a constant. We do not attempt to detect every possible way that a register value could be saved for later use. --- Dear muslers, In response to an earlier patch adding CFI debug info to __syscall_cp_asm, R. Felkner suggested using an AWK script instead to automatically add the directives at build time (thus keeping the asm nice and clean and pretty). Here is a prototype of such a script. As you can see, it is specific to i386. Given the relative brevity and simplicity of the script, I don't see any benefit to be had in trying to generalize the script to handle other archs (thus obfuscating it). The amount of common code which could be pulled out is small. Better to just add a comparable script for each arch. (This can be done incrementally as people feel the need.) I have tested this on my dev PC -- the GDB backtraces look good. I can also print out the correct value of registers in the caller's stack frame, even when the value has been changed in the callee. Regards, Alex Dowad Makefile | 4 ++ tools/add-cfi.awk.i386 | 152 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 156 insertions(+) create mode 100644 tools/add-cfi.awk.i386 diff --git a/Makefile b/Makefile index 6559295..f7335aa 100644 --- a/Makefile +++ b/Makefile @@ -118,7 +118,11 @@ $(foreach s,$(wildcard src/*/$(ARCH)*/*.s),$(eval $(call mkasmdep,$(s)))) $(CC) $(CFLAGS_ALL_STATIC) -c -o $@ $(dir $<)$(shell cat $<) %.o: $(ARCH)/%.s +ifeq ($(ARCH),i386) + awk -f tools/add-cfi.awk.i386 $< | $(CC) $(CFLAGS_ALL_STATIC) -x assembler -c -o $@ - +else $(CC) $(CFLAGS_ALL_STATIC) -c -o $@ $< +endif %.o: %.c $(GENH) $(IMPH) $(CC) $(CFLAGS_ALL_STATIC) -c -o $@ $< diff --git a/tools/add-cfi.awk.i386 b/tools/add-cfi.awk.i386 new file mode 100644 index 0000000..7eacc18 --- /dev/null +++ b/tools/add-cfi.awk.i386 @@ -0,0 +1,152 @@ +# Insert GAS CFI directives ("control frame information") into x86-32 asm input +# +# CFI directives tell the assembler how to generate "stack frame" debug info +# This information can tell a debugger (like gdb) how to find the current stack +# frame at any point in the program code, and how to find the values which +# various registers had at higher points in the call stack +# With this information, the debugger can show a backtrace, and you can move up +# and down the call stack and examine the values of local variables + +BEGIN { + # don"t put CFI data in the .eh_frame ELF section (which we don't keep) + print ".cfi_sections .debug_frame" + + # only emit CFI directives inside a function callable from C + # (blindly emitting a '.cfi_startproc' at the beginning of each file and + # '.cfi_endproc' at the end doesn't work) + in_function = 0 +} + +function hex2int(str) { + str = tolower(str) + + for (i = 1; i <= 16; i++) { + char = substr("0123456789abcdef", i, 1) + lookup[char] = i-1 + } + + result = 0 + for (i = 1; i <= length(str); i++) { + result = result * 16 + char = substr(str, i, 1) + result = result + lookup[char] + } + return result +} + +function get_const() { + # only use if you already know there is 1 and only 1 constant + match($0, /\$[0-9a-fA-F]+/) + return hex2int(substr($0, RSTART+1, RLENGTH-1)) +} +function get_reg() { + # only use if you already know there is 1 and only 1 register + match($0, /%e(ax|bx|cx|dx|si|di|bp)/) + return substr($0, RSTART+1, RLENGTH-1) +} +function get_reg1() { + # for instructions with 2 operands, get 1st operand (assuming it is register) + match($0, /%e(ax|bx|cx|dx|si|di|bp),/) + return substr($0, RSTART+1, RLENGTH-2) +} +function get_reg2() { + # for instructions with 2 operands, get 2nd operand (assuming it is register) + match($0, /,%e(ax|bx|cx|dx|si|di|bp)/) + return substr($0, RSTART+2, RLENGTH-2) +} + +function adjust_sp_offset(delta) { + if (in_function) { + printf ".cfi_adjust_cfa_offset %d\n", delta + } +} + +{ print } + +/\.type.*,@function/ { + if (in_function) { + print ".cfi_endproc" + } + + print ".cfi_startproc" + in_function = 1 + + for (register in saved) + delete saved[register] + for (register in dirty) + delete dirty[register] +} + +# KEEPING UP WITH THE STACK POINTER +# We do NOT attempt to understand foolish and ridiculous tricks like stashing +# the stack pointer and then using %esp as a scratch register, or bitshifting +# it or taking its square root or anything stupid like that. +# %esp should only be adjusted by pushing/popping or adding/subtracting constants +# +/pushl?/ { adjust_sp_offset(4) } +/popl?/ { adjust_sp_offset(-4) } +# TODO: can add/sub instructions also specify offset in decimal? +# TODO: can offset be negative? +/addl?\s+\$[0-9a-fA-F]+,%esp/ { adjust_sp_offset(-get_const()) } +/subl?\s+\$[0-9a-fA-F]+,%esp/ { adjust_sp_offset(get_const()) } + +# TRACKING REGISTER VALUES FROM THE PREVIOUS STACK FRAME +# +/pushl?\s+%e(ax|bx|cx|dx|si|di|bp)/ { # don't match "push (%reg)" + # if a register is being pushed, and its value has not changed since the + # beginning of this function, the pushed value can be used when printing + # local variables at the next level up the stack + # emit '.cfi_rel_offset' for that + + if (in_function) { + register = get_reg() + if (!saved[register] && !dirty[register]) { + printf ".cfi_rel_offset %s,0\n", register + saved[register] = 1 + } + } +} + +# TODO: this should also understand hex offsets prefixed with 0x or -0x +/movl?\s+%e(ax|bx|cx|dx|si|di|bp),-?[0-9]*\(%esp\)/ { + if (in_function) { + register = get_reg() + if (match($0, /-?[0-9]+\(%esp\)/)) { + offset = substr($0, RSTART, RLENGTH-6) # decimal, not hex! + } else { + offset = 0 + } + if (!saved[register] && !dirty[register]) { + printf ".cfi_rel_offset %s,%d\n", register, offset + saved[register] = 1 + } + } +} + +# IF REGISTER VALUES ARE UNCEREMONIOUSLY TRASHED +# ...then we want to know about it. +# +function trashed(register) { + if (in_function && !saved[register] && !dirty[register]) { + printf ".cfi_undefined %s\n", register + } + dirty[register] = 1 +} +# this does NOT exhaustively check for all possible instructions which could +# overwrite a register value inherited from the caller (just the common ones) +# TODO: detect when ax/ah/al/etc. are trashed -- means eax is no longer usable either +/mov.*,%e(ax|bx|cx|dx|si|di|bp)/ { trashed(get_reg2()) } +/(add|addl|sub|subl|and|or|xor|lea|sal|sar|shl|shr)\s+%e(ax|bx|cx|dx|si|di|bp),/ { + trashed(get_reg1()) +} +/i?mul\s+[^,]*$/ { trashed("eax"); trashed("edx") } +/i?mul\s+%e(ax|bx|cx|dx|si|di|bp),/ { trashed(get_reg1()) } +/^(\w+:)?\s*i?div/ { trashed("eax"); trashed("edx") } +/(dec|inc|not|neg|pop)\s+%e(ax|bx|cx|dx|si|di|bp)/ { trashed(get_reg()) } +/^(\w+:)\s*cpuid/ { trashed("eax"); trashed("ebx"); trashed("ecx"); trashed("edx") } + +END { + if (in_function) { + print ".cfi_endproc" + } +} \ No newline at end of file -- 2.0.0.GIT