├── lib ├── __init__.py ├── libunlinker_common.py ├── libelf_mips32el.py ├── libunlinker.py ├── libelf.py └── libunlinker_mips32el.py ├── tests ├── reference │ ├── __init__.py │ ├── libunlinker │ │ ├── __init__.py │ │ └── mips32el │ │ │ ├── __init__.py │ │ │ ├── .gitignore │ │ │ ├── linux │ │ │ ├── __init__.py │ │ │ ├── ctype.o │ │ │ ├── asciiTable.o │ │ │ ├── helloWorld.o │ │ │ ├── asciiTable.elf │ │ │ ├── asciiTable.pyc │ │ │ ├── helloWorld.elf │ │ │ ├── helloWorld.pyc │ │ │ ├── helloWorld.c │ │ │ ├── ctype.h │ │ │ ├── asciiTable.c │ │ │ ├── linux-helpers.h │ │ │ ├── ctype.c │ │ │ ├── helloWorld.py │ │ │ └── asciiTable.py │ │ │ ├── testcases │ │ │ ├── __init__.py │ │ │ ├── __start.c │ │ │ ├── __start.o │ │ │ ├── testBss.o │ │ │ ├── testData.o │ │ │ ├── testFlow.o │ │ │ ├── testSbss.o │ │ │ ├── testSdata.o │ │ │ ├── testData.elf │ │ │ ├── testData.pyc │ │ │ ├── testFlow.elf │ │ │ ├── testFlow.pyc │ │ │ ├── testSmallData.elf │ │ │ ├── testSmallData.pyc │ │ │ ├── test-helpers.h │ │ │ ├── testFlow.c │ │ │ ├── testBss.c │ │ │ ├── testSbss.c │ │ │ ├── testData.c │ │ │ ├── testSdata.c │ │ │ └── testFlow.py │ │ │ └── Makefile │ ├── samples.gar │ └── libelf │ │ └── mips32el │ │ ├── testEmpty.o │ │ ├── testLoadSave.o │ │ ├── testMemcpy.o │ │ ├── testHelloWorld.o │ │ └── testLoadSaveNobits.o ├── output │ ├── libelf │ │ └── mips32el │ │ │ └── .gitignore │ └── libunlinker │ │ └── mips32el │ │ └── .gitignore ├── TestLibelf.py ├── TestLibunlinker.py └── MockProgram.py ├── .gitignore ├── UnlinkerSamples.py ├── README.md └── UnlinkerExportTestCase.py /lib/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/reference/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | .jython_cache 3 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/.gitignore: -------------------------------------------------------------------------------- 1 | *.log 2 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /tests/output/libelf/mips32el/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /tests/output/libunlinker/mips32el/.gitignore: -------------------------------------------------------------------------------- 1 | * 2 | !.gitignore 3 | -------------------------------------------------------------------------------- /tests/reference/samples.gar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/samples.gar -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/__start.c: -------------------------------------------------------------------------------- 1 | __attribute__((noreturn)) void __start(void) { 2 | while (1); 3 | } 4 | -------------------------------------------------------------------------------- /tests/reference/libelf/mips32el/testEmpty.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libelf/mips32el/testEmpty.o -------------------------------------------------------------------------------- /tests/reference/libelf/mips32el/testLoadSave.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libelf/mips32el/testLoadSave.o -------------------------------------------------------------------------------- /tests/reference/libelf/mips32el/testMemcpy.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libelf/mips32el/testMemcpy.o -------------------------------------------------------------------------------- /tests/reference/libelf/mips32el/testHelloWorld.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libelf/mips32el/testHelloWorld.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/ctype.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/ctype.o -------------------------------------------------------------------------------- /tests/reference/libelf/mips32el/testLoadSaveNobits.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libelf/mips32el/testLoadSaveNobits.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/asciiTable.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/asciiTable.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/helloWorld.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/helloWorld.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/__start.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/__start.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testBss.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testBss.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/asciiTable.elf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/asciiTable.elf -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/asciiTable.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/asciiTable.pyc -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/helloWorld.elf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/helloWorld.elf -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/helloWorld.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/linux/helloWorld.pyc -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testData.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testData.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testFlow.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testFlow.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testSbss.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testSbss.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testSdata.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testSdata.o -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testData.elf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testData.elf -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testData.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testData.pyc -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testFlow.elf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testFlow.elf -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testFlow.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testFlow.pyc -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testSmallData.elf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testSmallData.elf -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testSmallData.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/boricj/ghidra-unlinker-scripts/HEAD/tests/reference/libunlinker/mips32el/testcases/testSmallData.pyc -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/helloWorld.c: -------------------------------------------------------------------------------- 1 | #include "linux-helpers.h" 2 | 3 | const char S_HELLO_WORLD[] = "Hello, world!\n"; 4 | 5 | __attribute__((noreturn)) void __start(void) { 6 | write(1, S_HELLO_WORLD, sizeof(S_HELLO_WORLD) - 1); 7 | exit(0); 8 | } 9 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/ctype.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | extern int isalnum(int _c); 4 | extern int isalpha(int _c); 5 | extern int iscntrl(int _c); 6 | extern int isdigit(int _c); 7 | extern int isgraph(int _c); 8 | extern int islower(int _c); 9 | extern int isprint(int _c); 10 | extern int ispunct(int _c); 11 | extern int isspace(int _c); 12 | extern int isupper(int _c); 13 | extern int isxdigit(int _c); 14 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/test-helpers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define TESTCASE_READ(name, variable) \ 4 | int testcase_read_ ## name(int a, int b, int c, int d) { \ 5 | return variable; \ 6 | } 7 | #define TESTCASE_WRITE(name, variable, value) \ 8 | void testcase_write_ ## name(int a, int b, int c, int d) { \ 9 | variable = value; \ 10 | } 11 | #define TESTCASE_DATA(name, variable) \ 12 | int* testcase_data_ ## name(int a, int b, int c, int d) { \ 13 | return &variable; \ 14 | } 15 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/Makefile: -------------------------------------------------------------------------------- 1 | TOOLCHAIN?=mipsel-unknown-linux-gnu 2 | CFLAGS?=-Os -g -ffreestanding -fno-pic -fno-plt -mno-abicalls -mno-check-zero-division 3 | LDFLAGS?=-static -nostdlib 4 | 5 | .PHONY: all clean 6 | 7 | all: linux/asciiTable.elf linux/helloWorld.elf testcases/testData.elf testcases/testFlow.elf testcases/testSmallData.elf 8 | 9 | clean: 10 | rm -f */*.elf */*.o 11 | 12 | linux/asciiTable.elf: linux/asciiTable.o linux/ctype.o 13 | $(TOOLCHAIN)-cc -o $@ $(LDFLAGS) $^ 14 | 15 | linux/helloWorld.elf: linux/helloWorld.o 16 | $(TOOLCHAIN)-cc -o $@ $(LDFLAGS) $^ 17 | 18 | testcases/testData.elf: testcases/__start.o testcases/testBss.o testcases/testData.o 19 | $(TOOLCHAIN)-cc -o $@ $(LDFLAGS) $^ 20 | 21 | testcases/testFlow.elf: testcases/__start.o testcases/testFlow.o 22 | $(TOOLCHAIN)-cc -o $@ $(LDFLAGS) $^ 23 | 24 | testcases/testSmallData.elf: testcases/__start.o testcases/testSbss.o testcases/testSdata.o 25 | $(TOOLCHAIN)-cc -o $@ $(LDFLAGS) $^ 26 | 27 | %.o: %.c 28 | $(TOOLCHAIN)-cc -c -o $@ $(CFLAGS) $< 29 | -------------------------------------------------------------------------------- /lib/libunlinker_common.py: -------------------------------------------------------------------------------- 1 | # Ghidra reference type names 2 | COMPUTED_CALL="COMPUTED_CALL" 3 | DATA="DATA" 4 | PARAM="PARAM" 5 | READ="READ" 6 | UNCONDITIONAL_CALL="UNCONDITIONAL_CALL" 7 | UNCONDITIONAL_JUMP="UNCONDITIONAL_JUMP" 8 | WRITE="WRITE" 9 | 10 | def test_condition(expected, value, context): 11 | if isinstance(expected, tuple) or isinstance(expected, list) or isinstance(expected, set): 12 | return value in expected 13 | elif isinstance(expected, int) or isinstance(expected, long) or isinstance(expected, str): 14 | return expected == value 15 | elif callable(expected): 16 | return expected(value, context) == True 17 | elif expected is None: 18 | return True 19 | raise Exception("Unknown condition type " + str(type(expected))) 20 | 21 | class PatchRequest: 22 | def __init__(self, offset, value, length): 23 | self.offset = offset 24 | self.value = value 25 | self.length = length 26 | 27 | def __eq__(self, other): 28 | return self.offset == other.offset and self.value == other.value and self.length == other.length 29 | 30 | def __hash__(self): 31 | return hash((self.offset, self.value, self.length)) 32 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testFlow.c: -------------------------------------------------------------------------------- 1 | #include "test-helpers.h" 2 | 3 | void testcase_flow_target() { 4 | } 5 | 6 | void testcase_flow_call() { 7 | asm volatile ( 8 | "jal testcase_flow_target" 9 | : 10 | : 11 | : 12 | ); 13 | } 14 | 15 | void testcase_flow_call_indirect() { 16 | register void(*v0)(void) asm("v0") = testcase_flow_target; 17 | 18 | asm volatile ( 19 | "jalr %0" 20 | : 21 | : "r"(v0) 22 | : 23 | ); 24 | } 25 | 26 | __attribute__((noreturn)) void testcase_flow_jump() { 27 | asm volatile ( 28 | "j testcase_flow_target" 29 | : 30 | : 31 | : 32 | ); 33 | __builtin_unreachable(); 34 | } 35 | 36 | void testcase_flow_jump_local(int i) { 37 | asm volatile ( 38 | "beq %0, %0, .L998;" 39 | "addu $a0, $a0, $a0;" 40 | "j .L999;" 41 | ".L998:;" 42 | "addu $a2, $a2, $a2;" 43 | ".L999:;" 44 | "addu $a1, $a1, $a1;" 45 | : 46 | : "r"(i) 47 | : 48 | ); 49 | } 50 | 51 | __attribute__((noreturn)) void testcase_flow_jump_indirect() { 52 | register void(*v0)(void) asm("v0") = testcase_flow_target; 53 | 54 | asm volatile ( 55 | "jr %0" 56 | : 57 | : "r"(v0) 58 | : 59 | ); 60 | __builtin_unreachable(); 61 | } 62 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/asciiTable.c: -------------------------------------------------------------------------------- 1 | #include "linux-helpers.h" 2 | #include "ctype.h" 3 | 4 | void print_number(int num) { 5 | putch('0'); 6 | 7 | for (int n = 2; n >= 0; n--) { 8 | int digit = (num >> (3 * n)) % 010; 9 | putch('0' + digit); 10 | } 11 | } 12 | 13 | typedef struct { 14 | int (*func)(int); 15 | char flag; 16 | } ascii_property; 17 | 18 | #define NUM_ASCII_PROPERTIES 11 19 | 20 | const ascii_property s_ascii_properties[11] = { 21 | { isgraph, 'g', }, 22 | { isprint, 'p', }, 23 | { iscntrl, 'c', }, 24 | { isspace, 's', }, 25 | { ispunct, '!', }, 26 | { isalnum, 'A', }, 27 | { isalpha, 'a', }, 28 | { isdigit, 'd', }, 29 | { isxdigit, 'x', }, 30 | { isupper, 'U', }, 31 | { islower, 'l', }, 32 | }; 33 | 34 | __attribute__((noreturn)) void __start(void) { 35 | for (int i = 0; i < 128; i++) { 36 | print_number(i); 37 | putch(' '); 38 | 39 | if (isgraph(i)) 40 | putch(i); 41 | else 42 | putch(' '); 43 | putch(' '); 44 | 45 | for (int j = 0; j < NUM_ASCII_PROPERTIES; j++) { 46 | const ascii_property *property = &s_ascii_properties[j]; 47 | 48 | if (property->func(i)) 49 | putch(property->flag); 50 | else 51 | putch(' '); 52 | } 53 | 54 | putch('\n'); 55 | } 56 | 57 | exit(0); 58 | } 59 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testBss.c: -------------------------------------------------------------------------------- 1 | #include "test-helpers.h" 2 | 3 | __attribute__((section(".bss"))) int bss_int; 4 | __attribute__((section(".bss"))) int bss_int_array[4]; 5 | 6 | TESTCASE_READ(bss_int, bss_int) 7 | TESTCASE_READ(bss_int_array_0, bss_int_array[0]) 8 | TESTCASE_READ(bss_int_array_1, bss_int_array[1]) 9 | TESTCASE_READ(bss_int_array_2, bss_int_array[2]) 10 | TESTCASE_READ(bss_int_array_3, bss_int_array[3]) 11 | TESTCASE_READ(bss_int_array_a, bss_int_array[a]) 12 | TESTCASE_READ(bss_int_array_a_1, bss_int_array[a+1]) 13 | TESTCASE_READ(bss_int_array_a_b, bss_int_array[a+b]) 14 | TESTCASE_READ(bss_int_array_a_b_1, bss_int_array[a+b+1]) 15 | 16 | TESTCASE_DATA(bss_int, bss_int) 17 | TESTCASE_DATA(bss_int_array_0, bss_int_array[0]) 18 | TESTCASE_DATA(bss_int_array_1, bss_int_array[1]) 19 | TESTCASE_DATA(bss_int_array_2, bss_int_array[2]) 20 | TESTCASE_DATA(bss_int_array_3, bss_int_array[3]) 21 | TESTCASE_DATA(bss_int_array_a, bss_int_array[a]) 22 | TESTCASE_DATA(bss_int_array_a_1, bss_int_array[a+1]) 23 | TESTCASE_DATA(bss_int_array_a_b, bss_int_array[a+b]) 24 | TESTCASE_DATA(bss_int_array_a_b_1, bss_int_array[a+b+1]) 25 | 26 | TESTCASE_WRITE(bss_int_val_0, bss_int, 0) 27 | TESTCASE_WRITE(bss_int_array_0_val_0, bss_int_array[0], 0) 28 | TESTCASE_WRITE(bss_int_array_1_val_0, bss_int_array[1], 0) 29 | TESTCASE_WRITE(bss_int_array_2_val_0, bss_int_array[2], 0) 30 | TESTCASE_WRITE(bss_int_array_3_val_0, bss_int_array[3], 0) 31 | TESTCASE_WRITE(bss_int_array_3_val_a, bss_int_array[a], 0) 32 | TESTCASE_WRITE(bss_int_array_a_1_val_0, bss_int_array[a+1], 0) 33 | TESTCASE_WRITE(bss_int_array_a_b_val_0, bss_int_array[a+b], 0) 34 | TESTCASE_WRITE(bss_int_array_a_b_1_val_0, bss_int_array[a+b+1], 0) 35 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testSbss.c: -------------------------------------------------------------------------------- 1 | #include "test-helpers.h" 2 | 3 | __attribute__((section(".sbss"))) int sbss_int; 4 | __attribute__((section(".sbss"))) int sbss_int_array[4]; 5 | 6 | TESTCASE_READ(sbss_int, sbss_int) 7 | TESTCASE_READ(sbss_int_array_0, sbss_int_array[0]) 8 | TESTCASE_READ(sbss_int_array_1, sbss_int_array[1]) 9 | TESTCASE_READ(sbss_int_array_2, sbss_int_array[2]) 10 | TESTCASE_READ(sbss_int_array_3, sbss_int_array[3]) 11 | TESTCASE_READ(sbss_int_array_a, sbss_int_array[a]) 12 | TESTCASE_READ(sbss_int_array_a_1, sbss_int_array[a+1]) 13 | TESTCASE_READ(sbss_int_array_a_b, sbss_int_array[a+b]) 14 | TESTCASE_READ(sbss_int_array_a_b_1, sbss_int_array[a+b+1]) 15 | 16 | TESTCASE_DATA(sbss_int, sbss_int) 17 | TESTCASE_DATA(sbss_int_array_0, sbss_int_array[0]) 18 | TESTCASE_DATA(sbss_int_array_1, sbss_int_array[1]) 19 | TESTCASE_DATA(sbss_int_array_2, sbss_int_array[2]) 20 | TESTCASE_DATA(sbss_int_array_3, sbss_int_array[3]) 21 | TESTCASE_DATA(sbss_int_array_a, sbss_int_array[a]) 22 | TESTCASE_DATA(sbss_int_array_a_1, sbss_int_array[a+1]) 23 | TESTCASE_DATA(sbss_int_array_a_b, sbss_int_array[a+b]) 24 | TESTCASE_DATA(sbss_int_array_a_b_1, sbss_int_array[a+b+1]) 25 | 26 | TESTCASE_WRITE(sbss_int_val_0, sbss_int, 0) 27 | TESTCASE_WRITE(sbss_int_array_0_val_0, sbss_int_array[0], 0) 28 | TESTCASE_WRITE(sbss_int_array_1_val_0, sbss_int_array[1], 0) 29 | TESTCASE_WRITE(sbss_int_array_2_val_0, sbss_int_array[2], 0) 30 | TESTCASE_WRITE(sbss_int_array_3_val_0, sbss_int_array[3], 0) 31 | TESTCASE_WRITE(sbss_int_array_a_val_0, sbss_int_array[a], 0) 32 | TESTCASE_WRITE(sbss_int_array_a_1_val_0, sbss_int_array[a+1], 0) 33 | TESTCASE_WRITE(sbss_int_array_a_b_val_0, sbss_int_array[a+b], 0) 34 | TESTCASE_WRITE(sbss_int_array_a_b_1_val_0, sbss_int_array[a+b+1], 0) 35 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testData.c: -------------------------------------------------------------------------------- 1 | #include "test-helpers.h" 2 | 3 | __attribute__((section(".data"))) int data_int = 1; 4 | __attribute__((section(".data"))) int data_int_array[4] = { 2, 3, 4, 5 }; 5 | 6 | TESTCASE_READ(data_int, data_int) 7 | TESTCASE_READ(data_int_array_0, data_int_array[0]) 8 | TESTCASE_READ(data_int_array_1, data_int_array[1]) 9 | TESTCASE_READ(data_int_array_2, data_int_array[2]) 10 | TESTCASE_READ(data_int_array_3, data_int_array[3]) 11 | TESTCASE_READ(data_int_array_a, data_int_array[a]) 12 | TESTCASE_READ(data_int_array_a_1, data_int_array[a+1]) 13 | TESTCASE_READ(data_int_array_a_b, data_int_array[a+b]) 14 | TESTCASE_READ(data_int_array_a_b_1, data_int_array[a+b+1]) 15 | 16 | TESTCASE_DATA(data_int, data_int) 17 | TESTCASE_DATA(data_int_array_0, data_int_array[0]) 18 | TESTCASE_DATA(data_int_array_1, data_int_array[1]) 19 | TESTCASE_DATA(data_int_array_2, data_int_array[2]) 20 | TESTCASE_DATA(data_int_array_3, data_int_array[3]) 21 | TESTCASE_DATA(data_int_array_a, data_int_array[a]) 22 | TESTCASE_DATA(data_int_array_a_1, data_int_array[a+1]) 23 | TESTCASE_DATA(data_int_array_a_b, data_int_array[a+b]) 24 | TESTCASE_DATA(data_int_array_a_b_1, data_int_array[a+b+1]) 25 | 26 | TESTCASE_WRITE(data_int_val_0, data_int, 0) 27 | TESTCASE_WRITE(data_int_array_0_val_0, data_int_array[0], 0) 28 | TESTCASE_WRITE(data_int_array_1_val_0, data_int_array[1], 0) 29 | TESTCASE_WRITE(data_int_array_2_val_0, data_int_array[2], 0) 30 | TESTCASE_WRITE(data_int_array_3_val_0, data_int_array[3], 0) 31 | TESTCASE_WRITE(data_int_array_a_val_0, data_int_array[a], 0) 32 | TESTCASE_WRITE(data_int_array_a_1_val_0, data_int_array[a+1], 0) 33 | TESTCASE_WRITE(data_int_array_a_b_val_0, data_int_array[a+b], 0) 34 | TESTCASE_WRITE(data_int_array_a_b_1_val_0, data_int_array[a+b+1], 0) 35 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testSdata.c: -------------------------------------------------------------------------------- 1 | #include "test-helpers.h" 2 | 3 | __attribute__((section(".sdata"))) int sdata_int = 1; 4 | __attribute__((section(".sdata"))) int sdata_int_array[4] = { 2, 3, 4, 5 }; 5 | 6 | TESTCASE_READ(sdata_int, sdata_int) 7 | TESTCASE_READ(sdata_int_array_0, sdata_int_array[0]) 8 | TESTCASE_READ(sdata_int_array_1, sdata_int_array[1]) 9 | TESTCASE_READ(sdata_int_array_2, sdata_int_array[2]) 10 | TESTCASE_READ(sdata_int_array_3, sdata_int_array[3]) 11 | TESTCASE_READ(sdata_int_array_a, sdata_int_array[a]) 12 | TESTCASE_READ(sdata_int_array_a_1, sdata_int_array[a+1]) 13 | TESTCASE_READ(sdata_int_array_a_b, sdata_int_array[a+b]) 14 | TESTCASE_READ(sdata_int_array_a_b_1, sdata_int_array[a+b+1]) 15 | 16 | TESTCASE_DATA(sdata_int, sdata_int) 17 | TESTCASE_DATA(sdata_int_array_0, sdata_int_array[0]) 18 | TESTCASE_DATA(sdata_int_array_1, sdata_int_array[1]) 19 | TESTCASE_DATA(sdata_int_array_2, sdata_int_array[2]) 20 | TESTCASE_DATA(sdata_int_array_3, sdata_int_array[3]) 21 | TESTCASE_DATA(sdata_int_array_a, sdata_int_array[a]) 22 | TESTCASE_DATA(sdata_int_array_a_1, sdata_int_array[a+1]) 23 | TESTCASE_DATA(sdata_int_array_a_b, sdata_int_array[a+b]) 24 | TESTCASE_DATA(sdata_int_array_a_b_1, sdata_int_array[a+b+1]) 25 | 26 | TESTCASE_WRITE(sdata_int_val_0, sdata_int, 0) 27 | TESTCASE_WRITE(sdata_int_array_0_val_0, sdata_int_array[0], 0) 28 | TESTCASE_WRITE(sdata_int_array_1_val_0, sdata_int_array[1], 0) 29 | TESTCASE_WRITE(sdata_int_array_2_val_0, sdata_int_array[2], 0) 30 | TESTCASE_WRITE(sdata_int_array_3_val_0, sdata_int_array[3], 0) 31 | TESTCASE_WRITE(sdata_int_array_a_val_0, sdata_int_array[a], 0) 32 | TESTCASE_WRITE(sdata_int_array_a_1_val_0, sdata_int_array[a+1], 0) 33 | TESTCASE_WRITE(sdata_int_array_a_b_val_0, sdata_int_array[a+b], 0) 34 | TESTCASE_WRITE(sdata_int_array_a_b_1_val_0, sdata_int_array[a+b+1], 0) 35 | -------------------------------------------------------------------------------- /UnlinkerSamples.py: -------------------------------------------------------------------------------- 1 | # Unlinker script invocations for bundled samples 2 | #@author Jean-Baptiste Boric 3 | #@category Unlinker 4 | #@keybinding 5 | #@menupath 6 | #@toolbar 7 | 8 | import logging, os 9 | from lib.libunlinker import * 10 | 11 | # tests/reference/libunlinker/mips32el/linux/helloWorld.elf 12 | if currentProgram.executableSHA256 == u'2b972ed9f9071d1c511f13bc841119202f354d5ffc08fe398bc441d5ba25fa7f': 13 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 14 | sym_address_end = currentProgram.getAddressFactory().getAddress("0040010f") 15 | object_files = ( 16 | ("helloWorld", ( 17 | ("004000d0", "004000ff", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 18 | ("00400100", "0040010f", ".rodata", SHT_PROGBITS, SHF_ALLOC), 19 | )), 20 | ) 21 | # tests/reference/libunlinker/mips32el/linux/asciiTable.elf 22 | elif currentProgram.executableSHA256 == u'e4ceb90bd6433a9d9059f9e00be730fd93fb78ebc4506c484069a385d4e98d00': 23 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 24 | sym_address_end = currentProgram.getAddressFactory().getAddress("004005ff") 25 | object_files = ( 26 | ("asciiTable", ( 27 | ("004000d0", "0040027f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 28 | ("00400490", "004004ef", ".rodata", SHT_PROGBITS, SHF_ALLOC), 29 | )), 30 | ("ctype", ( 31 | ("00400280", "0040048f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 32 | ("004004f0", "004005ff", ".rodata", SHT_PROGBITS, SHF_ALLOC), 33 | )), 34 | ) 35 | else: 36 | raise Exception("Unknown SHA256 hash {} of program {}".format(currentProgram.executableSHA256, currentProgram.getName())) 37 | 38 | output_dir = askDirectory("Export relocatable objects to", "Save").getPath() 39 | 40 | sym_address_set = currentProgram.getAddressFactory().getAddressSet(sym_address_start, sym_address_end) 41 | unlink_program(currentProgram, output_dir, object_files, sym_address_set) 42 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/linux-helpers.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | static const int __NR_Linux = 4000; 4 | static const int __NR_syscall = (__NR_Linux + 0); 5 | static const int __NR_exit = (__NR_Linux + 1); 6 | static const int __NR_write = (__NR_Linux + 4); 7 | 8 | #define __SYSCALL_CLOBBERS "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", \ 9 | "$14", "$15", "$24", "$25", "hi", "lo", "memory" 10 | 11 | #define write(fd, buf, len) do { \ 12 | register int v0 asm("v0") = __NR_write; \ 13 | register int a0 asm("a0") = fd; \ 14 | register const void* a1 asm("a1") = buf; \ 15 | register int a2 asm("a2") = len; \ 16 | \ 17 | asm volatile ( \ 18 | "syscall" \ 19 | : "+r"(v0), "+r"(a0), "+r"(a1), "+r"(a2) \ 20 | : \ 21 | : "$7", __SYSCALL_CLOBBERS \ 22 | ); \ 23 | } while (0) 24 | 25 | #define exit(status) do { \ 26 | register int v0 asm("v0") = __NR_exit; \ 27 | register int a0 asm("a0") = status; \ 28 | \ 29 | asm volatile ( \ 30 | "syscall" \ 31 | : "+r"(v0), "+r"(a0) \ 32 | : \ 33 | : "$5", "$6", "$7",__SYSCALL_CLOBBERS \ 34 | ); \ 35 | \ 36 | __builtin_unreachable(); \ 37 | } while (0) 38 | 39 | #define putch(ch) do { \ 40 | const char _putch_data = ch; \ 41 | write(1, &_putch_data, 1); \ 42 | } while (0) 43 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | **⚠ This repository is obsoleted by https://github.com/boricj/ghidra-unlinker-extension** 2 | 3 | # Unlinker scripts for Ghidra 4 | 5 | This set of Ghidra scripts allows one to unlink programs analyzed with Ghidra back into relocatable ELF object files. 6 | 7 | Possible applications include: 8 | * Relinking the generated relocatable object files to recreate a working ELF program with the same behavior as the original one, even if the original program isn't an ELF program. 9 | * Use both original and replacement relocatable object files to modify a program, by substituting functions or data at the symbol level. 10 | * Decompile a program back by writing reimplementations of the generated object files, one at a time, while relinking to ensure the program has no changes in behavior with the rewritten source code. 11 | 12 | ## Running 13 | 14 | * Analyze a program with Ghidra. 15 | * Prepare an invocation script using `UnlinkerSamples.py` as a reference. 16 | * Invoke the script on a open program. 17 | 18 | The sample script outputs a set of object files in a directory. Each generated object file also has a companion log file for troubleshooting unlinking issues/failures. 19 | 20 | ## Examples 21 | 22 | A Ghidra archived project for all samples is provided at `tests/reference/samples.gar`. 23 | 24 | ### MIPS32 little-endian Linux programs 25 | 26 | The programs at `tests/reference/libunlinker/mips32el/linux` used as part of the test suite demonstrates the usage of the unlinker. The sample programs themselves can be executed with a QEMU userspace emulator on non-MIPS environments. 27 | 28 | ## Testing 29 | 30 | To run tests, execute the following command: 31 | 32 | ``` 33 | jython -m unittest discover tests/ 'Test*.py' 34 | ``` 35 | 36 | The test suite does not require Ghidra to execute, but it requires a Jython interpreter. 37 | A standalone Jython interpreter can be found inside `Ghidra/Features/Python/lib/` in a Ghidra installation, it can be invoked with: 38 | * Bash: `java -jar "${GHIDRA_HOME}/Ghidra/Features/Python/lib/jython-standalone-2.7.2.jar"` 39 | * PowerShell: `java -jar "${env:GHIDRA_HOME}/Ghidra/Features/Python/lib/jython-standalone-2.7.2.jar"` 40 | 41 | ## Limitations 42 | 43 | * Only supports little-endian, 32-bit MIPS programs. 44 | * Requires a lot of improvements for real-world programs. 45 | -------------------------------------------------------------------------------- /lib/libelf_mips32el.py: -------------------------------------------------------------------------------- 1 | from libelf import * 2 | 3 | MIPS32_OPCODE_MASK = 0b111111 4 | MIPS32_OPCODE_OFFSET = 26 5 | 6 | MIPS32_SREG_MASK = 0b11111 7 | MIPS32_SREG_OFFSET = 21 8 | 9 | MIPS32_TREG_MASK = 0b11111 10 | MIPS32_TREG_OFFSET = 16 11 | 12 | MIPS32_DREG_MASK = 0b11111 13 | MIPS32_DREG_OFFSET = 11 14 | 15 | MIPS32_FUNC_MASK = 0b111111 16 | MIPS32_ITYPE_IMM_MASK = 0xffff 17 | MIPS32_REG_GP = 28 18 | MIPS32_REGS_NOT_GP = set(range(1, 32)) - set((MIPS32_REG_GP,)) 19 | 20 | MIPS32_OPCODE_REG = 0b000000 21 | MIPS32_OPCODE_BGEZ_BLTZ = 0b000001 22 | MIPS32_OPCODE_J = 0b000010 23 | MIPS32_OPCODE_JAL = 0b000011 24 | MIPS32_OPCODE_JR = 0b001000 25 | MIPS32_OPCODE_JALR = 0b001001 26 | 27 | MIPS32_OPCODE_BEQ = 0b000100 28 | MIPS32_OPCODE_BNE = 0b000101 29 | MIPS32_OPCODE_BLEZ = 0b000110 30 | MIPS32_OPCODE_BGTZ = 0b000111 31 | 32 | MIPS32_OPCODE_ADDIU = 0b001001 33 | MIPS32_OPCODE_ORI = 0b001101 34 | MIPS32_OPCODE_LUI = 0b001111 35 | MIPS32_OPCODE_LB = 0b100000 36 | MIPS32_OPCODE_LH = 0b100001 37 | MIPS32_OPCODE_LW = 0b100011 38 | MIPS32_OPCODE_LBU = 0b100100 39 | MIPS32_OPCODE_LHU = 0b100101 40 | MIPS32_OPCODE_SB = 0b101000 41 | MIPS32_OPCODE_SH = 0b101001 42 | MIPS32_OPCODE_SW = 0b101011 43 | 44 | MIPS32_OPCODES_LOADSTORE = (MIPS32_OPCODE_LB, MIPS32_OPCODE_LH, MIPS32_OPCODE_LW, MIPS32_OPCODE_LBU, MIPS32_OPCODE_LHU, MIPS32_OPCODE_SB, MIPS32_OPCODE_SH, MIPS32_OPCODE_SW) 45 | MIPS32_OPCODES_ITYPES = MIPS32_OPCODES_LOADSTORE + (MIPS32_OPCODE_ADDIU,) 46 | MIPS32_OPCODES_RELATIVE_JUMPS = (MIPS32_OPCODE_BGEZ_BLTZ, MIPS32_OPCODE_BEQ, MIPS32_OPCODE_BNE, MIPS32_OPCODE_BLEZ, MIPS32_OPCODE_BGTZ) 47 | 48 | MIPS32_FUNC_ADD = 0b100000 49 | MIPS32_FUNC_ADDU = 0b100001 50 | 51 | def _get_sreg_from_itype(self, instruction): 52 | return (instruction & self.MIPS32_SREG_MASK) >> 21 53 | 54 | def _get_treg_from_itype(self, instruction): 55 | return (instruction & self.MIPS32_TREG_MASK) >> 16 56 | 57 | def _get_imm_from_jtype(self, instruction): 58 | return (instruction & ~self.MIPS32_OPCODE_MASK) << 2 59 | 60 | def _get_sreg_from_rtype(self, instruction): 61 | return (instruction & self.MIPS32_SREG_MASK) >> 21 62 | 63 | def _get_treg_from_rtype(self, instruction): 64 | return (instruction & self.MIPS32_TREG_MASK) >> 16 65 | 66 | def _get_dreg_from_rtype(self, instruction): 67 | return (instruction & self.MIPS32_DREG_MASK) >> 11 68 | -------------------------------------------------------------------------------- /tests/TestLibelf.py: -------------------------------------------------------------------------------- 1 | #TODO Testing of libelf 2 | #@author Jean-Baptiste Boric 3 | #@category Test 4 | #@keybinding 5 | #@menupath 6 | #@toolbar 7 | 8 | import io, sys, unittest 9 | sys.path.insert(1, "lib") 10 | 11 | from libelf import * 12 | 13 | def generateTestEmptyMips32ElRel(): 14 | return ElfFile(ELFCLASS32, ELFDATA2LSB, ELF_ET_REL, ELF_EM_MIPS, e_flags=0x1000) 15 | 16 | def generateTestMemcpyMips32ElRel(): 17 | elf = ElfFile(ELFCLASS32, ELFDATA2LSB, ELF_ET_REL, ELF_EM_MIPS, e_flags=0x1000) 18 | text_section = ElfSection(".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR, data=b"\x06\x00\xc0\x18\x21\x30\x86\x00\x01\x00\xa5\x24\x01\x00\x84\x24\xff\xff\xa2\x80\xfc\xff\xc4\x14\xff\xff\x82\xa0\x08\x00\xe0\x03\x00\x00\x00\x00") 19 | reginfo_section = ElfSection(".reginfo", SHT_MIPS_REGINFO, sh_link=".text", data=b"\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1C") 20 | 21 | elf.append(text_section) 22 | elf.append(reginfo_section) 23 | 24 | symbols = list(( 25 | ElfSymbol("my_memcpy", 0, 48, STT_FUNC|STB_GLOBAL, 0, ".text"), 26 | )) 27 | elf.synthesize_symbols(symbols) 28 | 29 | return elf 30 | 31 | def generateTestHelloWorldMips32ElRel(): 32 | elf = ElfFile(ELFCLASS32, ELFDATA2LSB, ELF_ET_REL, ELF_EM_MIPS, e_flags=0x1000) 33 | text_section = ElfSection(".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR, data=b"\xd8\xff\xbd\x27\x00\x00\x05\x3c\x10\x00\xa4\x27\x0f\x00\x06\x24\x24\x00\xbf\xaf\x00\x00\x00\x0c\x00\x00\xa5\x24\xa4\x0f\x02\x24\x01\x00\x04\x24\x10\x00\xa5\x27\x0e\x00\x06\x24\x0c\x00\x00\x00\xa1\x0f\x02\x24\x25\x20\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00") 34 | rodata_section = ElfSection(".rodata", SHT_PROGBITS, SHF_ALLOC, data=b"Hello, world!\n\0") 35 | reginfo_section = ElfSection(".reginfo", SHT_MIPS_REGINFO, sh_link=".text", data=b"\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1C") 36 | 37 | elf.append(text_section) 38 | elf.append(rodata_section) 39 | elf.append(reginfo_section) 40 | 41 | symbols = list(( 42 | ElfSymbol("__start", 0, 96, STT_FUNC|STB_GLOBAL, 0, ".text"), 43 | ElfSymbol("$LC0", 0, 16, STT_NOTYPE|STB_GLOBAL, 0, ".rodata"), 44 | ElfSymbol("my_memcpy", 0, 0, STT_FUNC|STB_GLOBAL, 0, ""), 45 | )) 46 | elf.synthesize_symbols(symbols) 47 | 48 | relocations = list(( 49 | ElfRel(0x4, "$LC0", R_MIPS_HI16), 50 | ElfRel(0x14, "my_memcpy", R_MIPS_26), 51 | ElfRel(0x18, "$LC0", R_MIPS_LO16), 52 | )) 53 | elf.synthesize_relocations(relocations) 54 | 55 | return elf 56 | 57 | class TestElfFile(unittest.TestCase): 58 | def _compare(self, elf, reference): 59 | with open("tests/output/libelf/" + reference, "wb") as fp: 60 | elf.write(fp) 61 | with io.BytesIO() as mp: 62 | elf.write(mp) 63 | with open("tests/reference/libelf/" + reference, "rb") as fp: 64 | self.assertEquals(mp.getvalue(), fp.read()) 65 | 66 | def testEmptyMips32ElRel(self): 67 | elf = generateTestEmptyMips32ElRel() 68 | self._compare(elf, "mips32el/testEmpty.o") 69 | 70 | def testMemcpyMips32ElRel(self): 71 | elf = generateTestMemcpyMips32ElRel() 72 | self._compare(elf, "mips32el/testMemcpy.o") 73 | 74 | def testHelloWorldMips32ElRel(self): 75 | elf = generateTestHelloWorldMips32ElRel() 76 | self._compare(elf, "mips32el/testHelloWorld.o") 77 | 78 | def testLoadSave(self): 79 | with open("tests/reference/libelf/mips32el/testLoadSave.o", "rb") as fp: 80 | elf = loadElfFromFile(fp) 81 | 82 | self._compare(elf, "mips32el/testLoadSave.o") 83 | 84 | def testLoadSaveNobitsMips32ElRel(self): 85 | with open("tests/reference/libelf/mips32el/testLoadSaveNoBits.o", "rb") as fp: 86 | elf = loadElfFromFile(fp) 87 | 88 | self._compare(elf, "mips32el/testLoadSaveNoBits.o") 89 | 90 | if __name__ == '__main__': 91 | unittest.main() 92 | -------------------------------------------------------------------------------- /UnlinkerExportTestCase.py: -------------------------------------------------------------------------------- 1 | # Export the current program as a test case for the unlinker 2 | #@author Jean-Baptiste Boric 3 | #@category Unlinker 4 | #@keybinding 5 | #@menupath 6 | #@toolbar 7 | 8 | import jarray 9 | 10 | output_file = askFile("Export unlinker test case", "Save").getPath() 11 | 12 | program_name = currentProgram.getName() 13 | data = currentProgram.getListing().getDefinedData(True) 14 | functions = currentProgram.getFunctionManager().getFunctions(True) 15 | memory_blocks = currentProgram.getMemory().getBlocks() 16 | symbols = currentProgram.getSymbolTable().getAllSymbols(True) 17 | 18 | def toaddr(addr): 19 | return hex(int(addr.getOffset())) 20 | 21 | with open(output_file, "w") as fp: 22 | fp.write("# Generated from {}\n".format(program_name)) 23 | fp.write("from MockProgram import *\n") 24 | 25 | fp.write("# Data\ndata = (\n") 26 | for datum in data: 27 | fp.write(" MockData(min_addr=MockAddress({}), max_addr=MockAddress({})),\n".format(toaddr(datum.getMinAddress()), toaddr(datum.getMaxAddress()))) 28 | fp.write(")\n") 29 | 30 | fp.write("# Functions\nfunctions = (\n") 31 | for function in functions: 32 | fp.write(" MockFunction(name='{}', body=MockAddressSet(MockAddress({}), MockAddress({}))),\n".format(function.getName(), toaddr(function.getBody().getMinAddress()), toaddr(function.getBody().getMaxAddress()))) 33 | fp.write(")\n") 34 | 35 | fp.write("# Memory blocks\nmemory_blocks = (\n") 36 | for memory_block in memory_blocks: 37 | if memory_block.isLoaded(): 38 | if memory_block.isInitialized(): 39 | fp.write(" MockMemoryBlock(name='{}', address_range=MockAddressSet(MockAddress({}), MockAddress({})).getFirstRange(), data=(".format(memory_block.getName(), toaddr(memory_block.getStart()), toaddr(memory_block.getEnd()))) 40 | data = jarray.zeros(memory_block.getSize(), "b") 41 | memory_block.getBytes(memory_block.getStart(), data) 42 | fp.write(','.join((str(i) for i in data))) 43 | fp.write(")),\n") 44 | else: 45 | fp.write(" MockMemoryBlock(name='{}', address_range=MockAddressSet(MockAddress({}), MockAddress({})).getFirstRange(), data=None),\n".format(memory_block.getName(), toaddr(memory_block.getStart()), toaddr(memory_block.getEnd()))) 46 | fp.write(")\n") 47 | 48 | fp.write("# Symbols\nsymbols = (\n") 49 | for symbol in symbols: 50 | fp.write(" MockSymbol(name='{}', address=MockAddress({}), isGlobal={}, references=(\n".format(symbol.getName(), toaddr(symbol.getAddress()), str(symbol.isGlobal()))) 51 | for reference in symbol.getReferences(): 52 | fp.write(" MockReference(from_address=MockAddress({}), to_address=MockAddress({}), isPrimary={}, operand_index={},\n".format(toaddr(reference.getFromAddress()), toaddr(reference.getToAddress()), str(reference.isPrimary()), reference.getOperandIndex())) 53 | reftype = reference.getReferenceType() 54 | fp.write(" reftype=MockRefType('{}', isCall={}, isComputed={}, isConditional={}, isData={}, isFallthrough={}, isFlow={}, isIndirect={}, isJump={}, isOverride={}, isRead={}, isTerminal={}, isUnConditional={}, isWrite={})),\n".format( 55 | reftype.getName(), 56 | str(reftype.isCall()), 57 | str(reftype.isComputed()), 58 | str(reftype.isConditional()), 59 | str(reftype.isData()), 60 | str(reftype.isFallthrough()), 61 | str(reftype.isFlow()), 62 | str(reftype.isIndirect()), 63 | str(reftype.isJump()), 64 | str(reftype.isOverride()), 65 | str(reftype.isRead()), 66 | str(reftype.isTerminal()), 67 | str(reftype.isUnConditional()), 68 | str(reftype.isWrite()) 69 | )) 70 | fp.write(" )),\n") 71 | fp.write(")\n") 72 | 73 | fp.write("currentProgram = MockProgram(data=data, functions=functions, memory_blocks=memory_blocks, symbols=symbols)\n") 74 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/ctype.c: -------------------------------------------------------------------------------- 1 | /* $OpenBSD: ctype_.c,v 1.12 2015/09/19 04:02:21 guenther Exp $ */ 2 | /* $OpenBSD: ctype.h,v 1.25 2017/09/05 03:16:13 schwarze Exp $ */ 3 | /* $NetBSD: ctype.h,v 1.14 1994/10/26 00:55:47 cgd Exp $ */ 4 | /* 5 | * Copyright (c) 1989 The Regents of the University of California. 6 | * All rights reserved. 7 | * (c) UNIX System Laboratories, Inc. 8 | * All or some portions of this file are derived from material licensed 9 | * to the University of California by American Telephone and Telegraph 10 | * Co. or Unix System Laboratories, Inc. and are reproduced herein with 11 | * the permission of UNIX System Laboratories, Inc. 12 | * 13 | * Redistribution and use in source and binary forms, with or without 14 | * modification, are permitted provided that the following conditions 15 | * are met: 16 | * 1. Redistributions of source code must retain the above copyright 17 | * notice, this list of conditions and the following disclaimer. 18 | * 2. Redistributions in binary form must reproduce the above copyright 19 | * notice, this list of conditions and the following disclaimer in the 20 | * documentation and/or other materials provided with the distribution. 21 | * 3. Neither the name of the University nor the names of its contributors 22 | * may be used to endorse or promote products derived from this software 23 | * without specific prior written permission. 24 | * 25 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 26 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 29 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 30 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 31 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 32 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 33 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 34 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 35 | * SUCH DAMAGE. 36 | * 37 | * @(#)ctype.h 5.3 (Berkeley) 4/3/91 38 | */ 39 | 40 | #define _U 0x01 41 | #define _L 0x02 42 | #define _N 0x04 43 | #define _S 0x08 44 | #define _P 0x10 45 | #define _C 0x20 46 | #define _X 0x40 47 | #define _B 0x80 48 | 49 | const char _ctype_[1 + 256] = { 50 | 0, 51 | _C, _C, _C, _C, _C, _C, _C, _C, 52 | _C, _C|_S, _C|_S, _C|_S, _C|_S, _C|_S, _C, _C, 53 | _C, _C, _C, _C, _C, _C, _C, _C, 54 | _C, _C, _C, _C, _C, _C, _C, _C, 55 | _S|(char)_B, _P, _P, _P, _P, _P, _P, _P, 56 | _P, _P, _P, _P, _P, _P, _P, _P, 57 | _N, _N, _N, _N, _N, _N, _N, _N, 58 | _N, _N, _P, _P, _P, _P, _P, _P, 59 | _P, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U|_X, _U, 60 | _U, _U, _U, _U, _U, _U, _U, _U, 61 | _U, _U, _U, _U, _U, _U, _U, _U, 62 | _U, _U, _U, _P, _P, _P, _P, _P, 63 | _P, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L|_X, _L, 64 | _L, _L, _L, _L, _L, _L, _L, _L, 65 | _L, _L, _L, _L, _L, _L, _L, _L, 66 | _L, _L, _L, _P, _P, _P, _P, _C, 67 | 68 | 0, 0, 0, 0, 0, 0, 0, 0, /* 80 */ 69 | 0, 0, 0, 0, 0, 0, 0, 0, /* 88 */ 70 | 0, 0, 0, 0, 0, 0, 0, 0, /* 90 */ 71 | 0, 0, 0, 0, 0, 0, 0, 0, /* 98 */ 72 | 0, 0, 0, 0, 0, 0, 0, 0, /* A0 */ 73 | 0, 0, 0, 0, 0, 0, 0, 0, /* A8 */ 74 | 0, 0, 0, 0, 0, 0, 0, 0, /* B0 */ 75 | 0, 0, 0, 0, 0, 0, 0, 0, /* B8 */ 76 | 0, 0, 0, 0, 0, 0, 0, 0, /* C0 */ 77 | 0, 0, 0, 0, 0, 0, 0, 0, /* C8 */ 78 | 0, 0, 0, 0, 0, 0, 0, 0, /* D0 */ 79 | 0, 0, 0, 0, 0, 0, 0, 0, /* D8 */ 80 | 0, 0, 0, 0, 0, 0, 0, 0, /* E0 */ 81 | 0, 0, 0, 0, 0, 0, 0, 0, /* E8 */ 82 | 0, 0, 0, 0, 0, 0, 0, 0, /* F0 */ 83 | 0, 0, 0, 0, 0, 0, 0, 0 /* F8 */ 84 | }; 85 | 86 | int isalnum(int _c) 87 | { 88 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & (_U|_L|_N))); 89 | } 90 | 91 | int isalpha(int _c) 92 | { 93 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & (_U|_L))); 94 | } 95 | 96 | int iscntrl(int _c) 97 | { 98 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _C)); 99 | } 100 | 101 | int isdigit(int _c) 102 | { 103 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _N)); 104 | } 105 | 106 | int isgraph(int _c) 107 | { 108 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & (_P|_U|_L|_N))); 109 | } 110 | 111 | int islower(int _c) 112 | { 113 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _L)); 114 | } 115 | 116 | int isprint(int _c) 117 | { 118 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & (_P|_U|_L|_N|_B))); 119 | } 120 | 121 | int ispunct(int _c) 122 | { 123 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _P)); 124 | } 125 | 126 | int isspace(int _c) 127 | { 128 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _S)); 129 | } 130 | 131 | int isupper(int _c) 132 | { 133 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & _U)); 134 | } 135 | 136 | int isxdigit(int _c) 137 | { 138 | return (_c == -1 ? 0 : ((_ctype_ + 1)[(unsigned char)_c] & (_N|_X))); 139 | } 140 | -------------------------------------------------------------------------------- /tests/TestLibunlinker.py: -------------------------------------------------------------------------------- 1 | #TODO Testing of libunlinker 2 | #@author Jean-Baptiste Boric 3 | #@category Test 4 | #@keybinding 5 | #@menupath 6 | #@toolbar 7 | 8 | import sys, unittest 9 | sys.path.insert(1, "lib") 10 | 11 | from libunlinker import * 12 | from MockProgram import * 13 | 14 | class TestUnlinker(unittest.TestCase): 15 | def _compare(self, object_files, output_dir, reference_dir): 16 | for object_file in object_files: 17 | filename = object_file[0] + ".o" 18 | output = output_dir + "/" + filename 19 | reference = reference_dir + "/" + filename 20 | 21 | with open(output, "rb") as op: 22 | with open(reference, "rb") as rp: 23 | self.assertEquals(op.read(), rp.read()) 24 | 25 | def _weakCompare(self, object_files, output_dir, reference_dir): 26 | for object_file in object_files: 27 | filename = object_file[0] + ".o" 28 | output = output_dir + "/" + filename 29 | reference = reference_dir + "/" + filename 30 | 31 | with open(output, "rb") as op: 32 | output_elf = loadElfFromFile(op) 33 | with open(reference, "rb") as rp: 34 | reference_elf = loadElfFromFile(rp) 35 | 36 | symbols_output = [symbol for symbol in output_elf.read_symbols() if symbol.st_info & STB_GLOBAL] 37 | symbols_reference = [symbol for symbol in reference_elf.read_symbols() if symbol.st_info & STB_GLOBAL] 38 | self.assertEquals(set(symbols_output), set(symbols_reference) & set(symbols_output)) 39 | 40 | for section in reference_elf.sections: 41 | if section.sh_type == SHT_REL and reference_elf.get_section(section.sh_info).sh_flags & SHF_ALLOC == SHF_ALLOC: 42 | rels_output = output_elf.read_rel(section.sh_name) 43 | rels_reference = reference_elf.read_rel(section.sh_name) 44 | self.assertEquals(set(rels_output), set(rels_reference)) 45 | if section.sh_type == SHT_PROGBITS and section.sh_flags & SHF_ALLOC == SHF_ALLOC and len(section.data) > 0: 46 | self.assertEquals(len(output_elf.get_section(section.sh_name).data), len(section.data)) 47 | self.assertEquals(output_elf.get_section(section.sh_name).data, section.data) 48 | 49 | def testHelloWorldMips32ElExec(self): 50 | from reference.libunlinker.mips32el.linux.helloWorld import currentProgram 51 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 52 | sym_address_end = currentProgram.getAddressFactory().getAddress("0040010f") 53 | sym_address_set = currentProgram.getAddressFactory().getAddressSet(sym_address_start, sym_address_end) 54 | object_files = ( 55 | ("helloWorld", ( 56 | ("004000d0", "004000ff", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 57 | ("00400100", "0040010f", ".rodata", SHT_PROGBITS, SHF_ALLOC), 58 | )), 59 | ) 60 | unlink_program(currentProgram, "tests/output/libunlinker/mips32el", object_files, sym_address_set) 61 | self._weakCompare(object_files, "tests/output/libunlinker/mips32el", "tests/reference/libunlinker/mips32el/linux") 62 | 63 | def testAsciiTableMips32ElExec(self): 64 | from reference.libunlinker.mips32el.linux.asciiTable import currentProgram 65 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 66 | sym_address_end = currentProgram.getAddressFactory().getAddress("004005ff") 67 | sym_address_set = currentProgram.getAddressFactory().getAddressSet(sym_address_start, sym_address_end) 68 | object_files = ( 69 | ("asciiTable", ( 70 | ("004000d0", "0040027f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 71 | ("00400490", "004004ef", ".rodata", SHT_PROGBITS, SHF_ALLOC), 72 | )), 73 | ("ctype", ( 74 | ("00400280", "0040048f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 75 | ("004004f0", "004005ff", ".rodata", SHT_PROGBITS, SHF_ALLOC), 76 | )), 77 | ) 78 | unlink_program(currentProgram, "tests/output/libunlinker/mips32el", object_files, sym_address_set) 79 | self._weakCompare(object_files, "tests/output/libunlinker/mips32el", "tests/reference/libunlinker/mips32el/linux") 80 | 81 | def testDataMips32ElExec(self): 82 | from reference.libunlinker.mips32el.testcases.testData import currentProgram 83 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 84 | sym_address_end = currentProgram.getAddressFactory().getAddress("0041057f") 85 | sym_address_set = currentProgram.getAddressFactory().getAddressSet(sym_address_start, sym_address_end) 86 | object_files = ( 87 | ("testBss", ( 88 | ("00400100", "0040031f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 89 | ("00410560", "0041057f", ".bss", SHT_NOBITS, SHF_ALLOC), 90 | )), 91 | ("testData", ( 92 | ("00400320", "0040053f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 93 | ("00410540", "0041055f", ".data", SHT_PROGBITS, SHF_ALLOC), 94 | )), 95 | ) 96 | unlink_program(currentProgram, "tests/output/libunlinker/mips32el", object_files, sym_address_set) 97 | self._weakCompare(object_files, "tests/output/libunlinker/mips32el", "tests/reference/libunlinker/mips32el/testCases") 98 | 99 | def testFlowMips32ElExec(self): 100 | from reference.libunlinker.mips32el.testcases.testFlow import currentProgram 101 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 102 | sym_address_end = currentProgram.getAddressFactory().getAddress("00400014f") 103 | sym_address_set = currentProgram.getAddressFactory().getAddressSet(sym_address_start, sym_address_end) 104 | object_files = ( 105 | ("testFlow", ( 106 | ("004000e0", "0040014f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 107 | )), 108 | ) 109 | unlink_program(currentProgram, "tests/output/libunlinker/mips32el", object_files, sym_address_set) 110 | self._weakCompare(object_files, "tests/output/libunlinker/mips32el", "tests/reference/libunlinker/mips32el/testCases") 111 | 112 | def testSmallDataMips32ElExec(self): 113 | from reference.libunlinker.mips32el.testcases.testSmallData import currentProgram 114 | sym_address_start = currentProgram.getAddressFactory().getAddress("004000d0") 115 | sym_address_end = currentProgram.getAddressFactory().getAddress("00410487") 116 | sym_address_set = currentProgram.getAddressFactory().getAddressSet(sym_address_start, sym_address_end) 117 | object_files = ( 118 | ("testSbss", ( 119 | ("00400100", "004002af", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 120 | ("00410474", "00410487", ".sbss", SHT_NOBITS, SHF_ALLOC), 121 | )), 122 | ("testSdata", ( 123 | ("004002b0", "0040045f", ".text", SHT_PROGBITS, SHF_ALLOC|SHF_EXECINSTR), 124 | ("00410460", "00410473", ".sdata", SHT_PROGBITS, SHF_ALLOC), 125 | )), 126 | ) 127 | unlink_program(currentProgram, "tests/output/libunlinker/mips32el", object_files, sym_address_set) 128 | self._weakCompare(object_files, "tests/output/libunlinker/mips32el", "tests/reference/libunlinker/mips32el/testCases") 129 | 130 | if __name__ == '__main__': 131 | unittest.main() 132 | -------------------------------------------------------------------------------- /tests/MockProgram.py: -------------------------------------------------------------------------------- 1 | class MockAddress: 2 | def __init__(self, value): 3 | self.value = value 4 | 5 | def __repr__(self): 6 | return self.__str__() 7 | 8 | def __str__(self): 9 | return hex(self.value) 10 | 11 | def __eq__(self, address): 12 | return self.value == address.value 13 | 14 | def __ne__(self, other): 15 | return not (self == other) 16 | 17 | def __hash__(self): 18 | return hash(self.value) 19 | 20 | def add(self, displacement): 21 | return MockAddress(self.value + displacement) 22 | 23 | def subtract(self, address): 24 | return self.value - address.value 25 | 26 | def getOffset(self): 27 | return self.value 28 | 29 | def getNewAddress(self, offset): 30 | return MockAddress(offset) 31 | 32 | class MockAddressRange: 33 | def __init__(self, addr, length): 34 | self.addr = addr 35 | self.length = length 36 | 37 | def __repr__(self): 38 | return self.__str__() 39 | 40 | def __str__(self): 41 | return "[{} {}]".format(self.getMinAddress(), self.getMaxAddress()) 42 | 43 | def contains(self, addr): 44 | return addr.subtract(self.addr) >= 0 and addr.subtract(self.addr) < self.length 45 | 46 | def getLength(self): 47 | return self.length 48 | 49 | def getMinAddress(self): 50 | return self.addr 51 | 52 | def getMaxAddress(self): 53 | return self.addr.add(self.length - 1) 54 | 55 | class MockAddressSet: 56 | def __init__(self, min_addr, max_addr): 57 | self.ranges = (MockAddressRange(min_addr, max_addr.subtract(min_addr) + 1),) 58 | 59 | def __str__(self): 60 | return "[{}]".format(" ".join([str(r) for r in self.ranges])) 61 | 62 | def __repr__(self): 63 | return self.__str__() 64 | 65 | def contains(self, addr): 66 | for address_range in self.ranges: 67 | if address_range.contains(addr): 68 | return True 69 | return False 70 | 71 | def getFirstRange(self): 72 | return self.ranges[0] 73 | 74 | def getMinAddress(self): 75 | min_addr = self.ranges[0].getMinAddress() 76 | for address_range in self.ranges: 77 | if min_addr.getOffset() > address_range.getMinAddress().getOffset(): 78 | min_addr = address_range.getMinAddress() 79 | return min_addr 80 | 81 | def getMaxAddress(self): 82 | max_addr = self.ranges[0].getMaxAddress() 83 | for address_range in self.ranges: 84 | if max_addr.getOffset() < address_range.getMaxAddress().getOffset(): 85 | max_addr = address_range.getMaxAddress() 86 | return max_addr 87 | 88 | def getNumAddresses(self): 89 | return self.getFirstRange().getLength() 90 | 91 | class MockAddressFactory: 92 | def getAddress(self, value): 93 | return MockAddress(int(value, 16)) 94 | 95 | def getAddressSet(self, min_addr, max_addr): 96 | return MockAddressSet(min_addr, max_addr) 97 | 98 | class MockData(): 99 | def __init__(self, min_addr, max_addr): 100 | self.min_addr = min_addr 101 | self.max_addr = max_addr 102 | 103 | def getMinAddress(self): 104 | return self.min_addr 105 | 106 | def getMaxAddress(self): 107 | return self.max_addr 108 | 109 | def getLength(self): 110 | return self.max_addr.subtract(self.min_addr) + 1 111 | 112 | class MockListing(): 113 | def __init__(self, data): 114 | self.data = data 115 | self.data_at = dict() 116 | for datum in data: 117 | self.data_at[datum.getMinAddress()] = datum 118 | 119 | def getDataAt(self, address): 120 | return self.data_at.get(address, None) 121 | 122 | class MockFunction: 123 | def __init__(self, name, body): 124 | self.name = name 125 | self.body = body 126 | 127 | def __repr__(self): 128 | return self.__str__() 129 | 130 | def __str__(self): 131 | return self.name 132 | 133 | def getBody(self): 134 | return self.body 135 | 136 | def getEntryPoint(self): 137 | return self.body.getMinAddress() 138 | 139 | def getName(self): 140 | return self.name 141 | 142 | class MockFunctionManager: 143 | def __init__(self, functions): 144 | self.functions = functions 145 | 146 | def getFunctions(self, asv, forward): 147 | if forward == False: 148 | raise Exception("forward != True") 149 | return (f for f in self.functions if asv.contains(f.getEntryPoint())) 150 | 151 | def getFunctionAt(self, address): 152 | for function in self.functions: 153 | if function.getBody().getMinAddress() == address: 154 | return function 155 | return None 156 | 157 | def getFunctionContaining(self, address): 158 | for function in self.functions: 159 | if function.getBody().contains(address): 160 | return function 161 | return None 162 | 163 | class MockMemory: 164 | def __init__(self, memory_blocks): 165 | self.memory_blocks = memory_blocks 166 | 167 | def getBytes(self, address, buffer): 168 | for memory_block in self.memory_blocks: 169 | if memory_block.contains(address): 170 | memory_block.getBytes(address, buffer) 171 | return 172 | 173 | class MockMemoryBlock: 174 | def __init__(self, name, address_range, data): 175 | self.name = name 176 | self.address_range = address_range 177 | self.data = data 178 | 179 | def contains(self, address): 180 | return self.address_range.contains(address) 181 | 182 | def getName(self): 183 | self.name = name 184 | 185 | def getStart(self): 186 | return self.address_range.getMinAddress() 187 | 188 | def getEnd(self): 189 | return self.address_range.getMaxAddress() 190 | 191 | def getBytes(self, address, buffer): 192 | memory_offset = address.subtract(self.getStart()) 193 | for i in range(0, len(buffer)): 194 | buffer[i] = self.data[memory_offset + i] 195 | 196 | class MockReference: 197 | def __init__(self, from_address, to_address, reftype, operand_index, isPrimary): 198 | self.from_address = from_address 199 | self.to_address = to_address 200 | self.reftype = reftype 201 | self.operand_index = operand_index 202 | self._isPrimary = isPrimary 203 | 204 | def __repr__(self): 205 | return self.__str__() 206 | 207 | def __str__(self): 208 | return "From: {} To: {}".format(self.from_address, self.to_address) 209 | 210 | def getFromAddress(self): 211 | return self.from_address 212 | 213 | def getToAddress(self): 214 | return self.to_address 215 | 216 | def getOperandIndex(self): 217 | return self.operand_index 218 | 219 | def getReferenceType(self): 220 | return self.reftype 221 | 222 | def isPrimary(self): 223 | return self._isPrimary 224 | 225 | class MockRefType: 226 | def __init__(self, name, isCall, isComputed, isConditional, isData, isFallthrough, isFlow, isIndirect, isJump, isOverride, isRead, isTerminal, isUnConditional, isWrite): 227 | self.name = name 228 | self._isCall = isCall 229 | self._isComputed = isComputed 230 | self._isConditional = isConditional 231 | self._isData = isData 232 | self._isFallthrough = isFallthrough 233 | self._isFlow = isFlow 234 | self._isIndirect = isIndirect 235 | self._isJump = isJump 236 | self._isOverride = isOverride 237 | self._isRead = isRead 238 | self._isTerminal = isTerminal 239 | self._isUnConditional = isUnConditional 240 | self._isWrite = isWrite 241 | 242 | def getName(self): 243 | return self.name 244 | 245 | def isCall(self): 246 | return self._isCall 247 | 248 | def isComputed(self): 249 | return self._isComputed 250 | 251 | def isConditional(self): 252 | return self._isConditional 253 | 254 | def isData(self): 255 | return self._isData 256 | 257 | def isFallthrough(self): 258 | return self._isFallthrough 259 | 260 | def isFlow(self): 261 | return self._isFlow 262 | 263 | def isIndirect(self): 264 | return self._isIndirect 265 | 266 | def isJump(self): 267 | return self._isJump 268 | 269 | def isOverride(self): 270 | return self._isOverride 271 | 272 | def isRead(self): 273 | return self._isRead 274 | 275 | def isTerminal(self): 276 | return self._isTerminal 277 | 278 | def isUnConditional(self): 279 | return self._isUnConditional 280 | 281 | def isWrite(self): 282 | return self._isWrite 283 | 284 | class MockSymbol: 285 | def __init__(self, name, fullName, address, isGlobal, references): 286 | self.name = name 287 | self.fullName = fullName 288 | self.address = address 289 | self.references = references 290 | self._isGlobal = isGlobal 291 | 292 | def __repr__(self): 293 | return self.__str__() 294 | 295 | def __str__(self): 296 | return self.name 297 | 298 | def getAddress(self): 299 | return self.address 300 | 301 | def getName(self, includeNamespace=False): 302 | if includeNamespace: 303 | return self.fullName 304 | return self.name 305 | 306 | def getReferences(self): 307 | return self.references 308 | 309 | def isGlobal(self): 310 | return self._isGlobal 311 | 312 | class MockSymbolTable: 313 | def __init__(self, symbols): 314 | self.symbols = symbols 315 | 316 | def getAllSymbols(self, includeDynamicSymbols): 317 | if includeDynamicSymbols == False: 318 | raise Exception("includeDynamicSymbols != True") 319 | return self.symbols 320 | 321 | def getSymbols(self, name): 322 | return [symbol for symbol in self.symbols if symbol.getName() == name].__iter__() 323 | 324 | class MockProgram: 325 | def __init__(self, data, functions, memory_blocks, symbols): 326 | self.address_factory = MockAddressFactory() 327 | self.function_manager = MockFunctionManager(functions) 328 | self.listing = MockListing(data) 329 | self.memory = MockMemory(memory_blocks) 330 | self.symbol_table = MockSymbolTable(symbols) 331 | 332 | def getAddressFactory(self): 333 | return self.address_factory 334 | 335 | def getFunctionManager(self): 336 | return self.function_manager 337 | 338 | def getListing(self): 339 | return self.listing 340 | 341 | def getMemory(self): 342 | return self.memory 343 | 344 | def getSymbolTable(self): 345 | return self.symbol_table -------------------------------------------------------------------------------- /lib/libunlinker.py: -------------------------------------------------------------------------------- 1 | #TODO Script library for unlinking a section 2 | #@author Jean-Baptiste Boric 3 | #@category ScriptLibrary 4 | #@keybinding 5 | #@menupath 6 | #@toolbar 7 | 8 | import itertools, jarray, logging, re 9 | from collections import defaultdict 10 | 11 | from libelf import * 12 | from libunlinker_mips32el import * 13 | 14 | class SectionAnalyzer: 15 | RE_SUBSCRIPT = re.compile("^([^.[]+)(\[\d+\]|\.).*$") 16 | RE_LABEL = re.compile("^LAB_.*$") 17 | 18 | def __init__(self, program, section_name, section_range, section_type, section_flags, sym_address_set): 19 | self.program = program 20 | self.section_name = section_name 21 | self.section_range = section_range 22 | self.section_type = section_type 23 | self.section_flags = section_flags 24 | self.sym_address_set = sym_address_set 25 | 26 | self.internal_symbols = set() 27 | self.external_symbols = set() 28 | 29 | self.internal_to_internal = dict() 30 | self.internal_to_external = dict() 31 | self.external_to_internal = dict() 32 | 33 | self._isolate_section() 34 | 35 | def _interesting_symbol(self, symbol_name): 36 | if self.RE_LABEL.match(symbol_name) != None: 37 | return False 38 | 39 | match = self.RE_SUBSCRIPT.match(symbol_name) 40 | if match: 41 | next_symbol = next(self.program.getSymbolTable().getSymbols(match.group(1))) 42 | if next_symbol != None: 43 | return False 44 | 45 | return True 46 | 47 | def _normalize_symbol(self, symbol): 48 | match = self.RE_SUBSCRIPT.match(symbol.getName(True)) 49 | if match: 50 | next_symbol = next(self.program.getSymbolTable().getSymbols(match.group(1))) 51 | if next_symbol == None: 52 | logging.getLogger("unlinker.sym").warning("Cannot normalize subscript symbol {}".format(symbol)) 53 | else: 54 | return next_symbol 55 | 56 | return symbol 57 | 58 | def _isolate_section(self): 59 | for symbol in self.program.getSymbolTable().getAllSymbols(True): 60 | symbol_address = symbol.getAddress() 61 | symbol_name = symbol.getName(True) 62 | 63 | if self.section_range.contains(symbol_address): 64 | if self._interesting_symbol(symbol_name): 65 | self.internal_symbols.add(symbol) 66 | for reference in symbol.getReferences(): 67 | if reference.isPrimary() == False: 68 | continue 69 | from_address = reference.getFromAddress() 70 | if self.section_range.contains(from_address): 71 | offset = reference.getToAddress().subtract(symbol.getAddress()) 72 | self.internal_to_internal[reference] = (symbol, offset) 73 | elif self.sym_address_set.contains(from_address): 74 | self.external_to_internal[reference] = symbol 75 | elif self.sym_address_set.contains(symbol_address): 76 | for reference in symbol.getReferences(): 77 | if reference.isPrimary() == False: 78 | continue 79 | from_address = reference.getFromAddress() 80 | if self.section_range.contains(from_address): 81 | normalized_symbol = self._normalize_symbol(symbol) 82 | offset = reference.getToAddress().subtract(normalized_symbol.getAddress()) 83 | # if symbol.getName()[:4] == "DAT_": 84 | # logging.getLogger("unlinker.sym").warning("Symbol {} of reference {} hasn't been given a name".format(symbol, reference)) 85 | # pass 86 | self.internal_to_external[reference] = (normalized_symbol, offset) 87 | 88 | for reference, (symbol, offset) in self.internal_to_external.iteritems(): 89 | self.external_symbols.add(symbol) 90 | 91 | #FIXME: 1st arg can't be coerced to ghidra.program.model.address.Address, ghidra.program.model.address.AddressSetView 92 | #self.functions = list(self.program.getFunctionManager().getFunctions(self.section_range, True)) 93 | self.functions = list(self.program.getFunctionManager().getFunctions(self.program.getAddressFactory().getAddressSet(self.section_range.getMinAddress(), self.section_range.getMaxAddress()), True)) 94 | 95 | class ElfRelocatableObjectExporter: 96 | def __init__(self, program, relocatable_object, analyzed_sections, context): 97 | self.elf = relocatable_object 98 | self.program = program 99 | self.context = context 100 | 101 | self.symbols = list() 102 | self.internal_symbols = set() 103 | self.external_symbols = set() 104 | for analyzed_section in analyzed_sections: 105 | self.internal_symbols |= analyzed_section.internal_symbols 106 | self.external_symbols |= analyzed_section.external_symbols 107 | self.external_symbols -= analyzed_section.internal_symbols 108 | 109 | for analyzed_section in analyzed_sections: 110 | self.symbols.append(ElfSymbol(analyzed_section.section_name, 0, 0, STB_LOCAL|STT_SECTION, 0, analyzed_section.section_name)) 111 | 112 | for analyzed_section in analyzed_sections: 113 | self._add_section(analyzed_section) 114 | self._build_internal_symbol_table(program, analyzed_section.section_name, analyzed_section.section_range, analyzed_section.internal_symbols) 115 | 116 | self._build_external_symbol_table(program, self.external_symbols) 117 | self.elf.synthesize_symbols(sorted(self.symbols)) 118 | 119 | for analyzed_section in analyzed_sections: 120 | if (analyzed_section.section_flags & (SHF_ALLOC | SHF_EXECINSTR)) == SHF_ALLOC | SHF_EXECINSTR: 121 | self._build_relocations_text(program, analyzed_section) 122 | elif (analyzed_section.section_flags & SHF_ALLOC) == SHF_ALLOC: 123 | self._build_relocations_data(program, analyzed_section) 124 | else: 125 | logging.getLogger("unlinker.rel").error("Section {} is neither text or data".format(analyzed_section.section_name)) 126 | 127 | self.elf.finalize() 128 | 129 | def _add_section(self, section): 130 | section_data = jarray.zeros(section.section_range.getLength(), "b") 131 | if section.section_type != SHT_NOBITS: 132 | self.program.getMemory().getBytes(section.section_range.getMinAddress(), section_data) 133 | section = ElfSection(section.section_name, section.section_type, sh_flags=section.section_flags, sh_addralign=1, data=bytearray(section_data)) 134 | self.elf.append(section) 135 | 136 | def _is_symbol_global(self, symbol): 137 | return symbol.isGlobal() or symbol.getName(True)[:8] == "switchD_" 138 | 139 | def _build_internal_symbol_table(self, program, section_name, section_range, internal_symbols): 140 | for symbol in internal_symbols: 141 | address = symbol.getAddress() 142 | section_address = address.subtract(section_range.getMinAddress()) 143 | function = program.getFunctionManager().getFunctionAt(address) 144 | data = program.getListing().getDataAt(address) 145 | 146 | if self._is_symbol_global(symbol): 147 | st_info = STB_GLOBAL 148 | else: 149 | st_info = STB_LOCAL 150 | 151 | if function != None and function.getEntryPoint() == address: 152 | st_length = function.getBody().getNumAddresses() 153 | st_info |= STT_FUNC 154 | elif data != None: 155 | st_length = data.getLength() 156 | st_info |= STT_OBJECT 157 | else: 158 | st_length = 0 159 | st_info |= STT_NOTYPE 160 | 161 | self.symbols.append(ElfSymbol(symbol.getName(True), section_address, st_length, st_info, 0, section_name)) 162 | 163 | def _build_external_symbol_table(self, program, external_symbols): 164 | for symbol in external_symbols: 165 | address = symbol.getAddress() 166 | 167 | elf_symbol = ElfSymbol(symbol.getName(True), 0, 0, STB_GLOBAL, 0, "") 168 | self.symbols.append(elf_symbol) 169 | 170 | def _build_relocations_text(self, program, section): 171 | relocations = defaultdict(set) 172 | patches = defaultdict(set) 173 | 174 | for reference, (symbol, to_offset) in itertools.chain(section.internal_to_external.iteritems(), section.internal_to_internal.iteritems()): 175 | from_address = reference.getFromAddress() 176 | from_offset = from_address.subtract(section.section_range.getMinAddress()) 177 | function = program.getFunctionManager().getFunctionContaining(from_address) 178 | rels = None 179 | 180 | if function != None: 181 | rels = self.elf.delocate_text(section, function, reference, symbol.getName(True), from_offset, to_offset, self.context) 182 | if rels != None: 183 | for processed_relocation in rels[0]: 184 | relocations[processed_relocation.r_address].add(processed_relocation) 185 | for processed_patch in rels[1]: 186 | patches[processed_patch.offset].add(processed_patch) 187 | else: 188 | logging.getLogger("unlinker.rel").error("Unsupported text delocation reference {} from_offset {} to_offset {} symbol {}".format(reference, from_offset, to_offset, symbol)) 189 | 190 | self._synthesize_relocations(section, relocations, patches) 191 | 192 | def _build_relocations_data(self, program, section): 193 | relocations = defaultdict(set) 194 | patches = defaultdict(set) 195 | 196 | for reference, (symbol, to_offset) in itertools.chain(section.internal_to_external.iteritems(), section.internal_to_internal.iteritems()): 197 | from_address = reference.getFromAddress() 198 | from_offset = from_address.subtract(section.section_range.getMinAddress()) 199 | 200 | rels = self.elf.delocate_data(section, reference, symbol.getName(True), from_offset, to_offset, self.context) 201 | if rels != None: 202 | for processed_relocation in rels[0]: 203 | relocations[processed_relocation.r_address].add(processed_relocation) 204 | for processed_patch in rels[1]: 205 | patches[processed_patch.offset].add(processed_patch) 206 | else: 207 | logging.getLogger("unlinker.rel").error("Unsupported data delocation reference {} from_offset {} to_offset {} symbol {}".format(reference, from_offset, to_offset, symbol)) 208 | 209 | self._synthesize_relocations(section, relocations, patches) 210 | 211 | def _synthesize_relocations(self, section, relocations_dict, patches_dict): 212 | if len(relocations_dict) == 0: 213 | return 214 | 215 | relocations_list = list() 216 | elf_section = self.elf.get_section(section.section_name) 217 | 218 | for offset in sorted(relocations_dict.keys()): 219 | relocations = relocations_dict[offset] 220 | if len(relocations) > 1: 221 | logging.getLogger("unlinker.rel").error("Multiple conflicting relocations @ 0x{:x}: {}".format(offset, relocations)) 222 | relocations_list.extend(relocations) 223 | 224 | for offset in sorted(patches_dict.keys()): 225 | patches = patches_dict[offset] 226 | if len(patches) > 1: 227 | logging.getLogger("unlinker.rel").error("Multiple conflicting patches @ 0x{:x}: {}".format(offset, patches)) 228 | for patch in patches: 229 | if patch.length == 4: 230 | elf_section.write_u32(patch.offset, patch.value) 231 | else: 232 | raise Exception("Don't know how to patch with length " + str(patch.length)) 233 | 234 | self.elf.synthesize_relocations(relocations_list, info_section=section.section_name) 235 | 236 | def unlink_program(currentProgram, output_dir, object_files, sym_address_set): 237 | for object_file in object_files: 238 | output_path = output_dir + '/' + object_file[0] + '.o' 239 | log_path = output_path + ".log" 240 | sections = list() 241 | print(" --- Processing object file {}".format(output_path)) 242 | 243 | try: 244 | os.remove(log_path) 245 | except: 246 | pass 247 | log_file = logging.FileHandler(log_path) 248 | logging.getLogger("unlinker").addHandler(log_file) 249 | 250 | for object_section in object_file[1]: 251 | start_address = currentProgram.getAddressFactory().getAddress(object_section[0]) 252 | end_address = currentProgram.getAddressFactory().getAddress(object_section[1]) 253 | section_name = object_section[2] 254 | section_type = object_section[3] 255 | section_flags = object_section[4] 256 | section_range = currentProgram.getAddressFactory().getAddressSet(start_address, end_address).getFirstRange() 257 | 258 | gp = next(currentProgram.getSymbolTable().getSymbols("_gp")) 259 | if gp != None: 260 | gp = gp.getAddress().getOffset() 261 | context = { 262 | "gp": gp, 263 | } 264 | 265 | print(" * Processing section {} {}".format(section_name, section_range)) 266 | section = SectionAnalyzer(currentProgram, section_name, section_range, section_type, section_flags, sym_address_set) 267 | sections.append(section) 268 | 269 | with open(output_path, "wb") as fp: 270 | elf = ElfRelocatableObjectMips32l() 271 | exporter = ElfRelocatableObjectExporter(currentProgram, elf, sections, context) 272 | elf.write(fp) 273 | 274 | logging.getLogger("unlinker").removeHandler(log_file) 275 | log_file.close() 276 | -------------------------------------------------------------------------------- /lib/libelf.py: -------------------------------------------------------------------------------- 1 | #TODO Script library for writing ELF files 2 | #@author Jean-Baptiste Boric 3 | #@category ScriptLibrary 4 | #@keybinding 5 | #@menupath 6 | #@toolbar 7 | 8 | #TODO Make it 64-bit ELF compatible 9 | 10 | import itertools, jarray, struct 11 | 12 | ELFCLASSNONE = 0 13 | ELFCLASS32 = 1 14 | ELFCLASS64 = 2 15 | 16 | ELFDATANONE = 0 17 | ELFDATA2LSB = 1 18 | ELFDATA2MSB = 2 19 | 20 | EV_NONE = 0 21 | EV_CURRENT = 1 22 | 23 | ELFOSABI_SYSV = 0 24 | ELFOSABI_HPUX = 1 25 | ELFOSABI_NETBSD = 2 26 | ELFOSABI_LINUX = 3 27 | ELFOSABI_HURD = 4 28 | ELFOSABI_86OPEN = 5 29 | ELFOSABI_SOLARIS = 6 30 | ELFOSABI_MONTEREY = 7 31 | ELFOSABI_IRIX = 8 32 | ELFOSABI_FREEBSD = 9 33 | ELFOSABI_TRU64 = 10 34 | ELFOSABI_MODESTO = 11 35 | ELFOSABI_OPENBSD = 12 36 | ELFOSABI_ARM = 97 37 | ELFOSABI_STANDALONE = 255 38 | 39 | ELF_ET_NONE = 0 40 | ELF_ET_REL = 1 41 | ELF_ET_EXEC = 2 42 | ELF_ET_DYN = 3 43 | ELF_ET_CORE = 4 44 | 45 | ELF_EM_MIPS = 8 46 | 47 | ELF_EV_NONE = 0 48 | ELF_EV_CURRENT = 1 49 | 50 | elf32_hdr = "<4c12BHHIIIIIHHHHHH" 51 | elf32_hdr_size = struct.calcsize(elf32_hdr) 52 | elf32_sym = "= 0xff00: 274 | symbol_data=(0, 0, 0, 0, 0, 0) 275 | 276 | section_name = self.sections[symbol_data[5]].sh_name 277 | if symbol_data[3] == STB_LOCAL|STT_SECTION: 278 | symbol_name = section_name 279 | else: 280 | symbol_name = strtab_data[symbol_data[0]:strtab_data.index("\0", symbol_data[0])] 281 | 282 | symbols.append(ElfSymbol(symbol_name, symbol_data[1], symbol_data[2], symbol_data[3], symbol_data[4], self.sections[symbol_data[5]].sh_name)) 283 | return symbols 284 | 285 | def synthesize_relocations(self, relocations, info_section=".text", link_section=".symtab"): 286 | rel_data = bytearray() 287 | 288 | for relocation in relocations: 289 | symbol_idx = self.find_symbol_idx(relocation.r_symbol, link_section) 290 | rel_data += struct.pack(elf32_rel, 291 | relocation.r_address, symbol_idx << 8 | relocation.r_type 292 | ) 293 | 294 | self.append(ElfSection(".rel" + info_section, SHT_REL, sh_link=link_section, sh_info=info_section, sh_entsize=elf32_rel_size, data=rel_data)) 295 | 296 | def read_rel(self, section): 297 | section_rel = self.get_section(section) 298 | if section_rel.sh_type != SHT_REL: 299 | raise Exception("section type of " + section_rel.sh_name + " is not REL") 300 | 301 | symbols = self.read_symbols(section_rel.sh_link) 302 | 303 | rels = list() 304 | for raw_rel in itertools.izip_longest(*[iter(section_rel.data)] * struct.calcsize(elf32_rel)): 305 | rel_data = struct.unpack(elf32_rel, bytearray(raw_rel)) 306 | rels.append(ElfRel(rel_data[0], symbols[rel_data[1] >> 8].st_name, rel_data[1] & 0xff)) 307 | return rels 308 | 309 | class ElfSection: 310 | def __init__(self, sh_name, sh_type, sh_flags=0, sh_link="", sh_info="", sh_addralign=0, sh_entsize=0, data=""): 311 | self.sh_name = sh_name 312 | self.sh_type = sh_type 313 | self.sh_flags = sh_flags 314 | self.sh_link = sh_link 315 | self.sh_info = sh_info 316 | self.sh_addralign = sh_addralign 317 | self.sh_entsize = sh_entsize 318 | 319 | self.data = data 320 | 321 | def read_u32(self, offset): 322 | return struct.unpack_from("> 8) & 0xFF 328 | self.data[offset + 2] = (value >> 16) & 0xFF 329 | self.data[offset + 3] = (value >> 24) & 0xFF 330 | 331 | class ElfSymbol: 332 | def __init__(self, name, value, size, info, others, section): 333 | self.st_name = name 334 | self.st_value = value 335 | self.st_size = size 336 | self.st_info = info 337 | self.st_others = others 338 | self.st_section = section 339 | 340 | def __repr__(self): 341 | return "S 0x{:x} {} {}".format(self.st_value, self.st_section if self.st_section != "" else "UND", self.st_name) 342 | 343 | def __eq__(self, other): 344 | return self.st_name == other.st_name and self.st_value == other.st_value and self.st_size == other.st_size and self.st_info == other.st_info and self.st_others == other.st_others and self.st_section == other.st_section 345 | 346 | def __lt__(self, other): 347 | if self.st_info & 0xF0 == other.st_info & 0xF0: 348 | if self.st_section == other.st_section: 349 | if self.st_value == other.st_value: 350 | return self.st_name < other.st_name 351 | return self.st_value < other.st_value 352 | return self.st_section < other.st_section 353 | return self.st_info & 0xF0 < other.st_info & 0xF0 354 | 355 | def __hash__(self): 356 | return hash((self.st_name, self.st_value, self.st_size, self.st_info, self.st_others, self.st_section)) 357 | 358 | class ElfRel: 359 | def __init__(self, r_address, r_symbol, r_type): 360 | self.r_address = r_address 361 | self.r_symbol = r_symbol 362 | self.r_type = r_type 363 | 364 | def __repr__(self): 365 | return "R 0x{:x} {} {}".format(self.r_address, self.r_symbol, self.r_type) 366 | 367 | def __eq__(self, other): 368 | return self.r_address == other.r_address and self.r_symbol == other.r_symbol and self.r_type == other.r_type 369 | 370 | def __ne__(self, other): 371 | return not (self == other) 372 | 373 | def __hash__(self): 374 | return hash((self.r_address, self.r_symbol, self.r_type)) 375 | -------------------------------------------------------------------------------- /lib/libunlinker_mips32el.py: -------------------------------------------------------------------------------- 1 | from libelf import * 2 | from libelf_mips32el import * 3 | from libunlinker_common import * 4 | 5 | def li_32(lui, low_inst): 6 | if low_inst.opcode() in MIPS32_OPCODES_LOADSTORE + (MIPS32_OPCODE_ADDIU,): 7 | low_const = low_inst.immediate_i() 8 | elif low_inst.opcode() == MIPS32_OPCODE_ORI: 9 | low_const = low_inst.immediate_i_ze() 10 | else: 11 | raise Exception("Unknown 32-bit load instruction pattern {} {}".format(lui, low_inst)) 12 | return ((lui.immediate_i() << 16) & 0xffff0000) + low_const 13 | 14 | def from_jtype(j, reference): 15 | return (reference.getFromAddress().getOffset() & 0xf0000000) + (j.immediate_j() << 2) 16 | 17 | class Mips32Instruction: 18 | def __init__(self, value): 19 | self.value = value 20 | 21 | def opcode(self): 22 | return (self.value >> MIPS32_OPCODE_OFFSET) & MIPS32_OPCODE_MASK 23 | 24 | def sreg(self): 25 | return (self.value >> MIPS32_SREG_OFFSET) & MIPS32_SREG_MASK 26 | 27 | def treg(self): 28 | return (self.value >> MIPS32_TREG_OFFSET) & MIPS32_TREG_MASK 29 | 30 | def dreg(self): 31 | return (self.value >> MIPS32_DREG_OFFSET) & MIPS32_DREG_MASK 32 | 33 | def func(self): 34 | return self.value & MIPS32_FUNC_MASK 35 | 36 | def immediate_i(self): 37 | return twos_complement(self.value & MIPS32_ITYPE_IMM_MASK, 16) 38 | 39 | def immediate_i_ze(self): 40 | return self.value & MIPS32_ITYPE_IMM_MASK 41 | 42 | def immediate_j(self): 43 | return self.value & ~(MIPS32_OPCODE_MASK << MIPS32_OPCODE_OFFSET) 44 | 45 | def zeroed_immediate_i(self): 46 | return self.value & ~MIPS32_ITYPE_IMM_MASK 47 | 48 | def zeroed_immediate_j(self): 49 | return self.value & (MIPS32_OPCODE_MASK << MIPS32_OPCODE_OFFSET) 50 | 51 | def __repr__(self): 52 | return "0x{:8x}".format(self.value) 53 | 54 | class InstructionPattern: 55 | def __init__(self, opcode=None, sreg=None, treg=None, dreg=None, func=None): 56 | self.opcode = opcode 57 | self.sreg = sreg 58 | self.treg = treg 59 | self.dreg = dreg 60 | self.func = func 61 | 62 | def match(self, instructions): 63 | instruction = instructions[-1] 64 | if test_condition(self.opcode, instruction.opcode(), instructions) and \ 65 | test_condition(self.sreg, instruction.sreg(), instructions) and \ 66 | test_condition(self.treg, instruction.treg(), instructions) and \ 67 | test_condition(self.dreg, instruction.dreg(), instructions) and \ 68 | test_condition(self.func, instruction.func(), instructions): 69 | return True 70 | return False 71 | 72 | class ReferencePattern: 73 | def __init__(self, fixup, patterns, operand_index, reftype=None, symbol=None): 74 | self.fixup = fixup 75 | self.operand_index = operand_index 76 | self.patterns = patterns 77 | self.reftype = reftype 78 | self.symbol = symbol 79 | 80 | def _build_chains(self, section, offset, min_offset, depth=0, chain=()): 81 | current_chain = chain + (offset,) 82 | instructions = tuple(Mips32Instruction(section.read_u32(link)) for link in current_chain) 83 | 84 | if self.patterns[depth].match(instructions): 85 | if len(current_chain) == len(self.patterns): 86 | return (current_chain,) 87 | new_chains = (self._build_chains(section, i, min_offset, depth+1, current_chain) for i in range(offset - 4, min_offset - 4, -4)) 88 | return itertools.chain.from_iterable(new_chains) 89 | return () 90 | 91 | def match(self, elf, section, function, reference, symbol, from_offset, to_offset, context): 92 | if not test_condition(self.operand_index, reference.getOperandIndex(), None): 93 | return None 94 | if not test_condition(self.reftype, reference.getReferenceType().getName(), None): 95 | return None 96 | 97 | min_offset = function.getEntryPoint().subtract(section.section_range.getMinAddress()) 98 | elf_section = elf.get_section(section.section_name) 99 | 100 | chains = tuple(self._build_chains(elf_section, from_offset, min_offset)) 101 | 102 | for chain in chains: 103 | instructions = tuple(Mips32Instruction(elf_section.read_u32(link)) for link in chain) 104 | fix = self.fixup(chain, instructions, reference, symbol, to_offset, context) 105 | if fix != None: 106 | return fix 107 | return None 108 | 109 | def fixup_mips_26(chain, instructions, reference, symbol, to_offset, context): 110 | if from_jtype(instructions[0], reference) == reference.getToAddress().getOffset(): 111 | return ( 112 | ( 113 | ElfRel(chain[0], symbol, R_MIPS_26), 114 | ), 115 | ( 116 | PatchRequest(chain[0], instructions[0].zeroed_immediate_j() + (to_offset >> 2), 4), 117 | ), 118 | ) 119 | return None 120 | 121 | def fixup_mips_hi16_lo16_lui_itype_offset(chain, instructions, reference, symbol, to_offset, context): 122 | if li_32(instructions[-1], instructions[-2]) == reference.getToAddress().getOffset(): 123 | return ( 124 | ( 125 | ElfRel(chain[-1], symbol, R_MIPS_HI16), 126 | ElfRel(chain[-2], symbol, R_MIPS_LO16), 127 | ), 128 | ( 129 | PatchRequest(chain[-1], instructions[-1].zeroed_immediate_i(), 4), 130 | PatchRequest(chain[-2], instructions[-2].zeroed_immediate_i() + to_offset, 4), 131 | ), 132 | ) 133 | return None 134 | 135 | def fixup_mips_hi16_lo16_lui_itype_loadstore_offset(chain, instructions, reference, symbol, to_offset, context): 136 | if li_32(instructions[-1], instructions[-2]) == (reference.getToAddress().getOffset() - to_offset) \ 137 | and instructions[-3].immediate_i() == to_offset: 138 | return ( 139 | ( 140 | ElfRel(chain[-1], symbol, R_MIPS_HI16), 141 | ElfRel(chain[-2], symbol, R_MIPS_LO16), 142 | ), 143 | ( 144 | PatchRequest(chain[-1], instructions[-1].zeroed_immediate_i(), 4), 145 | PatchRequest(chain[-2], instructions[-2].zeroed_immediate_i(), 4), 146 | ), 147 | ) 148 | return None 149 | 150 | def fixup_mips_hi16_lo16_lui_itype_offset_reg_loadstore(chain, instructions, reference, symbol, to_offset, context): 151 | if li_32(instructions[-1], instructions[-2]) == (reference.getToAddress().getOffset()) \ 152 | and instructions[-4].immediate_i() == 0: 153 | return ( 154 | ( 155 | ElfRel(chain[-1], symbol, R_MIPS_HI16), 156 | ElfRel(chain[-2], symbol, R_MIPS_LO16), 157 | ), 158 | ( 159 | PatchRequest(chain[-1], instructions[-1].zeroed_immediate_i(), 4), 160 | PatchRequest(chain[-2], instructions[-2].zeroed_immediate_i() + to_offset, 4), 161 | ), 162 | ) 163 | return None 164 | 165 | def fixup_mips_gprel16_itype_offset(chain, instructions, reference, symbol, to_offset, context): 166 | if context["gp"] == None: 167 | return None 168 | if context["gp"] + instructions[-1].immediate_i() == reference.getToAddress().getOffset(): 169 | return ( 170 | ( 171 | ElfRel(chain[-1], symbol, R_MIPS_GPREL16), 172 | ), 173 | ( 174 | PatchRequest(chain[-1], instructions[-1].zeroed_immediate_i() + to_offset, 4), 175 | ), 176 | ) 177 | return None 178 | 179 | def fixup_mips_gprel16_addiu_loadstore_offset(chain, instructions, reference, symbol, to_offset, context): 180 | if context["gp"] == None: 181 | return None 182 | if context["gp"] + instructions[-1].immediate_i() == (reference.getToAddress().getOffset() - to_offset) \ 183 | and instructions[-2].immediate_i() == to_offset: 184 | return ( 185 | ( 186 | ElfRel(chain[-1], symbol, R_MIPS_GPREL16), 187 | ), 188 | ( 189 | PatchRequest(chain[-1], instructions[-1].zeroed_immediate_i(), 4), 190 | ), 191 | ) 192 | return None 193 | 194 | def fixup_mips_gprel16_addiu_offset_reg_loadstore(chain, instructions, reference, symbol, to_offset, context): 195 | if context["gp"] == None: 196 | return None 197 | if (context["gp"] + instructions[-1].immediate_i() == reference.getToAddress().getOffset()) \ 198 | and instructions[-3].immediate_i() == 0: 199 | return ( 200 | ( 201 | ElfRel(chain[-1], symbol, R_MIPS_GPREL16), 202 | ), 203 | ( 204 | PatchRequest(chain[-1], instructions[-1].zeroed_immediate_i() + to_offset, 4), 205 | ), 206 | ) 207 | return None 208 | 209 | REFERENCE_PATTERNS=( 210 | # Call/jump 211 | ReferencePattern( 212 | reftype=(UNCONDITIONAL_CALL, UNCONDITIONAL_JUMP), 213 | operand_index=0, 214 | patterns=tuple(reversed(( 215 | InstructionPattern(opcode=(MIPS32_OPCODE_J, MIPS32_OPCODE_JAL)), 216 | ))), 217 | fixup=fixup_mips_26, 218 | ), 219 | ReferencePattern( 220 | reftype=COMPUTED_CALL, 221 | operand_index=0, 222 | patterns=tuple(reversed(( 223 | InstructionPattern(opcode=MIPS32_OPCODE_LUI, treg=lambda reg, instructions : reg == instructions[1].sreg()), 224 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, treg=lambda reg, instructions : reg == instructions[0].sreg()), 225 | InstructionPattern(opcode=MIPS32_OPCODE_REG, func=(MIPS32_OPCODE_JR, MIPS32_OPCODE_JALR), sreg=MIPS32_REGS_NOT_GP), 226 | ))), 227 | fixup=fixup_mips_hi16_lo16_lui_itype_offset, 228 | ), 229 | # Not GP-relative 230 | ReferencePattern( 231 | reftype=(DATA, PARAM), 232 | operand_index=0, 233 | patterns=tuple(reversed(( 234 | InstructionPattern(opcode=MIPS32_OPCODE_LUI, treg=lambda reg, instructions : reg == instructions[0].sreg()), 235 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, sreg=MIPS32_REGS_NOT_GP), 236 | ))), 237 | fixup=fixup_mips_hi16_lo16_lui_itype_offset, 238 | ), 239 | ReferencePattern( 240 | reftype=(DATA, PARAM), 241 | operand_index=(0, 1), 242 | patterns=tuple(reversed(( 243 | InstructionPattern(opcode=MIPS32_OPCODE_LUI, treg=lambda reg, instructions : reg == instructions[1].sreg()), 244 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, treg=lambda reg, instructions : reg in (instructions[0].sreg(), instructions[0].treg())), 245 | InstructionPattern(opcode=MIPS32_OPCODE_REG, func=MIPS32_FUNC_ADDU), 246 | ))), 247 | fixup=fixup_mips_hi16_lo16_lui_itype_offset, 248 | ), 249 | ReferencePattern( 250 | reftype=(READ, WRITE), 251 | operand_index=1, 252 | patterns=tuple(reversed(( 253 | InstructionPattern(opcode=MIPS32_OPCODE_LUI, treg=lambda reg, instructions : reg == instructions[0].sreg()), 254 | InstructionPattern(opcode=MIPS32_OPCODES_LOADSTORE, sreg=MIPS32_REGS_NOT_GP), 255 | ))), 256 | fixup=fixup_mips_hi16_lo16_lui_itype_offset, 257 | ), 258 | ReferencePattern( 259 | reftype=(READ, WRITE), 260 | operand_index=1, 261 | patterns=tuple(reversed(( 262 | InstructionPattern(opcode=MIPS32_OPCODE_LUI, treg=lambda reg, instructions : reg == instructions[1].sreg()), 263 | InstructionPattern(opcode=(MIPS32_OPCODE_ADDIU, MIPS32_OPCODE_ORI), treg=lambda reg, instructions : reg == instructions[0].sreg()), 264 | InstructionPattern(opcode=MIPS32_OPCODES_LOADSTORE, sreg=MIPS32_REGS_NOT_GP), 265 | ))), 266 | fixup=fixup_mips_hi16_lo16_lui_itype_loadstore_offset, 267 | ), 268 | ReferencePattern( 269 | reftype=(READ, WRITE), 270 | operand_index=(0, 1), 271 | patterns=tuple(reversed(( 272 | InstructionPattern(opcode=MIPS32_OPCODE_LUI, treg=lambda reg, instructions : reg == instructions[2].sreg()), 273 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, treg=lambda reg, instructions : reg in (instructions[1].sreg(), instructions[1].treg())), 274 | InstructionPattern(opcode=MIPS32_OPCODE_REG, func=MIPS32_FUNC_ADDU, dreg=lambda reg, instructions : reg == instructions[0].sreg()), 275 | InstructionPattern(opcode=MIPS32_OPCODES_LOADSTORE, sreg=MIPS32_REGS_NOT_GP), 276 | ))), 277 | fixup=fixup_mips_hi16_lo16_lui_itype_offset_reg_loadstore, 278 | ), 279 | # GP-relative 280 | ReferencePattern( 281 | reftype=(DATA, PARAM), 282 | operand_index=0, 283 | patterns=tuple(reversed(( 284 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, sreg=MIPS32_REG_GP), 285 | ))), 286 | fixup=fixup_mips_gprel16_itype_offset, 287 | ), 288 | ReferencePattern( 289 | reftype=(DATA, PARAM), 290 | operand_index=(0, 1), 291 | patterns=tuple(reversed(( 292 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, treg=lambda reg, instructions : reg in (instructions[0].sreg(), instructions[0].treg()), sreg=MIPS32_REG_GP), 293 | InstructionPattern(opcode=MIPS32_OPCODE_REG, func=MIPS32_FUNC_ADDU), 294 | ))), 295 | fixup=fixup_mips_gprel16_itype_offset, 296 | ), 297 | ReferencePattern( 298 | reftype=(READ, WRITE), 299 | operand_index=1, 300 | patterns=tuple(reversed(( 301 | InstructionPattern(opcode=MIPS32_OPCODES_LOADSTORE, sreg=MIPS32_REG_GP), 302 | ))), 303 | fixup=fixup_mips_gprel16_itype_offset, 304 | ), 305 | ReferencePattern( 306 | reftype=(READ, WRITE), 307 | operand_index=1, 308 | patterns=tuple(reversed(( 309 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, treg=lambda reg, instructions : reg == instructions[0].sreg(), sreg=MIPS32_REG_GP), 310 | InstructionPattern(opcode=MIPS32_OPCODES_LOADSTORE, sreg=MIPS32_REGS_NOT_GP), 311 | ))), 312 | fixup=fixup_mips_gprel16_addiu_loadstore_offset, 313 | ), 314 | ReferencePattern( 315 | reftype=(READ, WRITE), 316 | operand_index=(0, 1), 317 | patterns=tuple(reversed(( 318 | InstructionPattern(opcode=MIPS32_OPCODE_ADDIU, treg=lambda reg, instructions : reg in (instructions[1].sreg(), instructions[1].treg()), sreg=MIPS32_REG_GP), 319 | InstructionPattern(opcode=MIPS32_OPCODE_REG, func=MIPS32_FUNC_ADDU, dreg=lambda reg, instructions : reg == instructions[0].sreg()), 320 | InstructionPattern(opcode=MIPS32_OPCODES_LOADSTORE, sreg=MIPS32_REGS_NOT_GP), 321 | ))), 322 | fixup=fixup_mips_gprel16_addiu_offset_reg_loadstore, 323 | ), 324 | ) 325 | 326 | class ElfRelocatableObjectMips32l(ElfFile): 327 | def __init__(self): 328 | ElfFile.__init__(self, ELFCLASS32, ELFDATA2LSB, ELF_ET_REL, ELF_EM_MIPS, e_flags=0x1000) 329 | self.relocations = dict() 330 | 331 | def delocate_text(self, section, function, reference, symbol, from_offset, to_offset, context): 332 | instruction = Mips32Instruction(self.get_section(section.section_name).read_u32(from_offset)) 333 | reftype = reference.getReferenceType() 334 | 335 | if instruction.opcode() in MIPS32_OPCODES_RELATIVE_JUMPS and section.section_range.contains(reference.getToAddress()): 336 | # Relative branches within section 337 | return ((), ()) 338 | elif instruction.opcode() == MIPS32_OPCODE_J and function.getBody().contains(reference.getToAddress()): 339 | # Absolute jump within function 340 | to_offset = reference.getToAddress().subtract(section.section_range.getMinAddress()) 341 | symbol = section.section_name 342 | 343 | for pattern in REFERENCE_PATTERNS: 344 | result = pattern.match(self, section, function, reference, symbol, from_offset, to_offset, context) 345 | if result != None: 346 | return result 347 | return None 348 | 349 | def delocate_data(self, section, reference, symbol, from_offset, to_offset, context): 350 | return ( 351 | ( 352 | ElfRel(from_offset, symbol, R_MIPS_32), 353 | ), 354 | ( 355 | PatchRequest(from_offset, to_offset, 4), 356 | ), 357 | ) 358 | 359 | def finalize(self): 360 | if self.has_section(".text"): 361 | self.append(ElfSection(".reginfo", SHT_MIPS_REGINFO, sh_link=".text", data=bytearray("\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1C"))) 362 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/helloWorld.py: -------------------------------------------------------------------------------- 1 | # Generated from helloWorld.elf 2 | from MockProgram import * 3 | # Data 4 | data = ( 5 | MockData(min_addr=MockAddress(0x400000), max_addr=MockAddress(0x400033)), 6 | MockData(min_addr=MockAddress(0x400034), max_addr=MockAddress(0x400093)), 7 | MockData(min_addr=MockAddress(0x4000b0), max_addr=MockAddress(0x4000c7)), 8 | MockData(min_addr=MockAddress(0x400100), max_addr=MockAddress(0x40010e)), 9 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x20)), 10 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x3)), 11 | MockData(min_addr=MockAddress(0x4), max_addr=MockAddress(0x7)), 12 | MockData(min_addr=MockAddress(0x8), max_addr=MockAddress(0x8)), 13 | MockData(min_addr=MockAddress(0x9), max_addr=MockAddress(0x9)), 14 | MockData(min_addr=MockAddress(0xa), max_addr=MockAddress(0xa)), 15 | MockData(min_addr=MockAddress(0xb), max_addr=MockAddress(0xb)), 16 | MockData(min_addr=MockAddress(0xc), max_addr=MockAddress(0xc)), 17 | MockData(min_addr=MockAddress(0xd), max_addr=MockAddress(0xf)), 18 | MockData(min_addr=MockAddress(0x10), max_addr=MockAddress(0x13)), 19 | MockData(min_addr=MockAddress(0x14), max_addr=MockAddress(0x17)), 20 | MockData(min_addr=MockAddress(0x18), max_addr=MockAddress(0x1b)), 21 | MockData(min_addr=MockAddress(0x1c), max_addr=MockAddress(0x1f)), 22 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0xc)), 23 | MockData(min_addr=MockAddress(0x1), max_addr=MockAddress(0x8)), 24 | MockData(min_addr=MockAddress(0x9), max_addr=MockAddress(0x10)), 25 | MockData(min_addr=MockAddress(0x11), max_addr=MockAddress(0x1a)), 26 | MockData(min_addr=MockAddress(0x1b), max_addr=MockAddress(0x29)), 27 | MockData(min_addr=MockAddress(0x2a), max_addr=MockAddress(0x32)), 28 | MockData(min_addr=MockAddress(0x33), max_addr=MockAddress(0x38)), 29 | MockData(min_addr=MockAddress(0x39), max_addr=MockAddress(0x40)), 30 | MockData(min_addr=MockAddress(0x41), max_addr=MockAddress(0x49)), 31 | MockData(min_addr=MockAddress(0x4a), max_addr=MockAddress(0x4e)), 32 | MockData(min_addr=MockAddress(0x4f), max_addr=MockAddress(0x5d)), 33 | MockData(min_addr=MockAddress(0x5e), max_addr=MockAddress(0x69)), 34 | MockData(min_addr=MockAddress(0x6a), max_addr=MockAddress(0x77)), 35 | MockData(min_addr=MockAddress(0x78), max_addr=MockAddress(0x83)), 36 | MockData(min_addr=MockAddress(0x84), max_addr=MockAddress(0x90)), 37 | MockData(min_addr=MockAddress(0x91), max_addr=MockAddress(0x9b)), 38 | MockData(min_addr=MockAddress(0x9c), max_addr=MockAddress(0xab)), 39 | MockData(min_addr=MockAddress(0xac), max_addr=MockAddress(0xb9)), 40 | MockData(min_addr=MockAddress(0x1), max_addr=MockAddress(0x13)), 41 | MockData(min_addr=MockAddress(0x14), max_addr=MockAddress(0x17)), 42 | MockData(min_addr=MockAddress(0x18), max_addr=MockAddress(0x25)), 43 | MockData(min_addr=MockAddress(0x26), max_addr=MockAddress(0x2c)), 44 | MockData(min_addr=MockAddress(0x2d), max_addr=MockAddress(0x34)), 45 | MockData(min_addr=MockAddress(0x35), max_addr=MockAddress(0x3b)), 46 | MockData(min_addr=MockAddress(0x3c), max_addr=MockAddress(0x47)), 47 | MockData(min_addr=MockAddress(0x48), max_addr=MockAddress(0x4e)), 48 | MockData(min_addr=MockAddress(0x4f), max_addr=MockAddress(0x53)), 49 | MockData(min_addr=MockAddress(0x54), max_addr=MockAddress(0x59)), 50 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x19f)), 51 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x2cf)), 52 | ) 53 | # Functions 54 | functions = ( 55 | MockFunction(name='__start', body=MockAddressSet(MockAddress(0x4000d0), MockAddress(0x4000f3))), 56 | ) 57 | # Memory blocks 58 | memory_blocks = ( 59 | MockMemoryBlock(name='segment_2.1', address_range=MockAddressSet(MockAddress(0x400000), MockAddress(0x400097)).getFirstRange(), data=(127,69,76,70,1,1,1,0,0,0,0,0,0,0,0,0,2,0,8,0,1,0,0,0,-48,0,64,0,52,0,0,0,-40,7,0,0,0,16,0,0,52,0,32,0,3,0,40,0,18,0,17,0,3,0,0,112,-104,0,0,0,-104,0,64,0,-104,0,64,0,24,0,0,0,24,0,0,0,4,0,0,0,8,0,0,0,0,0,0,112,-80,0,0,0,-80,0,64,0,-80,0,64,0,24,0,0,0,24,0,0,0,4,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0,0,0,64,0,0,0,64,0,16,1,0,0,16,1,0,0,5,0,0,0,0,0,1,0,0,0,0,0)), 60 | MockMemoryBlock(name='.MIPS.abiflags', address_range=MockAddressSet(MockAddress(0x400098), MockAddress(0x4000af)).getFirstRange(), data=(0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)), 61 | MockMemoryBlock(name='.reginfo', address_range=MockAddressSet(MockAddress(0x4000b0), MockAddress(0x4000c7)).getFirstRange(), data=(116,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-127,65,0)), 62 | MockMemoryBlock(name='.text', address_range=MockAddressSet(MockAddress(0x4000d0), MockAddress(0x4000ff)).getFirstRange(), data=(64,0,5,60,-92,15,2,36,1,0,4,36,0,1,-91,36,14,0,6,36,12,0,0,0,-95,15,2,36,37,32,0,0,12,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)), 63 | MockMemoryBlock(name='.rodata', address_range=MockAddressSet(MockAddress(0x400100), MockAddress(0x40010f)).getFirstRange(), data=(72,101,108,108,111,44,32,119,111,114,108,100,33,10,0,0)), 64 | ) 65 | # Symbols 66 | symbols = ( 67 | MockSymbol(name='Elf32_Phdr_ARRAY_00400034', fullName='Elf32_Phdr_ARRAY_00400034', address=MockAddress(0x400034), isGlobal=True, references=( 68 | MockReference(from_address=MockAddress(0x40001c), to_address=MockAddress(0x400034), isPrimary=True, operand_index=0, 69 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 70 | )), 71 | MockSymbol(name='DAT_00400098', fullName='DAT_00400098', address=MockAddress(0x400098), isGlobal=True, references=( 72 | MockReference(from_address=MockAddress(0x40003c), to_address=MockAddress(0x400098), isPrimary=True, operand_index=0, 73 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 74 | MockReference(from_address=MockAddress(0x34), to_address=MockAddress(0x400098), isPrimary=True, operand_index=0, 75 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 76 | )), 77 | MockSymbol(name='Elf32_RegInfo_MIPS_004000b0', fullName='Elf32_RegInfo_MIPS_004000b0', address=MockAddress(0x4000b0), isGlobal=True, references=( 78 | MockReference(from_address=MockAddress(0x40005c), to_address=MockAddress(0x4000b0), isPrimary=True, operand_index=0, 79 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 80 | MockReference(from_address=MockAddress(0x5c), to_address=MockAddress(0x4000b0), isPrimary=True, operand_index=0, 81 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 82 | )), 83 | MockSymbol(name='__start', fullName='__start', address=MockAddress(0x4000d0), isGlobal=True, references=( 84 | MockReference(from_address=MockAddress(0x84), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 85 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 86 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4000d0), isPrimary=False, operand_index=-1, 87 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 88 | MockReference(from_address=MockAddress(0x400018), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 89 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 90 | MockReference(from_address=MockAddress(0x18), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 91 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 92 | )), 93 | MockSymbol(name='S_HELLO_WORLD', fullName='S_HELLO_WORLD', address=MockAddress(0x400100), isGlobal=True, references=( 94 | MockReference(from_address=MockAddress(0xac), to_address=MockAddress(0x400100), isPrimary=True, operand_index=0, 95 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 96 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400100), isPrimary=True, operand_index=-1, 97 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 98 | MockReference(from_address=MockAddress(0x4000dc), to_address=MockAddress(0x400100), isPrimary=True, operand_index=0, 99 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 100 | )), 101 | MockSymbol(name='_fdata', fullName='_fdata', address=MockAddress(0x410110), isGlobal=True, references=( 102 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x410110), isPrimary=False, operand_index=-1, 103 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 104 | )), 105 | MockSymbol(name='__bss_start', fullName='__bss_start', address=MockAddress(0x410110), isGlobal=True, references=( 106 | )), 107 | MockSymbol(name='_edata', fullName='_edata', address=MockAddress(0x410110), isGlobal=True, references=( 108 | )), 109 | MockSymbol(name='_end', fullName='_end', address=MockAddress(0x410110), isGlobal=True, references=( 110 | )), 111 | MockSymbol(name='_fbss', fullName='_fbss', address=MockAddress(0x410110), isGlobal=True, references=( 112 | )), 113 | MockSymbol(name='_gp', fullName='_gp', address=MockAddress(0x418100), isGlobal=True, references=( 114 | )), 115 | MockSymbol(name='_mips_gp0_value', fullName='_mips_gp0_value', address=MockAddress(0x418100), isGlobal=True, references=( 116 | )), 117 | MockSymbol(name='s_GCC:_(crosstool-NG_1.24.0)_8.3.0_.comment__00000000', fullName='s_GCC:_(crosstool-NG_1.24.0)_8.3.0_.comment__00000000', address=MockAddress(0x0), isGlobal=True, references=( 118 | MockReference(from_address=MockAddress(0xd4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 119 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 120 | )), 121 | MockSymbol(name='DAT_.debug_abbrev__00000000', fullName='DAT_.debug_abbrev__00000000', address=MockAddress(0x0), isGlobal=True, references=( 122 | MockReference(from_address=MockAddress(0x174), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 123 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 124 | )), 125 | MockSymbol(name='DAT_.debug_aranges__00000000', fullName='DAT_.debug_aranges__00000000', address=MockAddress(0x0), isGlobal=True, references=( 126 | MockReference(from_address=MockAddress(0x124), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 127 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 128 | )), 129 | MockSymbol(name='cie_.debug_frame::00000000', fullName='cie_.debug_frame::00000000', address=MockAddress(0x0), isGlobal=True, references=( 130 | MockReference(from_address=MockAddress(0x1c4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 131 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 132 | MockReference(from_address=MockAddress(0x14), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 133 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 134 | )), 135 | MockSymbol(name='fde_.debug_frame::00000010', fullName='fde_.debug_frame::00000010', address=MockAddress(0x10), isGlobal=True, references=( 136 | )), 137 | MockSymbol(name='DAT_.debug_info__00000000', fullName='DAT_.debug_info__00000000', address=MockAddress(0x0), isGlobal=True, references=( 138 | MockReference(from_address=MockAddress(0x14c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 139 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 140 | )), 141 | MockSymbol(name='DAT_.debug_line__00000000', fullName='DAT_.debug_line__00000000', address=MockAddress(0x0), isGlobal=True, references=( 142 | MockReference(from_address=MockAddress(0x19c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 143 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 144 | )), 145 | MockSymbol(name='s___NR_syscall_.debug_str__00000000', fullName='s___NR_syscall_.debug_str__00000000', address=MockAddress(0x0), isGlobal=True, references=( 146 | MockReference(from_address=MockAddress(0x1ec), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 147 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 148 | )), 149 | MockSymbol(name='DAT_.gnu.attributes__00000000', fullName='DAT_.gnu.attributes__00000000', address=MockAddress(0x0), isGlobal=True, references=( 150 | MockReference(from_address=MockAddress(0x214), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 151 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 152 | )), 153 | MockSymbol(name='DAT_.pdr__00000000', fullName='DAT_.pdr__00000000', address=MockAddress(0x0), isGlobal=True, references=( 154 | MockReference(from_address=MockAddress(0xfc), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 155 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 156 | )), 157 | MockSymbol(name='DAT_.shstrtab__00000000', fullName='DAT_.shstrtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 158 | MockReference(from_address=MockAddress(0x2b4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 159 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 160 | )), 161 | MockSymbol(name='DAT_.strtab__00000000', fullName='DAT_.strtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 162 | MockReference(from_address=MockAddress(0x28c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 163 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 164 | )), 165 | MockSymbol(name='Elf32_Sym_ARRAY_.symtab__00000000', fullName='Elf32_Sym_ARRAY_.symtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 166 | MockReference(from_address=MockAddress(0x264), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 167 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 168 | )), 169 | MockSymbol(name='Elf32_Shdr_ARRAY__elfSectionHeaders__00000000', fullName='Elf32_Shdr_ARRAY__elfSectionHeaders__00000000', address=MockAddress(0x0), isGlobal=True, references=( 170 | MockReference(from_address=MockAddress(0x400020), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 171 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 172 | )), 173 | ) 174 | currentProgram = MockProgram(data=data, functions=functions, memory_blocks=memory_blocks, symbols=symbols) 175 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/testcases/testFlow.py: -------------------------------------------------------------------------------- 1 | # Generated from testFlow.elf 2 | from MockProgram import * 3 | # Data 4 | data = ( 5 | MockData(min_addr=MockAddress(0x400000), max_addr=MockAddress(0x400033)), 6 | MockData(min_addr=MockAddress(0x400034), max_addr=MockAddress(0x400093)), 7 | MockData(min_addr=MockAddress(0x4000b0), max_addr=MockAddress(0x4000c7)), 8 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x20)), 9 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x3)), 10 | MockData(min_addr=MockAddress(0x4), max_addr=MockAddress(0x7)), 11 | MockData(min_addr=MockAddress(0x8), max_addr=MockAddress(0x8)), 12 | MockData(min_addr=MockAddress(0x9), max_addr=MockAddress(0x9)), 13 | MockData(min_addr=MockAddress(0xa), max_addr=MockAddress(0xa)), 14 | MockData(min_addr=MockAddress(0xb), max_addr=MockAddress(0xb)), 15 | MockData(min_addr=MockAddress(0xc), max_addr=MockAddress(0xc)), 16 | MockData(min_addr=MockAddress(0xd), max_addr=MockAddress(0xf)), 17 | MockData(min_addr=MockAddress(0x10), max_addr=MockAddress(0x13)), 18 | MockData(min_addr=MockAddress(0x14), max_addr=MockAddress(0x17)), 19 | MockData(min_addr=MockAddress(0x18), max_addr=MockAddress(0x1b)), 20 | MockData(min_addr=MockAddress(0x1c), max_addr=MockAddress(0x1f)), 21 | MockData(min_addr=MockAddress(0x20), max_addr=MockAddress(0x23)), 22 | MockData(min_addr=MockAddress(0x24), max_addr=MockAddress(0x27)), 23 | MockData(min_addr=MockAddress(0x28), max_addr=MockAddress(0x28)), 24 | MockData(min_addr=MockAddress(0x29), max_addr=MockAddress(0x29)), 25 | MockData(min_addr=MockAddress(0x2a), max_addr=MockAddress(0x2a)), 26 | MockData(min_addr=MockAddress(0x2b), max_addr=MockAddress(0x2b)), 27 | MockData(min_addr=MockAddress(0x2c), max_addr=MockAddress(0x2c)), 28 | MockData(min_addr=MockAddress(0x2d), max_addr=MockAddress(0x2f)), 29 | MockData(min_addr=MockAddress(0x30), max_addr=MockAddress(0x33)), 30 | MockData(min_addr=MockAddress(0x34), max_addr=MockAddress(0x37)), 31 | MockData(min_addr=MockAddress(0x38), max_addr=MockAddress(0x3b)), 32 | MockData(min_addr=MockAddress(0x3c), max_addr=MockAddress(0x3f)), 33 | MockData(min_addr=MockAddress(0x40), max_addr=MockAddress(0x43)), 34 | MockData(min_addr=MockAddress(0x44), max_addr=MockAddress(0x47)), 35 | MockData(min_addr=MockAddress(0x48), max_addr=MockAddress(0x4b)), 36 | MockData(min_addr=MockAddress(0x4c), max_addr=MockAddress(0x4f)), 37 | MockData(min_addr=MockAddress(0x50), max_addr=MockAddress(0x53)), 38 | MockData(min_addr=MockAddress(0x54), max_addr=MockAddress(0x57)), 39 | MockData(min_addr=MockAddress(0x58), max_addr=MockAddress(0x5b)), 40 | MockData(min_addr=MockAddress(0x5c), max_addr=MockAddress(0x5f)), 41 | MockData(min_addr=MockAddress(0x60), max_addr=MockAddress(0x63)), 42 | MockData(min_addr=MockAddress(0x64), max_addr=MockAddress(0x67)), 43 | MockData(min_addr=MockAddress(0x68), max_addr=MockAddress(0x6b)), 44 | MockData(min_addr=MockAddress(0x6c), max_addr=MockAddress(0x6f)), 45 | MockData(min_addr=MockAddress(0x70), max_addr=MockAddress(0x73)), 46 | MockData(min_addr=MockAddress(0x74), max_addr=MockAddress(0x77)), 47 | MockData(min_addr=MockAddress(0x78), max_addr=MockAddress(0x7b)), 48 | MockData(min_addr=MockAddress(0x7c), max_addr=MockAddress(0x7f)), 49 | MockData(min_addr=MockAddress(0x80), max_addr=MockAddress(0x83)), 50 | MockData(min_addr=MockAddress(0x84), max_addr=MockAddress(0x87)), 51 | MockData(min_addr=MockAddress(0x88), max_addr=MockAddress(0x8b)), 52 | MockData(min_addr=MockAddress(0x8c), max_addr=MockAddress(0x8f)), 53 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x7d)), 54 | MockData(min_addr=MockAddress(0x1), max_addr=MockAddress(0x8)), 55 | MockData(min_addr=MockAddress(0x9), max_addr=MockAddress(0x10)), 56 | MockData(min_addr=MockAddress(0x11), max_addr=MockAddress(0x1a)), 57 | MockData(min_addr=MockAddress(0x1b), max_addr=MockAddress(0x29)), 58 | MockData(min_addr=MockAddress(0x2a), max_addr=MockAddress(0x32)), 59 | MockData(min_addr=MockAddress(0x33), max_addr=MockAddress(0x38)), 60 | MockData(min_addr=MockAddress(0x39), max_addr=MockAddress(0x41)), 61 | MockData(min_addr=MockAddress(0x42), max_addr=MockAddress(0x46)), 62 | MockData(min_addr=MockAddress(0x47), max_addr=MockAddress(0x55)), 63 | MockData(min_addr=MockAddress(0x56), max_addr=MockAddress(0x61)), 64 | MockData(min_addr=MockAddress(0x62), max_addr=MockAddress(0x6f)), 65 | MockData(min_addr=MockAddress(0x70), max_addr=MockAddress(0x7b)), 66 | MockData(min_addr=MockAddress(0x7c), max_addr=MockAddress(0x88)), 67 | MockData(min_addr=MockAddress(0x89), max_addr=MockAddress(0x93)), 68 | MockData(min_addr=MockAddress(0x94), max_addr=MockAddress(0xa3)), 69 | MockData(min_addr=MockAddress(0xa4), max_addr=MockAddress(0xb1)), 70 | MockData(min_addr=MockAddress(0x1), max_addr=MockAddress(0x14)), 71 | MockData(min_addr=MockAddress(0x15), max_addr=MockAddress(0x29)), 72 | MockData(min_addr=MockAddress(0x2a), max_addr=MockAddress(0x2d)), 73 | MockData(min_addr=MockAddress(0x2e), max_addr=MockAddress(0x34)), 74 | MockData(min_addr=MockAddress(0x35), max_addr=MockAddress(0x49)), 75 | MockData(min_addr=MockAddress(0x4a), max_addr=MockAddress(0x5c)), 76 | MockData(min_addr=MockAddress(0x5d), max_addr=MockAddress(0x64)), 77 | MockData(min_addr=MockAddress(0x65), max_addr=MockAddress(0x6b)), 78 | MockData(min_addr=MockAddress(0x6c), max_addr=MockAddress(0x87)), 79 | MockData(min_addr=MockAddress(0x88), max_addr=MockAddress(0x93)), 80 | MockData(min_addr=MockAddress(0x94), max_addr=MockAddress(0xa6)), 81 | MockData(min_addr=MockAddress(0xa7), max_addr=MockAddress(0xad)), 82 | MockData(min_addr=MockAddress(0xae), max_addr=MockAddress(0xb2)), 83 | MockData(min_addr=MockAddress(0xb3), max_addr=MockAddress(0xce)), 84 | MockData(min_addr=MockAddress(0xcf), max_addr=MockAddress(0xe7)), 85 | MockData(min_addr=MockAddress(0xe8), max_addr=MockAddress(0xed)), 86 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x1ef)), 87 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x2a7)), 88 | ) 89 | # Functions 90 | functions = ( 91 | MockFunction(name='__start', body=MockAddressSet(MockAddress(0x4000d0), MockAddress(0x4000d7))), 92 | MockFunction(name='testcase_flow_target', body=MockAddressSet(MockAddress(0x4000e0), MockAddress(0x4000e7))), 93 | MockFunction(name='testcase_flow_call', body=MockAddressSet(MockAddress(0x4000e8), MockAddress(0x4000f7))), 94 | MockFunction(name='testcase_flow_call_indirect', body=MockAddressSet(MockAddress(0x4000f8), MockAddress(0x40010f))), 95 | MockFunction(name='testcase_flow_jump', body=MockAddressSet(MockAddress(0x400110), MockAddress(0x400117))), 96 | MockFunction(name='testcase_flow_jump_local', body=MockAddressSet(MockAddress(0x400118), MockAddress(0x400133))), 97 | MockFunction(name='testcase_flow_jump_indirect', body=MockAddressSet(MockAddress(0x400134), MockAddress(0x400143))), 98 | ) 99 | # Memory blocks 100 | memory_blocks = ( 101 | MockMemoryBlock(name='segment_2.1', address_range=MockAddressSet(MockAddress(0x400000), MockAddress(0x400097)).getFirstRange(), data=(127,69,76,70,1,1,1,0,0,0,0,0,0,0,0,0,2,0,8,0,1,0,0,0,-48,0,64,0,52,0,0,0,76,11,0,0,1,16,0,0,52,0,32,0,3,0,40,0,17,0,16,0,3,0,0,112,-104,0,0,0,-104,0,64,0,-104,0,64,0,24,0,0,0,24,0,0,0,4,0,0,0,8,0,0,0,0,0,0,112,-80,0,0,0,-80,0,64,0,-80,0,64,0,24,0,0,0,24,0,0,0,4,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0,0,0,64,0,0,0,64,0,80,1,0,0,80,1,0,0,5,0,0,0,0,0,1,0,0,0,0,0)), 102 | MockMemoryBlock(name='.MIPS.abiflags', address_range=MockAddressSet(MockAddress(0x400098), MockAddress(0x4000af)).getFirstRange(), data=(0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)), 103 | MockMemoryBlock(name='.reginfo', address_range=MockAddressSet(MockAddress(0x4000b0), MockAddress(0x4000c7)).getFirstRange(), data=(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,-127,65,0)), 104 | MockMemoryBlock(name='.text', address_range=MockAddressSet(MockAddress(0x4000d0), MockAddress(0x40014f)).getFirstRange(), data=(-1,-1,0,16,0,0,0,0,0,0,0,0,0,0,0,0,8,0,-32,3,0,0,0,0,56,0,16,12,0,0,0,0,8,0,-32,3,0,0,0,0,64,0,2,60,-32,0,66,36,9,-8,64,0,0,0,0,0,8,0,-32,3,0,0,0,0,56,0,16,8,0,0,0,0,3,0,-124,16,0,0,0,0,75,0,16,8,33,32,-124,0,33,48,-58,0,8,0,-32,3,33,40,-91,0,64,0,2,60,-32,0,66,36,8,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)), 105 | ) 106 | # Symbols 107 | symbols = ( 108 | MockSymbol(name='Elf32_Phdr_ARRAY_00400034', fullName='Elf32_Phdr_ARRAY_00400034', address=MockAddress(0x400034), isGlobal=True, references=( 109 | MockReference(from_address=MockAddress(0x40001c), to_address=MockAddress(0x400034), isPrimary=True, operand_index=0, 110 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 111 | )), 112 | MockSymbol(name='DAT_00400098', fullName='DAT_00400098', address=MockAddress(0x400098), isGlobal=True, references=( 113 | MockReference(from_address=MockAddress(0x40003c), to_address=MockAddress(0x400098), isPrimary=True, operand_index=0, 114 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 115 | MockReference(from_address=MockAddress(0x34), to_address=MockAddress(0x400098), isPrimary=True, operand_index=0, 116 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 117 | )), 118 | MockSymbol(name='Elf32_RegInfo_MIPS_004000b0', fullName='Elf32_RegInfo_MIPS_004000b0', address=MockAddress(0x4000b0), isGlobal=True, references=( 119 | MockReference(from_address=MockAddress(0x40005c), to_address=MockAddress(0x4000b0), isPrimary=True, operand_index=0, 120 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 121 | MockReference(from_address=MockAddress(0x5c), to_address=MockAddress(0x4000b0), isPrimary=True, operand_index=0, 122 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 123 | )), 124 | MockSymbol(name='__start', fullName='__start', address=MockAddress(0x4000d0), isGlobal=True, references=( 125 | MockReference(from_address=MockAddress(0x84), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 126 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 127 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4000d0), isPrimary=False, operand_index=-1, 128 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 129 | MockReference(from_address=MockAddress(0x400018), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 130 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 131 | MockReference(from_address=MockAddress(0x18), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 132 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 133 | MockReference(from_address=MockAddress(0x4000d0), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 134 | reftype=MockRefType('UNCONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 135 | )), 136 | MockSymbol(name='testcase_flow_target', fullName='testcase_flow_target', address=MockAddress(0x4000e0), isGlobal=True, references=( 137 | MockReference(from_address=MockAddress(0x400110), to_address=MockAddress(0x4000e0), isPrimary=False, operand_index=-2, 138 | reftype=MockRefType('THUNK', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 139 | MockReference(from_address=MockAddress(0x400134), to_address=MockAddress(0x4000e0), isPrimary=False, operand_index=-2, 140 | reftype=MockRefType('THUNK', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 141 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4000e0), isPrimary=False, operand_index=-1, 142 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 143 | MockReference(from_address=MockAddress(0x38), to_address=MockAddress(0x4000e0), isPrimary=True, operand_index=0, 144 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 145 | MockReference(from_address=MockAddress(0x4000e8), to_address=MockAddress(0x4000e0), isPrimary=True, operand_index=0, 146 | reftype=MockRefType('UNCONDITIONAL_CALL', isCall=True, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 147 | MockReference(from_address=MockAddress(0x400110), to_address=MockAddress(0x4000e0), isPrimary=True, operand_index=0, 148 | reftype=MockRefType('UNCONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 149 | MockReference(from_address=MockAddress(0x40013c), to_address=MockAddress(0x4000e0), isPrimary=True, operand_index=0, 150 | reftype=MockRefType('COMPUTED_CALL', isCall=True, isComputed=True, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 151 | MockReference(from_address=MockAddress(0x400100), to_address=MockAddress(0x4000e0), isPrimary=True, operand_index=0, 152 | reftype=MockRefType('COMPUTED_CALL', isCall=True, isComputed=True, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 153 | )), 154 | MockSymbol(name='testcase_flow_call', fullName='testcase_flow_call', address=MockAddress(0x4000e8), isGlobal=True, references=( 155 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4000e8), isPrimary=False, operand_index=-1, 156 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 157 | MockReference(from_address=MockAddress(0x48), to_address=MockAddress(0x4000e8), isPrimary=True, operand_index=0, 158 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 159 | )), 160 | MockSymbol(name='testcase_flow_call_indirect', fullName='testcase_flow_call_indirect', address=MockAddress(0x4000f8), isGlobal=True, references=( 161 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4000f8), isPrimary=False, operand_index=-1, 162 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 163 | MockReference(from_address=MockAddress(0x58), to_address=MockAddress(0x4000f8), isPrimary=True, operand_index=0, 164 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 165 | )), 166 | MockSymbol(name='testcase_flow_jump', fullName='testcase_flow_jump', address=MockAddress(0x400110), isGlobal=True, references=( 167 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400110), isPrimary=False, operand_index=-1, 168 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 169 | MockReference(from_address=MockAddress(0x68), to_address=MockAddress(0x400110), isPrimary=True, operand_index=0, 170 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 171 | )), 172 | MockSymbol(name='testcase_flow_jump_local', fullName='testcase_flow_jump_local', address=MockAddress(0x400118), isGlobal=True, references=( 173 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400118), isPrimary=False, operand_index=-1, 174 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 175 | MockReference(from_address=MockAddress(0x78), to_address=MockAddress(0x400118), isPrimary=True, operand_index=0, 176 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 177 | )), 178 | MockSymbol(name='LAB_00400128', fullName='LAB_00400128', address=MockAddress(0x400128), isGlobal=True, references=( 179 | MockReference(from_address=MockAddress(0x400118), to_address=MockAddress(0x400128), isPrimary=True, operand_index=2, 180 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 181 | )), 182 | MockSymbol(name='LAB_0040012c', fullName='LAB_0040012c', address=MockAddress(0x40012c), isGlobal=True, references=( 183 | MockReference(from_address=MockAddress(0x400120), to_address=MockAddress(0x40012c), isPrimary=True, operand_index=0, 184 | reftype=MockRefType('UNCONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 185 | )), 186 | MockSymbol(name='testcase_flow_jump_indirect', fullName='testcase_flow_jump_indirect', address=MockAddress(0x400134), isGlobal=True, references=( 187 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400134), isPrimary=False, operand_index=-1, 188 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 189 | MockReference(from_address=MockAddress(0x88), to_address=MockAddress(0x400134), isPrimary=True, operand_index=0, 190 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 191 | )), 192 | MockSymbol(name='_fdata', fullName='_fdata', address=MockAddress(0x410150), isGlobal=True, references=( 193 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x410150), isPrimary=True, operand_index=-1, 194 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 195 | )), 196 | MockSymbol(name='__bss_start', fullName='__bss_start', address=MockAddress(0x410150), isGlobal=True, references=( 197 | )), 198 | MockSymbol(name='_edata', fullName='_edata', address=MockAddress(0x410150), isGlobal=True, references=( 199 | )), 200 | MockSymbol(name='_end', fullName='_end', address=MockAddress(0x410150), isGlobal=True, references=( 201 | )), 202 | MockSymbol(name='_fbss', fullName='_fbss', address=MockAddress(0x410150), isGlobal=True, references=( 203 | )), 204 | MockSymbol(name='_gp', fullName='_gp', address=MockAddress(0x418140), isGlobal=True, references=( 205 | )), 206 | MockSymbol(name='_mips_gp0_value', fullName='_mips_gp0_value', address=MockAddress(0x418140), isGlobal=True, references=( 207 | )), 208 | MockSymbol(name='s_GCC:_(crosstool-NG_1.24.0)_8.3.0_.comment__00000000', fullName='s_GCC:_(crosstool-NG_1.24.0)_8.3.0_.comment__00000000', address=MockAddress(0x0), isGlobal=True, references=( 209 | MockReference(from_address=MockAddress(0xac), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 210 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 211 | )), 212 | MockSymbol(name='DAT_.debug_abbrev__00000000', fullName='DAT_.debug_abbrev__00000000', address=MockAddress(0x0), isGlobal=True, references=( 213 | MockReference(from_address=MockAddress(0x14c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 214 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 215 | )), 216 | MockSymbol(name='DAT_.debug_aranges__00000000', fullName='DAT_.debug_aranges__00000000', address=MockAddress(0x0), isGlobal=True, references=( 217 | MockReference(from_address=MockAddress(0xfc), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 218 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 219 | )), 220 | MockSymbol(name='cie_.debug_frame::00000000', fullName='cie_.debug_frame::00000000', address=MockAddress(0x0), isGlobal=True, references=( 221 | MockReference(from_address=MockAddress(0x19c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 222 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 223 | MockReference(from_address=MockAddress(0x14), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 224 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 225 | )), 226 | MockSymbol(name='fde_.debug_frame::00000010', fullName='fde_.debug_frame::00000010', address=MockAddress(0x10), isGlobal=True, references=( 227 | )), 228 | MockSymbol(name='cie_.debug_frame::00000020', fullName='cie_.debug_frame::00000020', address=MockAddress(0x20), isGlobal=True, references=( 229 | MockReference(from_address=MockAddress(0x34), to_address=MockAddress(0x20), isPrimary=True, operand_index=0, 230 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 231 | MockReference(from_address=MockAddress(0x44), to_address=MockAddress(0x20), isPrimary=True, operand_index=0, 232 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 233 | MockReference(from_address=MockAddress(0x54), to_address=MockAddress(0x20), isPrimary=True, operand_index=0, 234 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 235 | MockReference(from_address=MockAddress(0x64), to_address=MockAddress(0x20), isPrimary=True, operand_index=0, 236 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 237 | MockReference(from_address=MockAddress(0x74), to_address=MockAddress(0x20), isPrimary=True, operand_index=0, 238 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 239 | MockReference(from_address=MockAddress(0x84), to_address=MockAddress(0x20), isPrimary=True, operand_index=0, 240 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 241 | )), 242 | MockSymbol(name='fde_.debug_frame::00000030', fullName='fde_.debug_frame::00000030', address=MockAddress(0x30), isGlobal=True, references=( 243 | )), 244 | MockSymbol(name='fde_.debug_frame::00000040', fullName='fde_.debug_frame::00000040', address=MockAddress(0x40), isGlobal=True, references=( 245 | )), 246 | MockSymbol(name='fde_.debug_frame::00000050', fullName='fde_.debug_frame::00000050', address=MockAddress(0x50), isGlobal=True, references=( 247 | )), 248 | MockSymbol(name='fde_.debug_frame::00000060', fullName='fde_.debug_frame::00000060', address=MockAddress(0x60), isGlobal=True, references=( 249 | )), 250 | MockSymbol(name='fde_.debug_frame::00000070', fullName='fde_.debug_frame::00000070', address=MockAddress(0x70), isGlobal=True, references=( 251 | )), 252 | MockSymbol(name='fde_.debug_frame::00000080', fullName='fde_.debug_frame::00000080', address=MockAddress(0x80), isGlobal=True, references=( 253 | )), 254 | MockSymbol(name='DAT_.debug_info__00000000', fullName='DAT_.debug_info__00000000', address=MockAddress(0x0), isGlobal=True, references=( 255 | MockReference(from_address=MockAddress(0x124), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 256 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 257 | )), 258 | MockSymbol(name='DAT_.debug_line__00000000', fullName='DAT_.debug_line__00000000', address=MockAddress(0x0), isGlobal=True, references=( 259 | MockReference(from_address=MockAddress(0x174), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 260 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 261 | )), 262 | MockSymbol(name='s_GNU_C17_8.3.0_-mel_-mno-abicalls_.debug_str__00000000', fullName='s_GNU_C17_8.3.0_-mel_-mno-abicalls_.debug_str__00000000', address=MockAddress(0x0), isGlobal=True, references=( 263 | MockReference(from_address=MockAddress(0x1c4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 264 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 265 | )), 266 | MockSymbol(name='DAT_.gnu.attributes__00000000', fullName='DAT_.gnu.attributes__00000000', address=MockAddress(0x0), isGlobal=True, references=( 267 | MockReference(from_address=MockAddress(0x1ec), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 268 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 269 | )), 270 | MockSymbol(name='DAT_.pdr__00000000', fullName='DAT_.pdr__00000000', address=MockAddress(0x0), isGlobal=True, references=( 271 | MockReference(from_address=MockAddress(0xd4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 272 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 273 | )), 274 | MockSymbol(name='DAT_.shstrtab__00000000', fullName='DAT_.shstrtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 275 | MockReference(from_address=MockAddress(0x28c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 276 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 277 | )), 278 | MockSymbol(name='DAT_.strtab__00000000', fullName='DAT_.strtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 279 | MockReference(from_address=MockAddress(0x264), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 280 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 281 | )), 282 | MockSymbol(name='Elf32_Sym_ARRAY_.symtab__00000000', fullName='Elf32_Sym_ARRAY_.symtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 283 | MockReference(from_address=MockAddress(0x23c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 284 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 285 | )), 286 | MockSymbol(name='Elf32_Shdr_ARRAY__elfSectionHeaders__00000000', fullName='Elf32_Shdr_ARRAY__elfSectionHeaders__00000000', address=MockAddress(0x0), isGlobal=True, references=( 287 | MockReference(from_address=MockAddress(0x400020), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 288 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 289 | )), 290 | ) 291 | currentProgram = MockProgram(data=data, functions=functions, memory_blocks=memory_blocks, symbols=symbols) 292 | -------------------------------------------------------------------------------- /tests/reference/libunlinker/mips32el/linux/asciiTable.py: -------------------------------------------------------------------------------- 1 | # Generated from asciiTable.elf 2 | from MockProgram import * 3 | # Data 4 | data = ( 5 | MockData(min_addr=MockAddress(0x400000), max_addr=MockAddress(0x400033)), 6 | MockData(min_addr=MockAddress(0x400034), max_addr=MockAddress(0x400093)), 7 | MockData(min_addr=MockAddress(0x4000b0), max_addr=MockAddress(0x4000c7)), 8 | MockData(min_addr=MockAddress(0x400490), max_addr=MockAddress(0x4004e7)), 9 | MockData(min_addr=MockAddress(0x4004f0), max_addr=MockAddress(0x4005f0)), 10 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x20)), 11 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x3)), 12 | MockData(min_addr=MockAddress(0x4), max_addr=MockAddress(0x7)), 13 | MockData(min_addr=MockAddress(0x8), max_addr=MockAddress(0x8)), 14 | MockData(min_addr=MockAddress(0x9), max_addr=MockAddress(0x9)), 15 | MockData(min_addr=MockAddress(0xa), max_addr=MockAddress(0xa)), 16 | MockData(min_addr=MockAddress(0xb), max_addr=MockAddress(0xb)), 17 | MockData(min_addr=MockAddress(0xc), max_addr=MockAddress(0xc)), 18 | MockData(min_addr=MockAddress(0xd), max_addr=MockAddress(0xf)), 19 | MockData(min_addr=MockAddress(0x10), max_addr=MockAddress(0x13)), 20 | MockData(min_addr=MockAddress(0x14), max_addr=MockAddress(0x17)), 21 | MockData(min_addr=MockAddress(0x18), max_addr=MockAddress(0x1b)), 22 | MockData(min_addr=MockAddress(0x1c), max_addr=MockAddress(0x1f)), 23 | MockData(min_addr=MockAddress(0x20), max_addr=MockAddress(0x37)), 24 | MockData(min_addr=MockAddress(0x38), max_addr=MockAddress(0x3b)), 25 | MockData(min_addr=MockAddress(0x3c), max_addr=MockAddress(0x3f)), 26 | MockData(min_addr=MockAddress(0x40), max_addr=MockAddress(0x43)), 27 | MockData(min_addr=MockAddress(0x44), max_addr=MockAddress(0x47)), 28 | MockData(min_addr=MockAddress(0x48), max_addr=MockAddress(0x5b)), 29 | MockData(min_addr=MockAddress(0x5c), max_addr=MockAddress(0x5f)), 30 | MockData(min_addr=MockAddress(0x60), max_addr=MockAddress(0x63)), 31 | MockData(min_addr=MockAddress(0x64), max_addr=MockAddress(0x64)), 32 | MockData(min_addr=MockAddress(0x65), max_addr=MockAddress(0x65)), 33 | MockData(min_addr=MockAddress(0x66), max_addr=MockAddress(0x66)), 34 | MockData(min_addr=MockAddress(0x67), max_addr=MockAddress(0x67)), 35 | MockData(min_addr=MockAddress(0x68), max_addr=MockAddress(0x68)), 36 | MockData(min_addr=MockAddress(0x69), max_addr=MockAddress(0x6b)), 37 | MockData(min_addr=MockAddress(0x6c), max_addr=MockAddress(0x6f)), 38 | MockData(min_addr=MockAddress(0x70), max_addr=MockAddress(0x73)), 39 | MockData(min_addr=MockAddress(0x74), max_addr=MockAddress(0x77)), 40 | MockData(min_addr=MockAddress(0x78), max_addr=MockAddress(0x7b)), 41 | MockData(min_addr=MockAddress(0x7c), max_addr=MockAddress(0x7f)), 42 | MockData(min_addr=MockAddress(0x80), max_addr=MockAddress(0x83)), 43 | MockData(min_addr=MockAddress(0x84), max_addr=MockAddress(0x87)), 44 | MockData(min_addr=MockAddress(0x88), max_addr=MockAddress(0x8b)), 45 | MockData(min_addr=MockAddress(0x8c), max_addr=MockAddress(0x8f)), 46 | MockData(min_addr=MockAddress(0x90), max_addr=MockAddress(0x93)), 47 | MockData(min_addr=MockAddress(0x94), max_addr=MockAddress(0x97)), 48 | MockData(min_addr=MockAddress(0x98), max_addr=MockAddress(0x9b)), 49 | MockData(min_addr=MockAddress(0x9c), max_addr=MockAddress(0x9f)), 50 | MockData(min_addr=MockAddress(0xa0), max_addr=MockAddress(0xa3)), 51 | MockData(min_addr=MockAddress(0xa4), max_addr=MockAddress(0xa7)), 52 | MockData(min_addr=MockAddress(0xa8), max_addr=MockAddress(0xab)), 53 | MockData(min_addr=MockAddress(0xac), max_addr=MockAddress(0xaf)), 54 | MockData(min_addr=MockAddress(0xb0), max_addr=MockAddress(0xb3)), 55 | MockData(min_addr=MockAddress(0xb4), max_addr=MockAddress(0xb7)), 56 | MockData(min_addr=MockAddress(0xb8), max_addr=MockAddress(0xbb)), 57 | MockData(min_addr=MockAddress(0xbc), max_addr=MockAddress(0xbf)), 58 | MockData(min_addr=MockAddress(0xc0), max_addr=MockAddress(0xc3)), 59 | MockData(min_addr=MockAddress(0xc4), max_addr=MockAddress(0xc7)), 60 | MockData(min_addr=MockAddress(0xc8), max_addr=MockAddress(0xcb)), 61 | MockData(min_addr=MockAddress(0xcc), max_addr=MockAddress(0xcf)), 62 | MockData(min_addr=MockAddress(0xd0), max_addr=MockAddress(0xd3)), 63 | MockData(min_addr=MockAddress(0xd4), max_addr=MockAddress(0xd7)), 64 | MockData(min_addr=MockAddress(0xd8), max_addr=MockAddress(0xdb)), 65 | MockData(min_addr=MockAddress(0xdc), max_addr=MockAddress(0xdf)), 66 | MockData(min_addr=MockAddress(0xe0), max_addr=MockAddress(0xe3)), 67 | MockData(min_addr=MockAddress(0xe4), max_addr=MockAddress(0xe7)), 68 | MockData(min_addr=MockAddress(0xe8), max_addr=MockAddress(0xeb)), 69 | MockData(min_addr=MockAddress(0xec), max_addr=MockAddress(0xef)), 70 | MockData(min_addr=MockAddress(0xf0), max_addr=MockAddress(0xf3)), 71 | MockData(min_addr=MockAddress(0xf4), max_addr=MockAddress(0xf7)), 72 | MockData(min_addr=MockAddress(0xf8), max_addr=MockAddress(0xfb)), 73 | MockData(min_addr=MockAddress(0xfc), max_addr=MockAddress(0xff)), 74 | MockData(min_addr=MockAddress(0x100), max_addr=MockAddress(0x103)), 75 | MockData(min_addr=MockAddress(0x104), max_addr=MockAddress(0x107)), 76 | MockData(min_addr=MockAddress(0x108), max_addr=MockAddress(0x10b)), 77 | MockData(min_addr=MockAddress(0x10c), max_addr=MockAddress(0x10f)), 78 | MockData(min_addr=MockAddress(0x110), max_addr=MockAddress(0x113)), 79 | MockData(min_addr=MockAddress(0x114), max_addr=MockAddress(0x117)), 80 | MockData(min_addr=MockAddress(0x118), max_addr=MockAddress(0x11b)), 81 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0xc)), 82 | MockData(min_addr=MockAddress(0x1), max_addr=MockAddress(0x8)), 83 | MockData(min_addr=MockAddress(0x9), max_addr=MockAddress(0x10)), 84 | MockData(min_addr=MockAddress(0x11), max_addr=MockAddress(0x1a)), 85 | MockData(min_addr=MockAddress(0x1b), max_addr=MockAddress(0x29)), 86 | MockData(min_addr=MockAddress(0x2a), max_addr=MockAddress(0x32)), 87 | MockData(min_addr=MockAddress(0x33), max_addr=MockAddress(0x38)), 88 | MockData(min_addr=MockAddress(0x39), max_addr=MockAddress(0x40)), 89 | MockData(min_addr=MockAddress(0x41), max_addr=MockAddress(0x49)), 90 | MockData(min_addr=MockAddress(0x4a), max_addr=MockAddress(0x4e)), 91 | MockData(min_addr=MockAddress(0x4f), max_addr=MockAddress(0x5d)), 92 | MockData(min_addr=MockAddress(0x5e), max_addr=MockAddress(0x69)), 93 | MockData(min_addr=MockAddress(0x6a), max_addr=MockAddress(0x77)), 94 | MockData(min_addr=MockAddress(0x78), max_addr=MockAddress(0x83)), 95 | MockData(min_addr=MockAddress(0x84), max_addr=MockAddress(0x90)), 96 | MockData(min_addr=MockAddress(0x91), max_addr=MockAddress(0x9b)), 97 | MockData(min_addr=MockAddress(0x9c), max_addr=MockAddress(0xa6)), 98 | MockData(min_addr=MockAddress(0xa7), max_addr=MockAddress(0xb4)), 99 | MockData(min_addr=MockAddress(0xb5), max_addr=MockAddress(0xc4)), 100 | MockData(min_addr=MockAddress(0xc5), max_addr=MockAddress(0xd2)), 101 | MockData(min_addr=MockAddress(0x1), max_addr=MockAddress(0x13)), 102 | MockData(min_addr=MockAddress(0x14), max_addr=MockAddress(0x21)), 103 | MockData(min_addr=MockAddress(0x22), max_addr=MockAddress(0x25)), 104 | MockData(min_addr=MockAddress(0x26), max_addr=MockAddress(0x38)), 105 | MockData(min_addr=MockAddress(0x39), max_addr=MockAddress(0x3f)), 106 | MockData(min_addr=MockAddress(0x40), max_addr=MockAddress(0x47)), 107 | MockData(min_addr=MockAddress(0x48), max_addr=MockAddress(0x4f)), 108 | MockData(min_addr=MockAddress(0x50), max_addr=MockAddress(0x57)), 109 | MockData(min_addr=MockAddress(0x58), max_addr=MockAddress(0x60)), 110 | MockData(min_addr=MockAddress(0x61), max_addr=MockAddress(0x68)), 111 | MockData(min_addr=MockAddress(0x69), max_addr=MockAddress(0x75)), 112 | MockData(min_addr=MockAddress(0x76), max_addr=MockAddress(0x7c)), 113 | MockData(min_addr=MockAddress(0x7d), max_addr=MockAddress(0x84)), 114 | MockData(min_addr=MockAddress(0x85), max_addr=MockAddress(0x8c)), 115 | MockData(min_addr=MockAddress(0x8d), max_addr=MockAddress(0x98)), 116 | MockData(min_addr=MockAddress(0x99), max_addr=MockAddress(0xa0)), 117 | MockData(min_addr=MockAddress(0xa1), max_addr=MockAddress(0xa8)), 118 | MockData(min_addr=MockAddress(0xa9), max_addr=MockAddress(0xb0)), 119 | MockData(min_addr=MockAddress(0xb1), max_addr=MockAddress(0xb8)), 120 | MockData(min_addr=MockAddress(0xb9), max_addr=MockAddress(0xbf)), 121 | MockData(min_addr=MockAddress(0xc0), max_addr=MockAddress(0xc4)), 122 | MockData(min_addr=MockAddress(0xc5), max_addr=MockAddress(0xcc)), 123 | MockData(min_addr=MockAddress(0xcd), max_addr=MockAddress(0xd4)), 124 | MockData(min_addr=MockAddress(0xd5), max_addr=MockAddress(0xda)), 125 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x29f)), 126 | MockData(min_addr=MockAddress(0x0), max_addr=MockAddress(0x31f)), 127 | ) 128 | # Functions 129 | functions = ( 130 | MockFunction(name='print_number', body=MockAddressSet(MockAddress(0x4000d0), MockAddress(0x40015b))), 131 | MockFunction(name='__start', body=MockAddressSet(MockAddress(0x40015c), MockAddress(0x400277))), 132 | MockFunction(name='isalnum', body=MockAddressSet(MockAddress(0x400280), MockAddress(0x4002af))), 133 | MockFunction(name='isalpha', body=MockAddressSet(MockAddress(0x4002b0), MockAddress(0x4002df))), 134 | MockFunction(name='iscntrl', body=MockAddressSet(MockAddress(0x4002e0), MockAddress(0x40030f))), 135 | MockFunction(name='isdigit', body=MockAddressSet(MockAddress(0x400310), MockAddress(0x40033f))), 136 | MockFunction(name='isgraph', body=MockAddressSet(MockAddress(0x400340), MockAddress(0x40036f))), 137 | MockFunction(name='islower', body=MockAddressSet(MockAddress(0x400370), MockAddress(0x40039f))), 138 | MockFunction(name='isprint', body=MockAddressSet(MockAddress(0x4003a0), MockAddress(0x4003cf))), 139 | MockFunction(name='ispunct', body=MockAddressSet(MockAddress(0x4003d0), MockAddress(0x4003ff))), 140 | MockFunction(name='isspace', body=MockAddressSet(MockAddress(0x400400), MockAddress(0x40042f))), 141 | MockFunction(name='isupper', body=MockAddressSet(MockAddress(0x400430), MockAddress(0x40045f))), 142 | MockFunction(name='isxdigit', body=MockAddressSet(MockAddress(0x400460), MockAddress(0x40048f))), 143 | ) 144 | # Memory blocks 145 | memory_blocks = ( 146 | MockMemoryBlock(name='segment_2.1', address_range=MockAddressSet(MockAddress(0x400000), MockAddress(0x400097)).getFirstRange(), data=(127,69,76,70,1,1,1,0,0,0,0,0,0,0,0,0,2,0,8,0,1,0,0,0,92,1,64,0,52,0,0,0,-8,32,0,0,1,16,0,0,52,0,32,0,3,0,40,0,20,0,19,0,3,0,0,112,-104,0,0,0,-104,0,64,0,-104,0,64,0,24,0,0,0,24,0,0,0,4,0,0,0,8,0,0,0,0,0,0,112,-80,0,0,0,-80,0,64,0,-80,0,64,0,24,0,0,0,24,0,0,0,4,0,0,0,4,0,0,0,1,0,0,0,0,0,0,0,0,0,64,0,0,0,64,0,0,6,0,0,0,6,0,0,5,0,0,0,0,0,1,0,0,0,0,0)), 147 | MockMemoryBlock(name='.MIPS.abiflags', address_range=MockAddressSet(MockAddress(0x400098), MockAddress(0x4000af)).getFirstRange(), data=(0,0,1,0,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)), 148 | MockMemoryBlock(name='.reginfo', address_range=MockAddressSet(MockAddress(0x4000b0), MockAddress(0x4000c7)).getFirstRange(), data=(116,0,127,-96,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-16,-123,65,0)), 149 | MockMemoryBlock(name='.text', address_range=MockAddressSet(MockAddress(0x4000d0), MockAddress(0x40048f)).getFirstRange(), data=(-24,-1,-67,39,48,0,2,36,37,40,-96,3,20,0,-77,-81,0,0,-94,-93,37,-104,-128,0,16,0,-78,-81,12,0,-79,-81,8,0,-80,-81,-92,15,2,36,1,0,4,36,1,0,6,36,12,0,0,0,6,0,16,36,8,0,17,36,-3,-1,18,36,7,16,19,2,26,0,81,0,1,0,4,36,37,40,-96,3,1,0,6,36,16,16,0,0,48,0,66,36,0,0,-94,-93,-92,15,2,36,12,0,0,0,-3,-1,16,38,-11,-1,18,22,7,16,19,2,20,0,-77,-113,16,0,-78,-113,12,0,-79,-113,8,0,-80,-113,8,0,-32,3,24,0,-67,39,-56,-1,-67,39,44,0,-75,-81,40,0,-76,-81,36,0,-77,-81,32,0,-78,-81,24,0,-80,-81,52,0,-65,-81,48,0,-74,-81,28,0,-79,-81,37,-128,0,0,32,0,18,36,64,0,21,60,10,0,20,36,-128,0,19,36,52,0,16,12,37,32,0,2,16,0,-78,-93,-92,15,2,36,1,0,4,36,16,0,-91,39,1,0,6,36,12,0,0,0,-48,0,16,12,37,32,0,2,42,0,64,16,0,0,0,0,16,0,-80,-93,-92,15,2,36,1,0,4,36,16,0,-91,39,1,0,6,36,12,0,0,0,-92,15,2,36,16,0,-78,-93,1,0,4,36,16,0,-91,39,1,0,6,36,12,0,0,0,-112,4,-79,38,88,0,54,38,0,0,34,-114,0,0,0,0,9,-8,64,0,37,32,0,2,24,0,64,16,0,0,0,0,4,0,34,-110,0,0,0,0,16,0,-94,-93,-92,15,2,36,1,0,4,36,16,0,-91,39,1,0,6,36,12,0,0,0,8,0,49,38,-16,-1,-47,22,-92,15,2,36,16,0,-76,-93,1,0,4,36,16,0,-91,39,1,0,6,36,12,0,0,0,1,0,16,38,-50,-1,19,22,-95,15,2,36,37,32,0,0,12,0,0,0,-41,-1,0,16,16,0,-78,-93,-21,-1,0,16,16,0,-78,-93,0,0,0,0,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,7,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,3,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,32,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,4,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,23,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,2,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-128,0,0,0,0,-105,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,16,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,8,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,1,0,66,48,8,0,-32,3,0,0,0,0,-1,-1,3,36,8,0,-125,16,37,16,0,0,64,0,2,60,-15,4,66,36,-1,0,-124,48,33,32,-126,0,0,0,-126,-112,0,0,0,0,68,0,66,48,8,0,-32,3,0,0,0,0)), 150 | MockMemoryBlock(name='.rodata', address_range=MockAddressSet(MockAddress(0x400490), MockAddress(0x4005ff)).getFirstRange(), data=(64,3,64,0,103,0,0,0,-96,3,64,0,112,0,0,0,-32,2,64,0,99,0,0,0,0,4,64,0,115,0,0,0,-48,3,64,0,33,0,0,0,-128,2,64,0,65,0,0,0,-80,2,64,0,97,0,0,0,16,3,64,0,100,0,0,0,96,4,64,0,120,0,0,0,48,4,64,0,85,0,0,0,112,3,64,0,108,0,0,0,0,0,0,0,0,0,0,0,0,32,32,32,32,32,32,32,32,32,40,40,40,40,40,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,-120,16,16,16,16,16,16,16,16,16,16,16,16,16,16,16,4,4,4,4,4,4,4,4,4,4,16,16,16,16,16,16,16,65,65,65,65,65,65,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,16,16,16,16,16,16,66,66,66,66,66,66,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,16,16,16,16,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)), 151 | ) 152 | # Symbols 153 | symbols = ( 154 | MockSymbol(name='Elf32_Phdr_ARRAY_00400034', fullName='Elf32_Phdr_ARRAY_00400034', address=MockAddress(0x400034), isGlobal=True, references=( 155 | MockReference(from_address=MockAddress(0x40001c), to_address=MockAddress(0x400034), isPrimary=True, operand_index=0, 156 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 157 | )), 158 | MockSymbol(name='DAT_00400098', fullName='DAT_00400098', address=MockAddress(0x400098), isGlobal=True, references=( 159 | MockReference(from_address=MockAddress(0x40003c), to_address=MockAddress(0x400098), isPrimary=True, operand_index=0, 160 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 161 | MockReference(from_address=MockAddress(0x34), to_address=MockAddress(0x400098), isPrimary=True, operand_index=0, 162 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 163 | )), 164 | MockSymbol(name='Elf32_RegInfo_MIPS_004000b0', fullName='Elf32_RegInfo_MIPS_004000b0', address=MockAddress(0x4000b0), isGlobal=True, references=( 165 | MockReference(from_address=MockAddress(0x40005c), to_address=MockAddress(0x4000b0), isPrimary=True, operand_index=0, 166 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 167 | MockReference(from_address=MockAddress(0x5c), to_address=MockAddress(0x4000b0), isPrimary=True, operand_index=0, 168 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 169 | )), 170 | MockSymbol(name='print_number', fullName='print_number', address=MockAddress(0x4000d0), isGlobal=True, references=( 171 | MockReference(from_address=MockAddress(0x84), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 172 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 173 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4000d0), isPrimary=False, operand_index=-1, 174 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 175 | MockReference(from_address=MockAddress(0x18), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 176 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 177 | MockReference(from_address=MockAddress(0x400194), to_address=MockAddress(0x4000d0), isPrimary=True, operand_index=0, 178 | reftype=MockRefType('UNCONDITIONAL_CALL', isCall=True, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 179 | )), 180 | MockSymbol(name='LAB_00400114', fullName='LAB_00400114', address=MockAddress(0x400114), isGlobal=True, references=( 181 | MockReference(from_address=MockAddress(0x40013c), to_address=MockAddress(0x400114), isPrimary=True, operand_index=2, 182 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 183 | )), 184 | MockSymbol(name='__start', fullName='__start', address=MockAddress(0x40015c), isGlobal=True, references=( 185 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x40015c), isPrimary=False, operand_index=-1, 186 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 187 | MockReference(from_address=MockAddress(0x400018), to_address=MockAddress(0x40015c), isPrimary=True, operand_index=0, 188 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 189 | MockReference(from_address=MockAddress(0x40), to_address=MockAddress(0x40015c), isPrimary=True, operand_index=0, 190 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 191 | )), 192 | MockSymbol(name='LAB_00400194', fullName='LAB_00400194', address=MockAddress(0x400194), isGlobal=True, references=( 193 | MockReference(from_address=MockAddress(0x400258), to_address=MockAddress(0x400194), isPrimary=True, operand_index=2, 194 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 195 | )), 196 | MockSymbol(name='LAB_004001c8', fullName='LAB_004001c8', address=MockAddress(0x4001c8), isGlobal=True, references=( 197 | MockReference(from_address=MockAddress(0x400268), to_address=MockAddress(0x4001c8), isPrimary=True, operand_index=0, 198 | reftype=MockRefType('UNCONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 199 | )), 200 | MockSymbol(name='LAB_004001fc', fullName='LAB_004001fc', address=MockAddress(0x4001fc), isGlobal=True, references=( 201 | MockReference(from_address=MockAddress(0x400238), to_address=MockAddress(0x4001fc), isPrimary=True, operand_index=2, 202 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 203 | )), 204 | MockSymbol(name='LAB_00400220', fullName='LAB_00400220', address=MockAddress(0x400220), isGlobal=True, references=( 205 | MockReference(from_address=MockAddress(0x400270), to_address=MockAddress(0x400220), isPrimary=True, operand_index=0, 206 | reftype=MockRefType('UNCONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 207 | )), 208 | MockSymbol(name='LAB_00400268', fullName='LAB_00400268', address=MockAddress(0x400268), isGlobal=True, references=( 209 | MockReference(from_address=MockAddress(0x4001bc), to_address=MockAddress(0x400268), isPrimary=True, operand_index=2, 210 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 211 | )), 212 | MockSymbol(name='LAB_00400270', fullName='LAB_00400270', address=MockAddress(0x400270), isGlobal=True, references=( 213 | MockReference(from_address=MockAddress(0x40020c), to_address=MockAddress(0x400270), isPrimary=True, operand_index=2, 214 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 215 | )), 216 | MockSymbol(name='isalnum', fullName='isalnum', address=MockAddress(0x400280), isGlobal=True, references=( 217 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400280), isPrimary=False, operand_index=-1, 218 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 219 | MockReference(from_address=MockAddress(0x4004b8), to_address=MockAddress(0x400280), isPrimary=True, operand_index=0, 220 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 221 | MockReference(from_address=MockAddress(0x74), to_address=MockAddress(0x400280), isPrimary=True, operand_index=0, 222 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 223 | )), 224 | MockSymbol(name='LAB_004002a8', fullName='LAB_004002a8', address=MockAddress(0x4002a8), isGlobal=True, references=( 225 | MockReference(from_address=MockAddress(0x400284), to_address=MockAddress(0x4002a8), isPrimary=True, operand_index=2, 226 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 227 | )), 228 | MockSymbol(name='isalpha', fullName='isalpha', address=MockAddress(0x4002b0), isGlobal=True, references=( 229 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4002b0), isPrimary=False, operand_index=-1, 230 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 231 | MockReference(from_address=MockAddress(0x4004c0), to_address=MockAddress(0x4002b0), isPrimary=True, operand_index=0, 232 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 233 | MockReference(from_address=MockAddress(0x84), to_address=MockAddress(0x4002b0), isPrimary=True, operand_index=0, 234 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 235 | )), 236 | MockSymbol(name='LAB_004002d8', fullName='LAB_004002d8', address=MockAddress(0x4002d8), isGlobal=True, references=( 237 | MockReference(from_address=MockAddress(0x4002b4), to_address=MockAddress(0x4002d8), isPrimary=True, operand_index=2, 238 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 239 | )), 240 | MockSymbol(name='iscntrl', fullName='iscntrl', address=MockAddress(0x4002e0), isGlobal=True, references=( 241 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4002e0), isPrimary=False, operand_index=-1, 242 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 243 | MockReference(from_address=MockAddress(0x4004a0), to_address=MockAddress(0x4002e0), isPrimary=True, operand_index=0, 244 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 245 | MockReference(from_address=MockAddress(0x94), to_address=MockAddress(0x4002e0), isPrimary=True, operand_index=0, 246 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 247 | )), 248 | MockSymbol(name='LAB_00400308', fullName='LAB_00400308', address=MockAddress(0x400308), isGlobal=True, references=( 249 | MockReference(from_address=MockAddress(0x4002e4), to_address=MockAddress(0x400308), isPrimary=True, operand_index=2, 250 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 251 | )), 252 | MockSymbol(name='isdigit', fullName='isdigit', address=MockAddress(0x400310), isGlobal=True, references=( 253 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400310), isPrimary=False, operand_index=-1, 254 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 255 | MockReference(from_address=MockAddress(0x4004c8), to_address=MockAddress(0x400310), isPrimary=True, operand_index=0, 256 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 257 | MockReference(from_address=MockAddress(0xa4), to_address=MockAddress(0x400310), isPrimary=True, operand_index=0, 258 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 259 | )), 260 | MockSymbol(name='LAB_00400338', fullName='LAB_00400338', address=MockAddress(0x400338), isGlobal=True, references=( 261 | MockReference(from_address=MockAddress(0x400314), to_address=MockAddress(0x400338), isPrimary=True, operand_index=2, 262 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 263 | )), 264 | MockSymbol(name='isgraph', fullName='isgraph', address=MockAddress(0x400340), isGlobal=True, references=( 265 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400340), isPrimary=False, operand_index=-1, 266 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 267 | MockReference(from_address=MockAddress(0x400490), to_address=MockAddress(0x400340), isPrimary=True, operand_index=0, 268 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 269 | MockReference(from_address=MockAddress(0xb4), to_address=MockAddress(0x400340), isPrimary=True, operand_index=0, 270 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 271 | MockReference(from_address=MockAddress(0x4001b4), to_address=MockAddress(0x400340), isPrimary=True, operand_index=0, 272 | reftype=MockRefType('UNCONDITIONAL_CALL', isCall=True, isComputed=False, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 273 | MockReference(from_address=MockAddress(0x400204), to_address=MockAddress(0x400340), isPrimary=True, operand_index=0, 274 | reftype=MockRefType('COMPUTED_CALL', isCall=True, isComputed=True, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 275 | )), 276 | MockSymbol(name='LAB_00400368', fullName='LAB_00400368', address=MockAddress(0x400368), isGlobal=True, references=( 277 | MockReference(from_address=MockAddress(0x400344), to_address=MockAddress(0x400368), isPrimary=True, operand_index=2, 278 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 279 | )), 280 | MockSymbol(name='islower', fullName='islower', address=MockAddress(0x400370), isGlobal=True, references=( 281 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400370), isPrimary=False, operand_index=-1, 282 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 283 | MockReference(from_address=MockAddress(0x4004e0), to_address=MockAddress(0x400370), isPrimary=True, operand_index=0, 284 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 285 | MockReference(from_address=MockAddress(0xc4), to_address=MockAddress(0x400370), isPrimary=True, operand_index=0, 286 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 287 | )), 288 | MockSymbol(name='LAB_00400398', fullName='LAB_00400398', address=MockAddress(0x400398), isGlobal=True, references=( 289 | MockReference(from_address=MockAddress(0x400374), to_address=MockAddress(0x400398), isPrimary=True, operand_index=2, 290 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 291 | )), 292 | MockSymbol(name='isprint', fullName='isprint', address=MockAddress(0x4003a0), isGlobal=True, references=( 293 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4003a0), isPrimary=False, operand_index=-1, 294 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 295 | MockReference(from_address=MockAddress(0x400498), to_address=MockAddress(0x4003a0), isPrimary=True, operand_index=0, 296 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 297 | MockReference(from_address=MockAddress(0xd4), to_address=MockAddress(0x4003a0), isPrimary=True, operand_index=0, 298 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 299 | MockReference(from_address=MockAddress(0x400204), to_address=MockAddress(0x4003a0), isPrimary=False, operand_index=0, 300 | reftype=MockRefType('COMPUTED_CALL', isCall=True, isComputed=True, isConditional=False, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 301 | )), 302 | MockSymbol(name='LAB_004003c8', fullName='LAB_004003c8', address=MockAddress(0x4003c8), isGlobal=True, references=( 303 | MockReference(from_address=MockAddress(0x4003a4), to_address=MockAddress(0x4003c8), isPrimary=True, operand_index=2, 304 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 305 | )), 306 | MockSymbol(name='ispunct', fullName='ispunct', address=MockAddress(0x4003d0), isGlobal=True, references=( 307 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4003d0), isPrimary=False, operand_index=-1, 308 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 309 | MockReference(from_address=MockAddress(0x4004b0), to_address=MockAddress(0x4003d0), isPrimary=True, operand_index=0, 310 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 311 | MockReference(from_address=MockAddress(0xe4), to_address=MockAddress(0x4003d0), isPrimary=True, operand_index=0, 312 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 313 | )), 314 | MockSymbol(name='LAB_004003f8', fullName='LAB_004003f8', address=MockAddress(0x4003f8), isGlobal=True, references=( 315 | MockReference(from_address=MockAddress(0x4003d4), to_address=MockAddress(0x4003f8), isPrimary=True, operand_index=2, 316 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 317 | )), 318 | MockSymbol(name='isspace', fullName='isspace', address=MockAddress(0x400400), isGlobal=True, references=( 319 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400400), isPrimary=False, operand_index=-1, 320 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 321 | MockReference(from_address=MockAddress(0x4004a8), to_address=MockAddress(0x400400), isPrimary=True, operand_index=0, 322 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 323 | MockReference(from_address=MockAddress(0xf4), to_address=MockAddress(0x400400), isPrimary=True, operand_index=0, 324 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 325 | )), 326 | MockSymbol(name='LAB_00400428', fullName='LAB_00400428', address=MockAddress(0x400428), isGlobal=True, references=( 327 | MockReference(from_address=MockAddress(0x400404), to_address=MockAddress(0x400428), isPrimary=True, operand_index=2, 328 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 329 | )), 330 | MockSymbol(name='isupper', fullName='isupper', address=MockAddress(0x400430), isGlobal=True, references=( 331 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400430), isPrimary=False, operand_index=-1, 332 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 333 | MockReference(from_address=MockAddress(0x4004d8), to_address=MockAddress(0x400430), isPrimary=True, operand_index=0, 334 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 335 | MockReference(from_address=MockAddress(0x104), to_address=MockAddress(0x400430), isPrimary=True, operand_index=0, 336 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 337 | )), 338 | MockSymbol(name='LAB_00400458', fullName='LAB_00400458', address=MockAddress(0x400458), isGlobal=True, references=( 339 | MockReference(from_address=MockAddress(0x400434), to_address=MockAddress(0x400458), isPrimary=True, operand_index=2, 340 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 341 | )), 342 | MockSymbol(name='isxdigit', fullName='isxdigit', address=MockAddress(0x400460), isGlobal=True, references=( 343 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400460), isPrimary=False, operand_index=-1, 344 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 345 | MockReference(from_address=MockAddress(0x4004d0), to_address=MockAddress(0x400460), isPrimary=True, operand_index=0, 346 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 347 | MockReference(from_address=MockAddress(0x114), to_address=MockAddress(0x400460), isPrimary=True, operand_index=0, 348 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 349 | )), 350 | MockSymbol(name='LAB_00400488', fullName='LAB_00400488', address=MockAddress(0x400488), isGlobal=True, references=( 351 | MockReference(from_address=MockAddress(0x400464), to_address=MockAddress(0x400488), isPrimary=True, operand_index=2, 352 | reftype=MockRefType('CONDITIONAL_JUMP', isCall=False, isComputed=False, isConditional=True, isData=False, isFallthrough=False, isFlow=True, isIndirect=False, isJump=True, isOverride=False, isRead=False, isTerminal=False, isUnConditional=False, isWrite=False)), 353 | )), 354 | MockSymbol(name='s_ascii_properties', fullName='s_ascii_properties', address=MockAddress(0x400490), isGlobal=True, references=( 355 | MockReference(from_address=MockAddress(0xac), to_address=MockAddress(0x400490), isPrimary=True, operand_index=0, 356 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 357 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x400490), isPrimary=True, operand_index=-1, 358 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 359 | MockReference(from_address=MockAddress(0x4001fc), to_address=MockAddress(0x400490), isPrimary=True, operand_index=1, 360 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 361 | )), 362 | MockSymbol(name='s_ascii_properties[0].flag', fullName='s_ascii_properties[0].flag', address=MockAddress(0x400494), isGlobal=True, references=( 363 | MockReference(from_address=MockAddress(0x400214), to_address=MockAddress(0x400494), isPrimary=True, operand_index=1, 364 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 365 | )), 366 | MockSymbol(name='s_ascii_properties[1].func', fullName='s_ascii_properties[1].func', address=MockAddress(0x400498), isGlobal=True, references=( 367 | MockReference(from_address=MockAddress(0x4001fc), to_address=MockAddress(0x400498), isPrimary=False, operand_index=1, 368 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 369 | )), 370 | MockSymbol(name='_ctype_', fullName='_ctype_', address=MockAddress(0x4004f0), isGlobal=True, references=( 371 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x4004f0), isPrimary=False, operand_index=-1, 372 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 373 | )), 374 | MockSymbol(name='_ctype_[1]', fullName='_ctype_[1]', address=MockAddress(0x4004f1), isGlobal=True, references=( 375 | MockReference(from_address=MockAddress(0x4002cc), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 376 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 377 | MockReference(from_address=MockAddress(0x40032c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 378 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 379 | MockReference(from_address=MockAddress(0x40038c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 380 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 381 | MockReference(from_address=MockAddress(0x4003ec), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 382 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 383 | MockReference(from_address=MockAddress(0x40044c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 384 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 385 | MockReference(from_address=MockAddress(0x40029c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 386 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 387 | MockReference(from_address=MockAddress(0x4002fc), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 388 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 389 | MockReference(from_address=MockAddress(0x40035c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 390 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 391 | MockReference(from_address=MockAddress(0x4003bc), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 392 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 393 | MockReference(from_address=MockAddress(0x40041c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 394 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 395 | MockReference(from_address=MockAddress(0x40047c), to_address=MockAddress(0x4004f1), isPrimary=True, operand_index=0, 396 | reftype=MockRefType('READ', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=True, isTerminal=False, isUnConditional=True, isWrite=False)), 397 | )), 398 | MockSymbol(name='_fdata', fullName='_fdata', address=MockAddress(0x410600), isGlobal=True, references=( 399 | MockReference(from_address=MockAddress(0x0), to_address=MockAddress(0x410600), isPrimary=False, operand_index=-1, 400 | reftype=MockRefType('EXTERNAL', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 401 | )), 402 | MockSymbol(name='__bss_start', fullName='__bss_start', address=MockAddress(0x410600), isGlobal=True, references=( 403 | )), 404 | MockSymbol(name='_edata', fullName='_edata', address=MockAddress(0x410600), isGlobal=True, references=( 405 | )), 406 | MockSymbol(name='_end', fullName='_end', address=MockAddress(0x410600), isGlobal=True, references=( 407 | )), 408 | MockSymbol(name='_fbss', fullName='_fbss', address=MockAddress(0x410600), isGlobal=True, references=( 409 | )), 410 | MockSymbol(name='_gp', fullName='_gp', address=MockAddress(0x4185f0), isGlobal=True, references=( 411 | )), 412 | MockSymbol(name='_mips_gp0_value', fullName='_mips_gp0_value', address=MockAddress(0x4185f0), isGlobal=True, references=( 413 | )), 414 | MockSymbol(name='s_GCC:_(crosstool-NG_1.24.0)_8.3.0_.comment__00000000', fullName='s_GCC:_(crosstool-NG_1.24.0)_8.3.0_.comment__00000000', address=MockAddress(0x0), isGlobal=True, references=( 415 | MockReference(from_address=MockAddress(0xd4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 416 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 417 | )), 418 | MockSymbol(name='DAT_.debug_abbrev__00000000', fullName='DAT_.debug_abbrev__00000000', address=MockAddress(0x0), isGlobal=True, references=( 419 | MockReference(from_address=MockAddress(0x174), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 420 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 421 | )), 422 | MockSymbol(name='DAT_.debug_aranges__00000000', fullName='DAT_.debug_aranges__00000000', address=MockAddress(0x0), isGlobal=True, references=( 423 | MockReference(from_address=MockAddress(0x124), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 424 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 425 | )), 426 | MockSymbol(name='cie_.debug_frame::00000000', fullName='cie_.debug_frame::00000000', address=MockAddress(0x0), isGlobal=True, references=( 427 | MockReference(from_address=MockAddress(0x1c4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 428 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 429 | MockReference(from_address=MockAddress(0x14), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 430 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 431 | MockReference(from_address=MockAddress(0x3c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 432 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 433 | )), 434 | MockSymbol(name='fde_.debug_frame::00000010', fullName='fde_.debug_frame::00000010', address=MockAddress(0x10), isGlobal=True, references=( 435 | )), 436 | MockSymbol(name='fde_.debug_frame::00000038', fullName='fde_.debug_frame::00000038', address=MockAddress(0x38), isGlobal=True, references=( 437 | )), 438 | MockSymbol(name='cie_.debug_frame::0000005c', fullName='cie_.debug_frame::0000005c', address=MockAddress(0x5c), isGlobal=True, references=( 439 | MockReference(from_address=MockAddress(0x70), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 440 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 441 | MockReference(from_address=MockAddress(0x80), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 442 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 443 | MockReference(from_address=MockAddress(0x90), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 444 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 445 | MockReference(from_address=MockAddress(0xa0), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 446 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 447 | MockReference(from_address=MockAddress(0xb0), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 448 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 449 | MockReference(from_address=MockAddress(0xc0), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 450 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 451 | MockReference(from_address=MockAddress(0xd0), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 452 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 453 | MockReference(from_address=MockAddress(0xe0), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 454 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 455 | MockReference(from_address=MockAddress(0xf0), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 456 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 457 | MockReference(from_address=MockAddress(0x100), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 458 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 459 | MockReference(from_address=MockAddress(0x110), to_address=MockAddress(0x5c), isPrimary=True, operand_index=0, 460 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 461 | )), 462 | MockSymbol(name='fde_.debug_frame::0000006c', fullName='fde_.debug_frame::0000006c', address=MockAddress(0x6c), isGlobal=True, references=( 463 | )), 464 | MockSymbol(name='fde_.debug_frame::0000007c', fullName='fde_.debug_frame::0000007c', address=MockAddress(0x7c), isGlobal=True, references=( 465 | )), 466 | MockSymbol(name='fde_.debug_frame::0000008c', fullName='fde_.debug_frame::0000008c', address=MockAddress(0x8c), isGlobal=True, references=( 467 | )), 468 | MockSymbol(name='fde_.debug_frame::0000009c', fullName='fde_.debug_frame::0000009c', address=MockAddress(0x9c), isGlobal=True, references=( 469 | )), 470 | MockSymbol(name='fde_.debug_frame::000000ac', fullName='fde_.debug_frame::000000ac', address=MockAddress(0xac), isGlobal=True, references=( 471 | )), 472 | MockSymbol(name='fde_.debug_frame::000000bc', fullName='fde_.debug_frame::000000bc', address=MockAddress(0xbc), isGlobal=True, references=( 473 | )), 474 | MockSymbol(name='fde_.debug_frame::000000cc', fullName='fde_.debug_frame::000000cc', address=MockAddress(0xcc), isGlobal=True, references=( 475 | )), 476 | MockSymbol(name='fde_.debug_frame::000000dc', fullName='fde_.debug_frame::000000dc', address=MockAddress(0xdc), isGlobal=True, references=( 477 | )), 478 | MockSymbol(name='fde_.debug_frame::000000ec', fullName='fde_.debug_frame::000000ec', address=MockAddress(0xec), isGlobal=True, references=( 479 | )), 480 | MockSymbol(name='fde_.debug_frame::000000fc', fullName='fde_.debug_frame::000000fc', address=MockAddress(0xfc), isGlobal=True, references=( 481 | )), 482 | MockSymbol(name='fde_.debug_frame::0000010c', fullName='fde_.debug_frame::0000010c', address=MockAddress(0x10c), isGlobal=True, references=( 483 | )), 484 | MockSymbol(name='DAT_.debug_info__00000000', fullName='DAT_.debug_info__00000000', address=MockAddress(0x0), isGlobal=True, references=( 485 | MockReference(from_address=MockAddress(0x14c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 486 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 487 | )), 488 | MockSymbol(name='DAT_.debug_line__00000000', fullName='DAT_.debug_line__00000000', address=MockAddress(0x0), isGlobal=True, references=( 489 | MockReference(from_address=MockAddress(0x19c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 490 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 491 | )), 492 | MockSymbol(name='DAT_.debug_loc__00000000', fullName='DAT_.debug_loc__00000000', address=MockAddress(0x0), isGlobal=True, references=( 493 | MockReference(from_address=MockAddress(0x214), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 494 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 495 | )), 496 | MockSymbol(name='DAT_.debug_ranges__00000000', fullName='DAT_.debug_ranges__00000000', address=MockAddress(0x0), isGlobal=True, references=( 497 | MockReference(from_address=MockAddress(0x23c), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 498 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 499 | )), 500 | MockSymbol(name='s_unsigned_int_.debug_str__00000000', fullName='s_unsigned_int_.debug_str__00000000', address=MockAddress(0x0), isGlobal=True, references=( 501 | MockReference(from_address=MockAddress(0x1ec), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 502 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 503 | )), 504 | MockSymbol(name='DAT_.gnu.attributes__00000000', fullName='DAT_.gnu.attributes__00000000', address=MockAddress(0x0), isGlobal=True, references=( 505 | MockReference(from_address=MockAddress(0x264), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 506 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 507 | )), 508 | MockSymbol(name='DAT_.pdr__00000000', fullName='DAT_.pdr__00000000', address=MockAddress(0x0), isGlobal=True, references=( 509 | MockReference(from_address=MockAddress(0xfc), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 510 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 511 | )), 512 | MockSymbol(name='DAT_.shstrtab__00000000', fullName='DAT_.shstrtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 513 | MockReference(from_address=MockAddress(0x304), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 514 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 515 | )), 516 | MockSymbol(name='DAT_.strtab__00000000', fullName='DAT_.strtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 517 | MockReference(from_address=MockAddress(0x2dc), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 518 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 519 | )), 520 | MockSymbol(name='Elf32_Sym_ARRAY_.symtab__00000000', fullName='Elf32_Sym_ARRAY_.symtab__00000000', address=MockAddress(0x0), isGlobal=True, references=( 521 | MockReference(from_address=MockAddress(0x2b4), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 522 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 523 | )), 524 | MockSymbol(name='Elf32_Shdr_ARRAY__elfSectionHeaders__00000000', fullName='Elf32_Shdr_ARRAY__elfSectionHeaders__00000000', address=MockAddress(0x0), isGlobal=True, references=( 525 | MockReference(from_address=MockAddress(0x400020), to_address=MockAddress(0x0), isPrimary=True, operand_index=0, 526 | reftype=MockRefType('DATA', isCall=False, isComputed=False, isConditional=False, isData=True, isFallthrough=False, isFlow=False, isIndirect=False, isJump=False, isOverride=False, isRead=False, isTerminal=False, isUnConditional=True, isWrite=False)), 527 | )), 528 | ) 529 | currentProgram = MockProgram(data=data, functions=functions, memory_blocks=memory_blocks, symbols=symbols) 530 | --------------------------------------------------------------------------------