Merge branch 'arm32-func-after-litpool' into 'main'

ARM32: Find function starts after literal pools

Closes #518 and gtirb-pprinter#250

See merge request rewriting/ddisasm!1236

Author: jdorn-gt

CHANGELOG.md

@@ -29,6 +29,7 @@
   (`symbol_minus_symbol`) in LEA
 * Fix bug that could result in false-positive symbolic data conflicting with real strings
 * Fix bug that could result in incorrect symbol references due to incorrect GOT entries when multiple symbols share the same name
+* Fix bug that could result in missing functions for ARM32
 
 # 1.9.0
 

examples/arm_asm_examples/ex_func_after_litpool/Makefile

@@ -0,0 +1,18 @@
+AS=arm-linux-gnueabihf-as
+LD=arm-linux-gnueabihf-ld
+STRIP=arm-linux-gnueabihf-strip
+
+all: ex
+
+ex: ex_original.s
+	$(AS) -march=armv7-a -o ex.o ex_original.s
+	$(LD) -o ex ex.o
+	$(STRIP) ex
+	@qemu-arm -L /usr/arm-linux-gnueabihf ./ex > out.txt
+
+clean:
+	rm -f ex ex.o out.txt
+
+check:
+	qemu-arm -L /usr/arm-linux-gnueabihf ./ex > /tmp/res.txt
+	@ diff out.txt /tmp/res.txt && echo TEST OK

examples/arm_asm_examples/ex_func_after_litpool/ex_original.s

@@ -0,0 +1,87 @@
+#
+# This function is to check if ddisasm finds a function entry after literal
+# pools even if there is no symbol info nor direct calls to the function.
+#
+# The function `add` does not have any direct call to it.
+# After stripped, `add` has no symbol information.
+# It is placed right after the literal pool.
+#
+
+.arch armv7-a
+
+.thumb
+.text
+
+.equ SYS_EXIT, 1
+.equ SYS_WRITE, 4
+.equ STDOUT, 1
+
+@ Function: sum (calls a function via BLX r3)
+.global sum
+.type sum, %function
+.thumb_func
+sum:
+    push {lr}        @ Save link register
+    mov r3, r2       @ Store function pointer in r3
+    blx r3           @ Call function pointer
+    pop {pc}         @ Return
+
+@ Print function: writes r0 as ASCII to stdout
+.global print_result
+.type print_result, %function
+.thumb_func
+print_result:
+    push {r1-r3, lr}
+
+    @ Convert number in r0 to ASCII ('0' + value)
+    add r0, r0, #48      @ Convert to ASCII ('0' = 48)
+
+    @ Load address of result using PC-relative addressing
+    adr r3, result_ptr   @ Load address of result into r3
+    ldr r3, [r3]         @ Dereference pointer to get real address
+    strb r0, [r3, #8]    @ Store ASCII digit in result buffer
+
+    @ Write "Result: X\n" to stdout
+    mov r0, #STDOUT      @ fd = 1 (stdout)
+    adr r1, result_ptr   @ Load result address using literal pool
+    ldr r1, [r1]         @ Dereference pointer
+    mov r2, #10          @ size = 10
+    mov r7, #SYS_WRITE   @ syscall: write
+    svc #0
+
+    pop {r1-r3, pc}
+
+@ Entry Point (_start)
+.global _start
+.type _start, %function
+.thumb_func
+_start:
+    mov r0, #3       @ First argument (a)
+    mov r1, #4       @ Second argument (b)
+    adr r2, add_ptr  @ Load function pointer address
+    ldr r2, [r2]     @ Dereference pointer
+    bl sum           @ Call sum(a, b, add)
+
+    bl print_result  @ Print the result
+
+    mov r7, #SYS_EXIT  @ syscall: exit
+    mov r0, #0         @ exit code 0
+    svc #0
+
+@ Literal Pool (for PC-relative addressing)
+.ltorg
+.align 4
+result_ptr:  .word result
+add_ptr:     .word add
+
+@ Indirect call target
+.type add, %function
+.thumb_func
+add:
+    push {lr}
+    add r0, r0, r1   @ r0 = r0 + r1
+    pop {pc}
+
+.data
+result:
+    .asciz "Result: X\n"

src/datalog/basic_function_inference.dl

@@ -91,6 +91,19 @@ function_entry(EA):-
     direct_jump(Src,EA),
     code(EA).
 
+#if defined(ARCH_ARM32)
+// ARM32: Code right after literal pool
+function_entry(EA):-
+    binary_isa("ARM"),
+    refined_block(EA),
+    !function_entry_initial(EA),
+    possible_target(EA),
+    after_end(EA,PrevEA),
+    data_object(PrevEA,_,_),
+    litpool_boundaries(PrevEA,EA0),
+    EA0 = EA - (EA band 1).
+#endif
+
 function_without_callframe(EA):-
     function_entry(EA),
     !fde_addresses(EA,_).

tests/qemu-elf-arm.yaml

@@ -128,6 +128,9 @@ tests:
   - name: ex_adr_to_code
     <<: *assembly
 
+  - name: ex_func_after_litpool
+    <<: *assembly
+
   - name: ex1
     <<: *default