├── Codes ├── assembly │ ├── 6502 │ │ └── README.md │ ├── README.md │ ├── arm │ │ └── README.md │ ├── avr │ │ └── README.md │ ├── m68k │ │ └── README.md │ ├── mips │ │ └── README.md │ ├── powerpc │ │ └── README.md │ ├── x86 │ │ ├── README.md │ │ ├── interrupt-vector.md │ │ ├── nasm │ │ │ ├── 00.structure │ │ │ │ ├── 0.structure.asm │ │ │ │ ├── 1.structure2.asm │ │ │ │ ├── 2.segment.asm │ │ │ │ ├── 3.custom-section.asm │ │ │ │ ├── 4.instruction.asm │ │ │ │ ├── 5.inclusion.asm │ │ │ │ ├── 6.namespace.asm │ │ │ │ ├── 7a.section-ext-elf.asm │ │ │ │ ├── 7b.section-ext-pe.asm │ │ │ │ ├── external.inc │ │ │ │ └── instr.inc │ │ │ ├── 01.declaration │ │ │ │ ├── 0.define-data.asm │ │ │ │ ├── 1.reserve-space.asm │ │ │ │ ├── 2.constants.asm │ │ │ │ ├── 3.strings.asm │ │ │ │ ├── 4.floats.asm │ │ │ │ └── file.txt │ │ │ ├── 02.signs │ │ │ │ └── 0.signness.asm │ │ │ ├── 03.data-movement │ │ │ │ ├── 0.addressing-modes.asm │ │ │ │ ├── 1.immediate.asm │ │ │ │ ├── 2.register.asm │ │ │ │ └── 3.memory.asm │ │ │ ├── 04.arithmetic │ │ │ │ ├── 0.signed.asm │ │ │ │ └── 1.unsigned.asm │ │ │ ├── 05.bitwise │ │ │ │ ├── 0.logic.asm │ │ │ │ ├── 1.shift.asm │ │ │ │ ├── 2.rotate.asm │ │ │ │ ├── 3.flags.asm │ │ │ │ ├── 4.bit-test.asm │ │ │ │ ├── 5.scan.asm │ │ │ │ └── 6.bswap.asm │ │ │ ├── 06.conditional │ │ │ │ ├── 0.comparison.asm │ │ │ │ ├── 1.jump.asm │ │ │ │ └── 2.move.asm │ │ │ ├── 07.branching │ │ │ │ ├── 0.if.asm │ │ │ │ ├── 1.if-else.asm │ │ │ │ ├── 2.multi-if.asm │ │ │ │ ├── 3.complex-condition.asm │ │ │ │ ├── 4.jump-table.asm │ │ │ │ └── 5.nested-if.asm │ │ │ ├── 08.loop │ │ │ │ ├── 0.repeat.asm │ │ │ │ ├── 1.loop.asm │ │ │ │ ├── 2.do-while.asm │ │ │ │ ├── 3.while.asm │ │ │ │ └── 4.for.asm │ │ │ ├── 09.subroutine │ │ │ │ ├── 0.stack.asm │ │ │ │ ├── 1.declare.asm │ │ │ │ ├── 10.sysv-abi-conv.asm │ │ │ │ ├── 2.args.asm │ │ │ │ ├── 3.recursive.asm │ │ │ │ ├── 4.cdecl-conv.asm │ │ │ │ ├── 5.stdcall-conv.asm │ │ │ │ ├── 6.fastcall-conv.asm │ │ │ │ ├── 7.pascal-conv.asm │ │ │ │ ├── 8.optlink-conv.asm │ │ │ │ └── 9.ms-x64-conv.asm │ │ │ ├── 10.macro │ │ │ │ ├── 0.single.asm │ │ │ │ ├── 1.multi.asm │ │ │ │ └── 2.param-range.asm │ │ │ ├── 11.user-datatype │ │ │ │ └── 0.struc.asm │ │ │ ├── 12.mmx │ │ │ │ ├── 0.feature-check.asm │ │ │ │ ├── 1.data-movement.asm │ │ │ │ ├── 2.arithmetic.asm │ │ │ │ ├── 3.bitwise.asm │ │ │ │ └── 4.comparison.asm │ │ │ ├── 13.os-specific │ │ │ │ ├── linux │ │ │ │ │ ├── cetak.c │ │ │ │ │ ├── hello-32b.asm │ │ │ │ │ ├── hello-64b.asm │ │ │ │ │ ├── hello-extern.asm │ │ │ │ │ ├── hello-syscall32.asm │ │ │ │ │ └── hello-syscall64.asm │ │ │ │ └── windows │ │ │ │ │ ├── cetak.c │ │ │ │ │ ├── hello-32b.asm │ │ │ │ │ ├── hello-64b.asm │ │ │ │ │ ├── hello-extern.asm │ │ │ │ │ ├── hello-win32.asm │ │ │ │ │ └── hello-win64.asm │ │ │ └── README.md │ │ └── platform.md │ ├── xtensa │ │ └── README.md │ └── z80 │ │ └── README.md ├── bytecode │ ├── README.md │ ├── dalvik │ │ └── README.md │ ├── jvm │ │ └── README.md │ ├── net │ │ ├── README.md │ │ └── cil │ │ │ ├── 00.structure │ │ │ ├── 0.module.il │ │ │ ├── 1.class.il │ │ │ ├── 2.method.il │ │ │ ├── 3.instruction.il │ │ │ ├── 4.vars.il │ │ │ └── 5.stack.il │ │ │ ├── 01.type │ │ │ ├── 0.integer.il │ │ │ ├── 1.float.il │ │ │ ├── 2.string.il │ │ │ ├── 3.array.il │ │ │ ├── 4.structure.il │ │ │ ├── 5.enum.il │ │ │ ├── 6.pointer.il │ │ │ ├── 7.object.il │ │ │ └── 8.conversion.il │ │ │ ├── 02.operation │ │ │ ├── 0.arithmetic.il │ │ │ ├── 1.bitwise.il │ │ │ ├── 2.branching.il │ │ │ ├── 3.comparison.il │ │ │ ├── decision │ │ │ │ ├── complex-condition.il │ │ │ │ ├── if-else.il │ │ │ │ ├── if.il │ │ │ │ ├── multi-if.il │ │ │ │ ├── nested-if.il │ │ │ │ └── switch.il │ │ │ └── loop │ │ │ │ ├── do-while.il │ │ │ │ ├── for.il │ │ │ │ └── while.il │ │ │ ├── 03.method │ │ │ ├── 0.call.il │ │ │ ├── 1.param.il │ │ │ ├── 2.retval.il │ │ │ ├── 3.vararg.il │ │ │ └── 4.pointer.il │ │ │ ├── 04.object │ │ │ ├── inheritance │ │ │ │ ├── 0.class.il │ │ │ │ ├── 1.interface.il │ │ │ │ ├── 2.check.il │ │ │ │ └── 3.castclass.il │ │ │ └── structure │ │ │ │ ├── 1.nested.il │ │ │ │ ├── 2.method-overload.il │ │ │ │ └── 3.operator-overload.il │ │ │ ├── 05.exception │ │ │ ├── 0.exception.il │ │ │ ├── 1.throw.il │ │ │ ├── 2.finally.il │ │ │ └── 3.defined.il │ │ │ └── 06.features │ │ │ └── pinvoke.il │ ├── php │ │ └── README.md │ ├── python │ │ └── README.md │ ├── ruby │ │ └── README.md │ ├── swift │ │ └── README.md │ ├── vm.md │ └── web-asm │ │ └── README.md ├── control-flows.md ├── interrupt-exception.md ├── ir-code │ ├── README.md │ ├── llvm │ │ ├── README.md │ │ ├── _layout.md │ │ ├── _pass.md │ │ ├── _tools.md │ │ └── ir │ │ │ ├── 00.structure │ │ │ ├── 0.module.ll │ │ │ ├── 1.function.ll │ │ │ ├── 2.basic-block.ll │ │ │ └── 3.instruction.ll │ │ │ ├── 01.type │ │ │ ├── 0.identifier.ll │ │ │ ├── 1.integer.ll │ │ │ ├── 2.float.ll │ │ │ ├── 3.array.ll │ │ │ ├── 4.string.ll │ │ │ ├── 5.function.ll │ │ │ ├── 6.structure.ll │ │ │ ├── 7.pointer.ll │ │ │ ├── 8.vector.ll │ │ │ └── 9.conversion.ll │ │ │ ├── 02.operation │ │ │ ├── bitwise.ll │ │ │ ├── branching.ll │ │ │ ├── comparison.ll │ │ │ ├── decision │ │ │ │ ├── complex-condition.ll │ │ │ │ ├── if-else.ll │ │ │ │ ├── if.ll │ │ │ │ ├── multi-if.ll │ │ │ │ ├── nested-if.ll │ │ │ │ └── switch.ll │ │ │ ├── loop │ │ │ │ ├── do-while.ll │ │ │ │ ├── for.ll │ │ │ │ └── while.ll │ │ │ ├── memory.ll │ │ │ ├── phi.ll │ │ │ └── select.ll │ │ │ ├── 03.subroutine │ │ │ ├── 0.call.ll │ │ │ ├── 1.param.ll │ │ │ ├── 2.retval.ll │ │ │ ├── 3.vararg.ll │ │ │ ├── 4.private.ll │ │ │ └── 5.calling-convention.ll │ │ │ └── 04.object │ │ │ ├── 0.class.ll │ │ │ ├── 1.method.ll │ │ │ ├── 2.inheritence.ll │ │ │ └── 3.multi-inheritance.ll │ ├── qemu │ │ └── README.md │ ├── radare2 │ │ └── README.md │ ├── soot │ │ └── README.md │ └── valgrind │ │ └── README.md └── numeric-system.md ├── README.md └── Tools └── ir-code └── llvm ├── anvill.md ├── bin2llvm.md ├── dagger.md ├── fcd.md ├── fracture.md ├── hikari.md ├── klee.md ├── llvm-mctoll.md ├── mcsema.md ├── noctilucence.md ├── obfuscator-llvm.md ├── qbdi.md ├── rellic.md ├── remill.md ├── reopt.md ├── retdec.md ├── rev.ng.md └── revgen.md /Codes/assembly/6502/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for 6502 processor assembly 4 | 5 | ## Assembler Vendor 6 | 7 | - k2asm 8 | - vasm 9 | -------------------------------------------------------------------------------- /Codes/assembly/arm/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for ARM processor assembly 4 | 5 | ## Assembler Vendor 6 | 7 | - fasmarm (Flat Assembler ARM) 8 | - gas (GNU Assembler) 9 | - vasm -------------------------------------------------------------------------------- /Codes/assembly/avr/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for AVR processor assembly 4 | 5 | ## Assembler Vendor 6 | 7 | - avrasm2 (AVR Assembler) 8 | - gas (GNU Assembler) -------------------------------------------------------------------------------- /Codes/assembly/m68k/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for m68k processor assembly. 4 | 5 | ## Assembler Vendor 6 | 7 | - vasm 8 | -------------------------------------------------------------------------------- /Codes/assembly/mips/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for MIPS processor assembly. 4 | 5 | ## Simulator Vendor 6 | 7 | - mars (MIPS Assembler and Runtime Simulator) 8 | - spim -------------------------------------------------------------------------------- /Codes/assembly/powerpc/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for PowerPC processor assembly. 4 | 5 | ## Assembler Vendor 6 | 7 | - gas (GNU Assembler) 8 | - vasm -------------------------------------------------------------------------------- /Codes/assembly/x86/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for x86 processor assembly. 4 | 5 | ## Assembler Vendor 6 | 7 | - fasm (Flat Assembler) 8 | - gas (GNU Assembler) 9 | - masm (Microsoft Macro Assembler) 10 | - nasm (Netwide Assembler) 11 | - yasm (Yet Another Assembler) -------------------------------------------------------------------------------- /Codes/assembly/x86/interrupt-vector.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | x86 Interrupt Vector 4 | 5 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/2.segment.asm: -------------------------------------------------------------------------------- 1 | ; segment.asm 2 | ; 3 | ; Memory segmentation 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o segment.o segment.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o segment.o segment.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o segment segment.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o segment segment.o 18 | ; 19 | ; Note: 20 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 21 | ; sebagai sebuah program. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | ;----------------------------------------------------------------------------- 26 | ; Segmented memory model membagi system memory ke beberapa bagian independen 27 | ; yang disebut sebagai segment. Segment dapat dirujuk (reference) melalui 28 | ; segment register. Setiap segment digunakan untuk menyimpan komponen spesifik 29 | ; seperti data, kode, stack, dsb. 30 | ; 31 | ; Segment dan section saling berkaitan erat namun bukan merupakan istilah sama. 32 | ; Section mengindikasikan section di object file atau executable. Section merupakan 33 | ; petunjuk bagi OS untuk memuat (load) komponen penting ke posisi yang sesuai. 34 | ; Sementara segment adalah area memori yang tercipta saat runtime dan dipesan 35 | ; untuk kebutuhan khusus. 36 | ; 37 | ; Segmentation dapat diimplementasikan dengan atau tanpa paging. 38 | ;----------------------------------------------------------------------------- 39 | 40 | global _start 41 | 42 | ; Data segment 43 | ; Direpresentasikan dengan section .data dan .bss 44 | ; Lihat juga contoh deklarasi lainnya di 'declaration' 45 | 46 | section .data 47 | immutable_data: db 10 48 | 49 | section .bss 50 | mutable_data: resb 1 51 | 52 | 53 | ; Code segment 54 | ; Direpresentasikan dengan section .text 55 | 56 | section .text 57 | _start: 58 | 59 | hlt ; Hentikan eksekusi 60 | 61 | 62 | ; Stack segment 63 | ; Diciptakan oleh OS dan tidak direpresentasikan oleh section apapun. 64 | ; Segment ini berisi data temporer, nilai yang diberikan ke function atau procedure 65 | ; pada program. -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/3.custom-section.asm: -------------------------------------------------------------------------------- 1 | ; custom-section.asm 2 | ; 3 | ; NASM mendukung custom section. 4 | ; Mendeklarasikan custom-section, mengisinya, dan merujuk dari manapun. 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o custom-section.o custom-section.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o custom-section.o custom-section.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o custom-section custom-section.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o custom-section custom-section.o 19 | ; 20 | ; Note: 21 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 22 | ; sebagai sebuah program. 23 | ; 24 | ; Gunakan viewer untuk melihat sections pada executable header. 25 | ; 26 | ;----------------------------------------------------------------------------- 27 | 28 | global _start 29 | 30 | ; Konstanta 31 | MAGIC equ 0xBADBABE 32 | MBALIGN equ 1 << 0 33 | MEMINFO equ 1 << 1 34 | 35 | ; Deklarasi user-defined section 36 | section .custom 37 | align 4 ; the data here should be 4-byte aligned 38 | magic: dd MAGIC 39 | dd MBALIGN 40 | dd MEMINFO 41 | 42 | 43 | section .text 44 | _start: 45 | 46 | ; Akses konten dari custom-section dapat dilakukan seperti akses 47 | ; section lain. 48 | push dword magic 49 | hlt ; Hentikan eksekusi 50 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/5.inclusion.asm: -------------------------------------------------------------------------------- 1 | ; inclusion.asm 2 | ; 3 | ; Assemble: 4 | ; (linux) 5 | ; $ nasm -f elf32 -o inclusion.o inclusion.asm 6 | ; 7 | ; (win32) 8 | ; $ nasm -f win32 -o inclusion.o inclusion.asm 9 | ; 10 | ; Link: 11 | ; (linux) 12 | ; $ ld -m elf_i386 -o inclusion inclusion.o 13 | ; 14 | ; (windows) 15 | ; $ ld -m i386pe -o inclusion inclusion.o 16 | ; 17 | ;----------------------------------------------------------------------------- 18 | 19 | ; Modul eksternal (code, data, atau keduanya) dapat disertakan / dimasukkan ke 20 | ; dalam module ini, seperti halnya melakukan import pada bahasa lain. 21 | 22 | %include "external.inc" 23 | 24 | global _start 25 | 26 | 27 | section .data 28 | 29 | 30 | section .text 31 | _start: 32 | ; Modul lain dimasukkan sebagai bagian dari fungsi. 33 | ; Dengan kata lain, isi dari modul akan disalin ke sini. Fungsi _start akan dikembangkan 34 | ; dan instruksi di "instr.inc" akan disalin. 35 | 36 | %include "instr.inc" 37 | 38 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/6.namespace.asm: -------------------------------------------------------------------------------- 1 | ; namespace.asm 2 | ; 3 | ; Membuat namespace 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o namespace.o namespace.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o namespace.o namespace.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o namespace namespace.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o namespace namespace.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging / emulator 21 | ; 22 | ;----------------------------------------------------------------------------- 23 | 24 | global _start 25 | 26 | section .data 27 | 28 | section .text 29 | 30 | ; Label merupakan sebuah token yang mengidentifikasi posisi dalam kode. 31 | ; Label dapat dilihat sebagai fungsi, tujuan percabangan, serta bagian loop. 32 | 33 | _start: 34 | 35 | ; Label yang berawalan titik '.' akan mendapatkan label non-local sebelumnya 36 | ; sebagai bagian namana, yang akan memberikan keunikan. 37 | 38 | ; Namespace sangat berguna untuk membagi program ke dalam komponen-komponen kecil 39 | ; tanpa mencemari penamaan secara global. 40 | 41 | labelspace: 42 | 43 | ; Hal ini sebaiknya tidak dilakukan, tapi ini memberikan informasi apa yang 44 | ; terjadi sebenarnya. 45 | 46 | jmp labelspace.inside_label 47 | mov eax, 1 48 | hlt 49 | 50 | .inside_label: 51 | 52 | ; Ini praktik yang disarankan ketika merujuk ke sebuah label. 53 | 54 | jmp .inside_label2 55 | mov eax, 2 56 | hlt 57 | 58 | .inside_label2: 59 | mov eax, 3 60 | hlt 61 | 62 | ; Label .inside_label dan .inside_label2 merupakan label di dalam namespace 'labelspace'. 63 | ; Keduanya dapat diakses berdasarkan nama utuh dan parsial. Dimungkinkan juga untuk 64 | ; membuat hierarki lebih dalam. 65 | 66 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/7a.section-ext-elf.asm: -------------------------------------------------------------------------------- 1 | ; section-ext-elf.asm 2 | ; 3 | ; Section extension untuk ELF 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o section-ext-elf.o section-ext-elf.asm 8 | ; 9 | ; Link: 10 | ; (linux) 11 | ; $ ld -m elf_i386 -o section-ext-elf section-ext-elf.o 12 | ; 13 | ; Note: 14 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 15 | ; sebagai sebuah program. 16 | ; 17 | ;----------------------------------------------------------------------------- 18 | 19 | ;----------------------------------------------------------------------------- 20 | ; Directive tambahan tersedia untuk mengendalikan tipe dan properti dari sections. 21 | ; Jika tidak dideklarasikan, NASM akan menghasilkan perkiraan properti yang sesuai. 22 | ; Section dengan nama standard akan di-assign secara otomatis. 23 | ; Properti umumnya berguna untuk custom-section. 24 | ;----------------------------------------------------------------------------- 25 | 26 | global _start 27 | 28 | ; The available qualifier: 29 | ; - alloc / noalloc: definisikan apabila section dimuat ke memory ketika runtime. 30 | ; - exec / no exec: definisikan apakah section merupakan bagian executable ketika runtime. 31 | ; - write / nowrite: definisikan apakah section merupakan bagian writable ketika runtime. 32 | ; - progbits / nobits: definisikan apakah section section secara eksplisit disimpan 33 | ; ke object file. 34 | ; - align: definisikan alignment yang digunakan section 35 | ; - tls: definisikan section memiliki Thread Local variables. 36 | 37 | section .data progbits alloc noexec write align=4 38 | immutable_data: db 10 39 | 40 | section .bss nobits alloc noexec wrie align=4 41 | mutable_data: resb 1 42 | 43 | section .text progbits alloc exec nowrite align=16 44 | _start: 45 | 46 | hlt ; Hentikan eksekusi 47 | 48 | ; Sample: 49 | ; section .rodata progbits alloc noexec nowrite align=4 50 | ; section .lrodata progbits alloc noexec nowrite align=4 51 | ; section .ldata progbits alloc noexec write align=4 52 | ; section .lbss nogbits alloc noexec write align=4 53 | ; section .tdata progbits alloc noexec write align=4 tls 54 | ; section .tbss nobits alloc noexec write align=4 tls 55 | ; section .comment progbits alloc noexec nowrite align=1 56 | ; section other progbits alloc noexec nowrite align=1 57 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/7b.section-ext-pe.asm: -------------------------------------------------------------------------------- 1 | ; section-ext-pe.asm 2 | ; 3 | ; Section extension untuk PE. 4 | ; 5 | ; Assemble: 6 | ; (win32) 7 | ; $ nasm -f win32 -o section-ext-pe.o section-ext-pe.asm 8 | ; 9 | ; Link: 10 | ; (windows) 11 | ; $ ld -m i386pe -o section-ext-pe section-ext-pe.o 12 | ; 13 | ; Note: 14 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 15 | ; sebagai sebuah program. 16 | ; 17 | ;----------------------------------------------------------------------------- 18 | 19 | ;----------------------------------------------------------------------------- 20 | ; Directive tambahan tersedia untuk mengendalikan tipe dan properti dari sections. 21 | ; Jika tidak dideklarasikan, NASM akan menghasilkan perkiraan properti yang sesuai. 22 | ; Section dengan nama standard akan di-assign secara otomatis. 23 | ; Properti umumnya berguna untuk custom-section. 24 | ;----------------------------------------------------------------------------- 25 | 26 | global _start 27 | 28 | ; The available qualifier: 29 | ; - code (or text): section merupakan code section, menjadi readable dan executable 30 | ; namun bukan tidak writable. 31 | ; - data & bss: section merupakan data section, menjadi readable dan writable 32 | ; namun tidak executable. Perbedaan antara data dan bss terletak 33 | ; pada keadaan inisialisasi. 34 | ; - info: section merupakan bersifat informational, tidak ada padanan yang 35 | ; dihasilkan ke binary oleh linker. 36 | 37 | ; NASM membebaskan alignment, umumnya bernilai perpangkatan 2. 38 | 39 | ; Section .data merupakan "data section" dengan alignment 4 40 | section .data data align=4 41 | immutable_data: db 10 42 | 43 | ; Section .bss merupakan "bss section" dengan alignment 4 44 | section .bss bss align=4 45 | mutable_data: resb 1 46 | 47 | ; Section .text merupakan "code section" dengan alignment 16 48 | section .text code align=16 49 | _start: 50 | 51 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/external.inc: -------------------------------------------------------------------------------- 1 | ; Included by other file 2 | %define VAL 10 -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/00.structure/instr.inc: -------------------------------------------------------------------------------- 1 | ; included by other file 2 | mov eax, 135 -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/01.declaration/1.reserve-space.asm: -------------------------------------------------------------------------------- 1 | ; reserve-space.asm 2 | ; 3 | ; Pesan ruang untuk uninitialized data di section .bss. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o reserve-space.o reserve-space.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o reserve-space.o reserve-space.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o reserve-space reserve-space.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o reserve-space reserve-space.o 18 | ; 19 | ; Note: 20 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 21 | ; sebagai sebuah program. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | global _start 26 | 27 | ; Pesan ruang di memory 28 | ; 29 | ; Ketika menghasilkan binary code, NASM akan mengalokasikan ruang untuk untaian 30 | ; byte di section terkait. untaian data ini bersifat tak terinisiasi (uninitialized) 31 | ; atau akan terisi dengan angka 0. 32 | ; 33 | ; 34 | ; Pemberian label tidak diwajibkan, tapi jika data akan diakses maka pelabelan 35 | ; harus dilakukan. 36 | ; 37 | ; Reservasi ruang memori dapat dilakukan dengan instruksi resX dengan X adalah 38 | ; tipe data yang diinginkan. 39 | ; resb = pesan bytes (8-bit) 40 | ; resw = pesan words (16-bits) 41 | ; resd = pesan double words (32-bits) 42 | ; resq = pesan quad words (64-bits) atau double-precision float 43 | ; rest = pesan 80-bits floating-point constant (extended-precision float) 44 | 45 | section .bss 46 | bbuffer: resb 5 ; pesan 5 bytes space 47 | wbuffer: resw 1 ; pesan a word 48 | qbuffer: resd 10 ; array of qword 49 | 50 | section .text 51 | _start: 52 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/01.declaration/2.constants.asm: -------------------------------------------------------------------------------- 1 | ; constants.asm 2 | ; 3 | ; Menciptakan konstanta. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o constants.o constants.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o constants.o constants.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o define-data define-data.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o define-data define-data.o 18 | ; 19 | ; Note: 20 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 21 | ; sebagai sebuah program. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | global _start 26 | 27 | ; Konstanta dapat dideklarasikan dengan instruksi 'equ' (equate). Instruksi ini 28 | ; tidak mengalokasikan ruang apapun. Simbol atau token akan dievaluasi kemudian 29 | ; dan segala kemunculan konstanta akan digantikan dengan nilai terkait. 30 | ; 31 | ; Karenanya, mendefinisikan konstanta hanyalah sebatas memberi nilai ke suatu nama 32 | ; dan berlaku saat kompilasi. 33 | 34 | lenequ: equ 4 ; kapanpun 'lenequ' ditemukan di source code, ia akan 35 | ; diganti dengan 4 36 | 37 | ; Instruksi equ mirip dengan #define di C. 38 | ; #define lenequ 4 39 | 40 | ; Instruksi lain yang sepadan untuk mendeklarasikan konstanta adalah dengan %define 41 | ; Instruksi %define dapat diletakkan dimanapun, bahkan di dalam fungsi. 42 | 43 | %define DLENEQU 10 44 | 45 | section .data 46 | ; Bandingkan dengan 'db' 47 | lendb: db 4 ; tulis 4 ke 1 byte memory 48 | 49 | section .text 50 | _start: 51 | ; untuk mengilustrasikan memory layout, kode berikut akan digunakan 52 | mov eax, lenequ 53 | mov eax, dword [lendb] 54 | 55 | ; hasilnya akan serupa dengan ini, asumsi bahwa alamat kode berada tepat 56 | ; setelah section data. 57 | ; 58 | ; addr code label instruction 59 | ;------------------------------------------- 60 | ; 402000 lenequ equ 4 61 | ; 402000 04 lendb db 4 62 | ; 402001 b8 04 00 00 00 mov eax, lenequ 63 | ; 402006 a1 00 20 40 00 mov eax, [lendb] 64 | 65 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/01.declaration/3.strings.asm: -------------------------------------------------------------------------------- 1 | ; strings.asm 2 | ; 3 | ; Deklarasi string. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o strings.o strings.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o strings.o strings.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o strings strings.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o strings strings.o 18 | ; 19 | ; Note: 20 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 21 | ; sebagai sebuah program. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | global _start 26 | 27 | ; String adalah array of characters atau deretan karakter yang padu. 28 | ; Karakter adalah representasi byte. 29 | ; Sebuah string dapat didefinisikan dalam berbagai kombinasi. 30 | 31 | section .data 32 | 33 | ; [1] String constant 34 | ; Seperti konstanta karakter, tapi lebih panjang. 35 | 36 | db 'Hello' ; string constant 37 | db 'H', 'e', 'l', 'l', 'o' ; konstanta karakter yang speadan 38 | 39 | dd 'ninechars' ; doubleword string constant 40 | dd 'nine', 'char', 's' ; menjadi tiga dwords 41 | db 'ninechars', 0, 0, 0 ; sama dengan dua deklarasi sebelumnya. 42 | 43 | 44 | ; [2] Unicode string 45 | ; Operator khusus disediakan untuk mendefinisikan unicode string. 46 | ; __utf16__ __utf16le__ __utf16be__ 47 | ; __utf32__ __utf32le__ __utf32be__ 48 | ; 49 | ; Fungsi tersebut menerima string UTF-8 dan mengubahnya menjadi UTF-16 50 | ; atau UTF-32. Jika tak disebutkan, output akan menggunakan little endian. 51 | dw __utf16__('C:\WINDOWS'), 0 ; pathname in UTF-16 52 | dd __utf32__('A + B = \u206a'), 0 ; string in UTF-32 53 | 54 | section .text 55 | _start: 56 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/01.declaration/4.floats.asm: -------------------------------------------------------------------------------- 1 | ; floats.asm 2 | ; 3 | ; Deklarasi floating-point. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o floats.o floats.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o floats.o floats.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o floats floats.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o floats floats.o 18 | ; 19 | ; Note: 20 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 21 | ; sebagai sebuah program. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | global _start 26 | 27 | ; Konstanta floating point hanya diterima sebagai argumen untuk instruksi 28 | ; DB, DW, DD, DQ, DT, and D0 29 | 30 | ; atau sebagai argument untuk operator khusus: 31 | ; __float8__, __float16__, __float32__, 32 | ; __float64__, __float80m__, __float80e__, 33 | ; __float128l__, __float128h__ 34 | 35 | section .data 36 | db -0.2 ; "Quarter precision" 37 | dw -0.5 ; IEEE 754r/SSE5 half precision 38 | dd 1.2 ; 39 | dd 1.222_222_222 ; penggunaan underscore diperbolehkan memisah digit 40 | dd 0x1p+2 ; 1.0x2^2 = 4.0 41 | dq 0x1p+32 ; 1.0x2^32 = 4 294 967 296.0 42 | dq 1.e10 ; 10 000 000 000.0 43 | dq 1.e+10 ; sama dengan 1.e10 44 | dq 1.e-10 ; 0.000 000 000 1 45 | dt 3.141592653589793238462 ; pi 46 | do 1.e+4000 ; IEEE 754r quad precision 47 | 48 | section .text 49 | _start: 50 | 51 | ; Operator khusus digunakan untuk menghasilkan bilangan floating point (pecahan) di 52 | ; konteks lain. Operator ini menghasilkan representasi biner dari floating point 53 | ; sebagai bilangan bulat. 54 | 55 | mov eax, __float32__(3.141592653589793238462) 56 | 57 | ; akan menjadi 58 | 59 | mov eax, 0x40490fdb 60 | 61 | ; Sesuai spesifikasi IEEE754, token khusus untuk mengidentifikasi infinity dan NaN 62 | ; juga tersedia. 63 | ; __Infinity__ floating point number infinity value 64 | ; __QNaN__, __NaN__ quiet NaN 65 | ; __SNaN__ signaling NaN 66 | 67 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/01.declaration/file.txt: -------------------------------------------------------------------------------- 1 | A txt resource that will be imported to object file. -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/02.signs/0.signness.asm: -------------------------------------------------------------------------------- 1 | ; signness.asm 2 | ; 3 | ; Data adalah untaian byte. 4 | ; Dapat merepresentasikan apa saja dari angka sederhana hingga 5 | ; user-defined data. 6 | ; Bilangan dapat dilihat sebagai bilangan bertanda atau tak bertanda 7 | ; (sign / unsigned number) 8 | ; 9 | ; Assemble: 10 | ; (linux) 11 | ; $ nasm -f elf32 -o signness.o signness.asm 12 | ; 13 | ; (win32) 14 | ; $ nasm -f win32 -o signness.o signness.asm 15 | ; 16 | ; Link: 17 | ; (linux) 18 | ; $ ld -m elf_i386 -o signness signness.o 19 | ; 20 | ; (windows) 21 | ; $ ld -m i386pe -o signness signness.o 22 | ; 23 | ; Note: 24 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 25 | ; sebagai sebuah program. 26 | ; 27 | ;----------------------------------------------------------------------------- 28 | 29 | global _start 30 | 31 | ; Sign adalah pertanda bahwa bilangan memiliki kemampuan untuk mengakomodasi 32 | ; bilangan negatif di sistem bilangan. 33 | 34 | section .data 35 | 36 | ; Memory hanyalah untaian byte, dapat diisi dengan nilai signed ataupun unsigned. 37 | ; Tidak dapat dipastikan apakah sebuah data biner merupakan data sign atau unsigned. 38 | ; 39 | ; Nilai negatif dapat disimpulkan dalam serangkaian instruksi yang melibatkannya. 40 | ; Namun tidak ada cara yang pasti untuk meyakinkan apakah benar nilai tersebut 41 | ; merupakan nilai negatif. 42 | 43 | data1: db 15 ; data1 = 0F 44 | data2: db -15 ; data2 = F1 45 | data3: db 0xF1 ; data3 = F1 46 | data4: dw -135 ; data4 = FF 79 47 | data5: dw 65401 ; data5 = FF 79 48 | 49 | ; data2 merupakan bilangan signed, sementara data3 unsigned. Pada akhirnya kedua bilangan 50 | ; akan menghasilkan nilai yang sama yaitu 0xF1. Hal ini dapat diverifikasi dengan 51 | ; hexdump atau disassembler. 52 | 53 | ; Dengan melihat source code, diketahui bahwa data dideklarasikan sebagai signed, tapi 54 | ; ketika melihat binary, hal itu tidak dapat dipastikan. 55 | ; 56 | ; Pertanyaannya, bagaimana dapat diketahui bahwa sebuah nilai merupakan bilangan negatif? 57 | ; Tidak ada cara yang jitu untuk menentukannya dengan melihat untaian byte saja. Perlu 58 | ; analisis dari instruksi yang memanipulasi data tersebut. 59 | 60 | section .text 61 | _start: 62 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/03.data-movement/1.immediate.asm: -------------------------------------------------------------------------------- 1 | ; immediate.asm 2 | ; 3 | ; Data movement untuk immediate value. 4 | ; Immediate value hanya dapat digunakan sebagai operan sumber, tidak bisa 5 | ; digunakan sebagai operan tujuan. 6 | ; 7 | ; Assemble: 8 | ; (linux) 9 | ; $ nasm -f elf32 -o immediate.o immediate.asm 10 | ; 11 | ; (win32) 12 | ; $ nasm -f win32 -o immediate.o immediate.asm 13 | ; 14 | ; Link: 15 | ; (linux) 16 | ; $ ld -m elf_i386 -o immediate immediate.o 17 | ; 18 | ; (windows) 19 | ; $ ld -m i386pe -o immediate immediate.o 20 | ; 21 | ; Note: 22 | ; Jalankan di lingkungan debugging atau emulator. 23 | ; Comment beberapa instruksi untuk menyesuaikan dengan target platform. 24 | ; 25 | ;----------------------------------------------------------------------------- 26 | 27 | global _start 28 | 29 | section .bss 30 | bblock resb 1 31 | wblock resw 1 32 | dblock resd 1 33 | qblock resq 1 34 | 35 | 36 | section .text 37 | _start: 38 | 39 | ; MOV 40 | ; tetapkan nilai register dengan immediate value. 41 | ; nilai dan register harus berukuran sesuai. 42 | 43 | mov al, 0 ; 8-bit b0 00 44 | mov bh, 1 ; 8-bit b7 01 45 | mov cx, 2 ; 16-bit 66 b9 02 00 46 | mov edx, 3 ; 32-bit ba 03 00 00 00 47 | ; error jika dieksekusi pada 32-bit 48 | mov r8, 4 ; 64-bit 41 b8 04 00 00 00 49 | 50 | ; tetapkan nilai pada alamat memory dengan immediate value. 51 | ; nilai dan memory harus berukuran sesuai. 52 | 53 | mov byte [bblock], 1 ; 8-bit 54 | mov word [wblock], 2 ; 16-bit 55 | mov dword [dblock], 3 ; 32-bit 56 | ; error jika dieksekusi pada 32-bit 57 | mov qword [qblock], 4 ; 64-bit 58 | 59 | 60 | ; PUSH 61 | ; Simpan immediate value ke stack (alamat yang ditunjuk ESP/RSP). 62 | ; Stack harus selalu aligned, ukuran elemen sama dengan ukuran memory alignment. 63 | ; Dimana alignment selalu: 64 | ; * 4-byte pada program 32-bit 65 | ; * 8-byte pada program 64-bit 66 | 67 | push 1 ; 8-bit 6a 01 68 | 69 | 70 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/05.bitwise/3.flags.asm: -------------------------------------------------------------------------------- 1 | ; flags.asm 2 | ; 3 | ; set / clear bit tertentu di register flag (EFLAGS) 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o flags.o flags.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o flags.o flags.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o flags flags.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o flags flags.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging atau emulator. 21 | ; Comment beberapa instruksi untuk menyesuaikan dengan target platform. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | global _start 26 | 27 | 28 | section .text 29 | _start: 30 | 31 | ; CF (Carry Flag) 32 | ; Carry Flag aktif otomatis ketika terdapat Carry pada operasi sebelumnya, 33 | ; entah dari operasi aritmetik maupun bitwise. 34 | ; Flag ini dapat diaktifkan (set) / dinonaktifkan (clear) secara manual. 35 | 36 | ; CLC (clear carry flag) 37 | clc 38 | 39 | ; STC (set carry flag) 40 | stc 41 | 42 | ; CMC (complement / toggling carry flag) 43 | cmc 44 | 45 | 46 | ; IF (Interrupt Flag) 47 | ; Interrupt Flag adalah flag sistem yang menentukan apakah CPU akan 48 | ; menangani Maskable Hardware Interrupt. 49 | ; Flag ini dapat diaktifkan (set) / dinonaktifkan (clear) secara manual. 50 | 51 | ; CLI (clear interrupt flag) 52 | cli 53 | 54 | ; STI (set interrupt flag) 55 | sti 56 | 57 | 58 | ; DF (Direction Flag) 59 | ; Direction Flag adalah flag yang mengendalikan arah (kiri ke kanan atau kanan ke kiri) 60 | ; pada pemrosesan string. 61 | ; Flag ini dapat diaktifkan (set) / dinonaktifkan (clear) secara manual. 62 | 63 | ; CLD (clear direction flag) 64 | cld 65 | 66 | ; STD (set direction flag) 67 | std 68 | 69 | 70 | ; Load / Store flags into register 71 | ; LAHF (load flags into AH register) 72 | lahf 73 | 74 | ; SAHF (store flags from AH register) 75 | sahf 76 | 77 | 78 | 79 | 80 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/05.bitwise/5.scan.asm: -------------------------------------------------------------------------------- 1 | ; scan.asm 2 | ; 3 | ; Assemble: 4 | ; (linux) 5 | ; $ nasm -f elf32 -o scan.o scan.asm 6 | ; 7 | ; (win32) 8 | ; $ nasm -f win32 -o scan.o scan.asm 9 | ; 10 | ; Link: 11 | ; $ gcc -m32 -o scan scan.o 12 | ; 13 | ; Note: 14 | ; Jalankan di lingkungan debugging atau emulator. 15 | ; 16 | ;----------------------------------------------------------------------------- 17 | 18 | global _start 19 | 20 | ; Scan posisi kemunculan pertama bit aktif di sebuah word atau dword dan menyimpan 21 | ; index tersebut ke operan tujuan. 22 | ; ZF akan bernilai 1 jika keseluruhan bit bernilai 0, jika tidak ZF bernilai 0 23 | 24 | section .bss 25 | wblock resw 1 26 | dblock resd 1 27 | qblock resq 1 28 | 29 | 30 | section .text 31 | _start: 32 | 33 | ; BSF (Bit Scan Forward) 34 | ; bsf reg, reg 35 | bsf bx, ax ; 16-bit 36 | bsf ebx, eax ; 32-bit 37 | ; error jika dieksekusi pada program 32-bit 38 | bsf rbx, rax ; 32-bit 39 | 40 | ; bsf reg, mem 41 | bsf ax, word [wblock] ; 16-bit 42 | bsf eax, dword [dblock] ; 32-bit 43 | ; error jika dieksekusi pada program 32-bit 44 | bsf rax, qword [qblock] ; 64-bit 45 | 46 | ; BSR (Bit Scan Reverse) 47 | ; bsf reg, reg 48 | bsr bx, ax ; 16-bit 49 | bsr ebx, eax ; 32-bit 50 | ; error jika dieksekusi pada program 32-bit 51 | bsr rbx, rax ; 32-bit 52 | 53 | ; bsf reg, mem 54 | bsr ax, word [wblock] ; 16-bit 55 | bsr eax, dword [dblock] ; 32-bit 56 | ; error jika dieksekusi pada program 32-bit 57 | bsr rax, qword [qblock] ; 64-bit 58 | 59 | 60 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/05.bitwise/6.bswap.asm: -------------------------------------------------------------------------------- 1 | ; swap.asm 2 | ; 3 | ; Assemble: 4 | ; (linux) 5 | ; $ nasm -f elf32 -o scan.o scan.asm 6 | ; 7 | ; (win32) 8 | ; $ nasm -f win32 -o scan.o scan.asm 9 | ; 10 | ; Link: 11 | ; $ gcc -m32 -o scan scan.o 12 | ; 13 | ; Note: 14 | ; Jalankan di lingkungan debugging atau emulator. 15 | ; 16 | ;----------------------------------------------------------------------------- 17 | 18 | global _start 19 | 20 | ; balikkan (reverse) urutan byte dari register, mengubah Endian 21 | ; bit 0 hingga 7 ditukar (swap) dengan bit 24 hingga 31 22 | ; bit 8 hingga 15 ditukar (swap) dengan bit 16 hingga 23 23 | 24 | section .text 25 | _start: 26 | 27 | ; bswap reg 28 | bswap ebx ; 32-bit 29 | bswap rbx ; 64-bit 30 | 31 | 32 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/06.conditional/2.move.asm: -------------------------------------------------------------------------------- 1 | ; move.asm 2 | ; 3 | ; Instruksi Conditional Move 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o move.o move.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o move.o move.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o move move.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o move move.o 18 | ; 19 | ;----------------------------------------------------------------------------- 20 | 21 | global _start 22 | 23 | ; Conditional Move adalah jenis instruksi yang mirip dengan Move pada umumnya. 24 | ; Perbedaannya adalah pada pada evaluasi dimana instruksi terjadi jika kondisi 25 | ; telah terpenuhi. 26 | 27 | ; Operan sumber dan tujuan harus memiliki ukuran sesuai. 28 | 29 | section .text 30 | _start: 31 | 32 | ; signed 33 | ; CMOVE (Move if Equal) 34 | ; move jika status ZF aktif 35 | cmove eax, ebx 36 | 37 | ; CMOVNE (Move if Not Equal) 38 | ; move jika status ZF nonaktif 39 | cmovne eax, ebx 40 | 41 | ; CMOVG (Move if Greater) 42 | ; move jika status ~(SF^OF) & ~ZF terpenuhi 43 | cmovg eax, ebx 44 | cmovnle eax, ebx ; sepadan dengan CMOVG 45 | 46 | ; CMOVGE (Move if Greater or Equal) 47 | ; move jika status ~(SF^OF) terpenuhi 48 | cmovge eax, ebx 49 | cmovnl eax, ebx ; sepadan dengan CMOVGE 50 | 51 | ; CMOVL (Move if lower) 52 | ; move jika status SF^OF 53 | cmovl eax, ebx 54 | cmovnge eax, ebx ; sepadan dengan CMOVL 55 | 56 | ; CMOVLE (Move if lower or Equal) 57 | ; move jika status (SF^OF) | ZF 58 | cmovle eax, ebx 59 | cmovng eax, ebx ; sepadan dengan CMOVLE 60 | 61 | ; CMOVS (Move if negative) 62 | ; move jika status SF aktif 63 | cmovs eax, ebx 64 | 65 | ; CMOVNS (Move is nonnegative) 66 | ; move jika status SF nonaktif 67 | cmovns eax, ebx 68 | 69 | 70 | ; unsigned 71 | ; CMOVZ (Move if zero) 72 | ; move jika status ZF aktif 73 | cmovz eax, ebx ; sepadan dengan CMOVE 74 | 75 | ; CMOVNZ (Move if Not zero) 76 | ; move jika status ZF nonaktif 77 | cmovnz eax, ebx ; sepadan dengan CMOVNE 78 | 79 | ; CMOVA (Move if Above) 80 | ; move jika status ~CF & ~ZF terpenuhi 81 | cmova eax, ebx 82 | cmovnbe eax, ebx ; sepadan dengan CMOVA 83 | 84 | ; CMOVAE (Move if Above or Equal) 85 | ; move jika status CF nonaktif 86 | cmovae eax, ebx 87 | cmovnb eax, ebx ; sepadan dengan CMOVAE 88 | 89 | ; CMOVB (Move if Below) 90 | ; move jika status CF aktif 91 | cmovb eax, ebx 92 | cmovnae eax, ebx ; sepadan dengan CMOVB 93 | 94 | ; CMOVBE (Move if Below or Equal) 95 | ; move jika status CF | ZF terpenuhi 96 | cmovbe eax, ebx 97 | cmovna eax, ebx ; sepadan dengan CMOVBE 98 | 99 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/07.branching/0.if.asm: -------------------------------------------------------------------------------- 1 | ; if.asm 2 | ; 3 | ; Percabangan dengan pengecekan kondisi tunggal 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o if.o if.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o if.o if.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o if if.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o if if.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging atau emulator. 21 | ; 22 | ;----------------------------------------------------------------------------- 23 | 24 | global _start 25 | 26 | ; Branching (percabangan) adalah perpindahan eksekusi ke sekumpulan instruksi 27 | ; berbeda menggunakan satu atau lebih instruksi Jump. 28 | 29 | ; Instruksi percabangan dapat berupa Unconditional Jump (selalu berpindah) 30 | ; ataupun Conditional Jump (mungkin berpindah). Satu atau lebih instruksi Jump 31 | ; dapat dikombinasikan untuk mengevaluasi kondisi yang kompleks dan memastikan 32 | ; apakah block instruksi akan dieksekusi atau tidak. 33 | ; 34 | ; Tujuan: 35 | ; Implementasi statement "If-Then" 36 | ; Percabangan sederhana yang mengarahkan ke sekelompok instruksi jika kondisi 37 | ; terpenuhi. 38 | ; 39 | ; Bentuk umum: 40 | ; if (condition) then 41 | ; do_action 42 | ; 43 | ; Padanan: 44 | ; if not (condition) then goto end 45 | ; do_action 46 | ; end: 47 | 48 | section .data 49 | var dd 0 50 | 51 | section .text 52 | 53 | _start: 54 | 55 | ; if (var == 0) 56 | ; { 57 | ; var = 1 58 | ; } 59 | 60 | ; Periksa apakah kondisi terpenuhi dan lakukan Jump jika false 61 | ; (negasi dari kondisi terpenuhi). 62 | ; Ini adalah implementasi efisien karena hanya butuh satu jump. 63 | 64 | mov eax, dword [var] ; isi nilai ke EAX 65 | 66 | ; pemeriksaan kondisi 67 | cmp eax, 0 ; bandingkan EAX dan 0 68 | 69 | ; lompati / lewati jika negasi dari kondisi terpenuhi 70 | jne .end ; jump ketika tak nol 71 | 72 | ; eksekusi do_action karena kondisi (asli) terpenuhi. 73 | mov dword [var], eax ; eksekusi aksi. 74 | 75 | .end: 76 | ; instruksi ini akan dieksekusi terlepas dari hasil percabangan. 77 | 78 | 79 | hlt ; Hentikan eksekusi 80 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/07.branching/1.if-else.asm: -------------------------------------------------------------------------------- 1 | ; if-else.asm 2 | ; 3 | ; Percabangan dengan pengecekan tunggal, aksi dan alternatifnya 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o if-else.o if-else.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o if-else.o if-else.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o if-else if-else.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o if-else if-else.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging atau emulator. 21 | ; 22 | ;----------------------------------------------------------------------------- 23 | 24 | global _start 25 | 26 | ; Branching (percabangan) adalah perpindahan eksekusi ke sekumpulan instruksi 27 | ; berbeda menggunakan satu atau lebih instruksi Jump. 28 | 29 | ; Instruksi percabangan dapat berupa Unconditional Jump (selalu berpindah) 30 | ; ataupun Conditional Jump (mungkin berpindah). Satu atau lebih instruksi Jump 31 | ; dapat dikombinasikan untuk mengevaluasi kondisi yang kompleks dan memastikan 32 | ; apakah block instruksi akan dieksekusi atau tidak. 33 | ; 34 | ; Tujuan: 35 | ; Implementasi statement "If-Else" 36 | ; Percabangan sederhana yang mengarahkan ke sekelompok instruksi jika kondisi 37 | ; terpenuhi, jika tidak lakukan instruksi alternatif. 38 | ; 39 | ; Bentuk umum: 40 | ; if (condition) then 41 | ; do_action 42 | ; else 43 | ; do_alternative_action 44 | ; 45 | ; Padanan: 46 | ; if not (condition) then goto else 47 | ; do_action 48 | ; goto end 49 | ; else: 50 | ; do_alternative_action 51 | ; end: 52 | 53 | section .data 54 | var dd 0 55 | 56 | section .text 57 | 58 | _start: 59 | 60 | ; if (var == 0) 61 | ; { 62 | ; var = 1 63 | ; } 64 | ; else 65 | ; { 66 | ; var = 2; 67 | ; } 68 | 69 | ; Periksa apakah kondisi terpenuhi dan lakukan Jump jika false 70 | ; (negasi dari kondisi terpenuhi). 71 | ; Ini adalah implementasi efisien karena hanya butuh dua jump. 72 | 73 | mov eax, dword [var] ; isi nilai ke EAX 74 | 75 | ; pemeriksaan kondisi 76 | cmp eax, 0 ; if (var == 0) 77 | 78 | ; lompati / lewati jika negasi dari kondisi terpenuhi 79 | jne .else ; jump ketika tak nol 80 | 81 | ; eksekusi do_action karena kondisi (asli) terpenuhi. 82 | mov dword [var], eax ; eksekusi aksi 83 | jmp .end ; hindari block untuk "else" atau aksi alternatif 84 | 85 | .else: 86 | ; eksekusi do_alternative_action karena kondisi (asli) tak terpenuhi. 87 | mov dword [var], eax 88 | 89 | .end: 90 | ; instruksi ini akan dieksekusi terlepas dari hasil percabangan. 91 | 92 | 93 | hlt ; Hentikan eksekusi 94 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/07.branching/5.nested-if.asm: -------------------------------------------------------------------------------- 1 | ; nested-if.asm 2 | ; 3 | ; Percabangan bersarang. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o nested-if.o nested-if.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o nested-if.o nested-if.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o nested-if nested-if.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o nested-if nested-if.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging atau emulator. 21 | ; 22 | ;----------------------------------------------------------------------------- 23 | 24 | global _start 25 | 26 | ; Branching (percabangan) adalah perpindahan eksekusi ke sekumpulan instruksi 27 | ; berbeda menggunakan satu atau lebih instruksi Jump. 28 | 29 | ; Instruksi percabangan dapat berupa Unconditional Jump (selalu berpindah) 30 | ; ataupun Conditional Jump (mungkin berpindah). Satu atau lebih instruksi Jump 31 | ; dapat dikombinasikan untuk mengevaluasi kondisi yang kompleks dan memastikan 32 | ; apakah block instruksi akan dieksekusi atau tidak. 33 | ; 34 | ; Tujuan: 35 | ; Implementasi percabangan bersarang. 36 | ; Sebuah percabangan dapat didefinisikan di dalam blok aksi percabangan lain. 37 | ; 38 | ; Bentuk umum: 39 | ; if (condition_1) then 40 | ; do_action_1 41 | ; if (condition_2) then 42 | ; do_action_2 43 | 44 | section .data 45 | var1 dd 0 46 | var2 dd 0 47 | 48 | section .text 49 | 50 | _start: 51 | 52 | ; Perlu dicatat bahwa pemeriksaan kondisi condition_2 hanya terjadi jika condition_1 terpenuhi. 53 | ; Dapat dikatakan bahwa pemeriksaan condition_2 berada pada block sama dengan do_action_1 54 | 55 | ; if (var1 == 0) then 56 | ; var1 = 10 57 | ; if (var2 == 0) then 58 | ; var2 = 20 59 | 60 | mov eax, dword [var1] ; isi nilai var1 ke EAX 61 | 62 | ; pemeriksaan kondisi condition_1 63 | cmp eax, 0 64 | jne .end ; jump jika tak nol 65 | 66 | ; eksekusi do_action_1 67 | mov dword [var1], 10 68 | 69 | ; pemeriksaan kondisi condition_2 70 | mov ebx, dword [var2] ; isi nilai var2 ke EBX 71 | cmp ebx, 0 72 | jne .end ; jump jika tak nol 73 | 74 | ; eksekusi do_action_2 75 | mov dword [var2], 20 76 | 77 | .end: 78 | ; instruksi ini akan dieksekusi terlepas dari hasil percabangan. 79 | 80 | 81 | hlt ; Hentikan eksekusi 82 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/08.loop/1.loop.asm: -------------------------------------------------------------------------------- 1 | ; loop.asm 2 | ; 3 | ; Instruksi perulangan sederhana 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o loop.o loop.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o loop.o loop.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o loop loop.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o loop loop.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging atau emulator. 21 | ; 22 | ;----------------------------------------------------------------------------- 23 | 24 | global _start 25 | 26 | ; Loop (perulangan) adalah serangkaian instruksi yang ditulis sekali namun dapat 27 | ; dieksekusi berkali-kali secara berturut-turut. 28 | ; 29 | ; Instruksi perulangan dapat dapat dikendalikan berdasarkan banyaknya perulangan 30 | ; maupun kondisi perulangan yang harus dipenuhi 31 | ; 32 | ; Di x86, loop dapat didefinisikan dengan tiga mekanisme berbeda: 33 | ; - REP (dan turunannya) 34 | ; - LOOP (dan turunannya) 35 | ; - Branching. 36 | 37 | ; LOOP (dan turunannya) adalah perulangan di level block. 38 | ; Eksekusi sekelompok instruksi secara berulang sebanyak sekian kali yang didefinisikan 39 | ; dalam count register ECX atau sampai kondisi yang diindikasikan flag ZF tak terpenuhi. 40 | ; 41 | ; Keluarga instruksi LOOP memiliki berapa instruksi: 42 | ; - LOOP (Loop) 43 | ; - LOOPE (Loop while Equal) 44 | ; - LOOPNE (Loop while Not Equal) 45 | ; - LOOPZ (Loop while Zero) 46 | ; - LOOPNZ (Loop while Not Zero) 47 | ; 48 | ; LOOP need a label which will be a destination jump. 49 | 50 | section .bss 51 | dstd resd 5 52 | 53 | 54 | section .text 55 | 56 | _start: 57 | 58 | ; LOOP (Loop) 59 | ; ulangi blok instruksi hingga ECX bernilai 0. 60 | 61 | ; mengisi array dengan counter 62 | mov ecx, 5 ; counter ECX 63 | mov edi, dstd ; destination 64 | mov eax, 0 65 | mov ebx, 0 66 | loop_label: 67 | stosd 68 | inc ebx 69 | add eax, ebx 70 | loop loop_label ; loop 71 | 72 | ; dstd = 0, 1, 3, 6, 10 73 | 74 | 75 | ; LOOPE (Loop while Equal) 76 | ; LOOPZ (Loop while Zero) 77 | ; ulangi blok instruksi hingga ECX bernilai 0 atau ZF = 0 78 | 79 | ; cari nilai yang tak sama di [EDI] dan [ESI] 80 | mov ecx, 5 ; counter ECX 81 | mov edi, dstd ; destination 82 | loope_label: 83 | loope loope_label ; loop 84 | 85 | 86 | ; LOOPNE (Loop while Not Equal) 87 | ; LOOPNZ (Loop while Not Zero) 88 | ; ulangi blok instruksi hingga ECX bernilai 0 atau ZF = 1 89 | 90 | ; cari nilai yang sama di [EDI] and [ESI] 91 | mov ecx, 5 ; counter ECX 92 | mov edi, dstd ; destination 93 | loopnz_label: 94 | loopnz loopnz_label ; loop 95 | 96 | 97 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/08.loop/2.do-while.asm: -------------------------------------------------------------------------------- 1 | ; do-while.asm 2 | ; 3 | ; Instruksi perulangan sederhana 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o do-while.o do-while.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o do-while.o do-while.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o do-while do-while.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o do-while do-while.o 18 | ; 19 | ; Note: 20 | ; Jalankan di lingkungan debugging atau emulator. 21 | ; 22 | ;----------------------------------------------------------------------------- 23 | 24 | global _start 25 | 26 | ; Loop (perulangan) adalah serangkaian instruksi yang ditulis sekali namun dapat 27 | ; dieksekusi berkali-kali secara berturut-turut. 28 | ; 29 | ; Instruksi perulangan dapat dikendalikan berdasarkan banyaknya perulangan 30 | ; maupun kondisi perulangan yang harus dipenuhi 31 | ; 32 | ; Di x86, loop dapat didefinisikan dengan tiga mekanisme berbeda: 33 | ; - REP (dan turunannya) 34 | ; - LOOP (dan turunannya) 35 | ; - Branching. 36 | 37 | ; Do-While loop adalah konstruksi perulangan sederhana dimana sekelompok instruksi 38 | ; dieksekusi setidaknya sebanyak sekali. 39 | ; 40 | ; Bentuk umum: 41 | ; do 42 | ; do_action 43 | ; while (condition) 44 | ; 45 | ; Padanan: 46 | ; loop_body: 47 | ; do_action 48 | ; if not (condition) then goto loop_body 49 | 50 | section .data 51 | var dd 0 52 | 53 | 54 | section .text 55 | 56 | _start: 57 | 58 | ; do 59 | ; { 60 | ; var ++; 61 | ; } while (var <= 10); 62 | 63 | ; blok instruksi dieksekusi, kondisi diperiksa saat akhir perulangan dan lompat 64 | ; kembali ke awal blok jika kondisi terpenuhi. 65 | 66 | ; lakukan inisialisasi apapun jika diperlukan di sini. 67 | mov eax, dword [var] 68 | 69 | loop_body: ; blok instruksi dimulai di sini. 70 | inc eax 71 | 72 | ; Pada kasus tertentu, beberapa instruksi dapat mengubah kondisi. 73 | ; Misal, perubahan counter, perubahan treshold, dsb. 74 | 75 | ; Conditional Jump, periksa apakah perulangan akan dilakukan kembali. 76 | cmp eax, 10 77 | jle loop_body ; ulangi jika kondisi tidak terpenuhi. 78 | 79 | ; di luar loop 80 | mov dword [var], eax 81 | 82 | 83 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/3.recursive.asm: -------------------------------------------------------------------------------- 1 | ; recursion.asm 2 | ; 3 | ; Pemanggilan fungsi secara rekursif. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o recursion.o recursion.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o recursion.o recursion.asm 11 | ; 12 | ; Link: 13 | ; $ gcc -m32 -o recursion recursion.o 14 | ; 15 | ; Note: 16 | ; Jalankan di lingkungan debugging atau emulator. 17 | ; 18 | ;----------------------------------------------------------------------------- 19 | 20 | global _start 21 | 22 | ; Rekursi adalah metode pemecahan masalah dengan solusi terkini bergantung kepada 23 | ; solusi untuk problem yang lebih kecil. 24 | 25 | ; Berdasarkan hal ini, fungsi rekursif adalah fungsi yang memanggil dirinya sendiri 26 | ; selama eksekusi hingga mencapai titik tertentu. Hal ini mengakibatkan fungsi 27 | ; berulang beberapa kali dan membentuk siklus. 28 | 29 | ; Sebuah fungsi rekursi memiliki: 30 | ; - satu atau lebih base case, dan 31 | ; - satu atau lebih kasus rekurens. 32 | ; 33 | ; Base Case adalah kondisi dimana rekursi berakhir dan input dapat digunakan untuk 34 | ; menghasilkan solusi secara langsung. 35 | ; Sementara rekurens adalah kondisi dimana input (problem) dipecah menjadi bagian kecil 36 | ; dan diselesaikan dengan memanggil fungsi diri sendiri untuk problem tersebut. 37 | 38 | 39 | section .text 40 | _start: 41 | push 5 42 | call func_recursion 43 | 44 | pop edx 45 | 46 | hlt ; Hentikan eksekusi 47 | 48 | 49 | ;----------------------------------------------------------------------------- 50 | 51 | ; Deklarasi fungsi rekursif. 52 | ; 53 | ; func_recursion(X) 54 | ; => 0 , jika X <= 0 55 | ; => X + func_recursion(X - 1) , jika X > 0 56 | 57 | func_recursion: 58 | 59 | ; Function Prologue 60 | push ebp 61 | mov ebp, esp 62 | 63 | ; Base Case, jika X <= 0 64 | mov edx, dword [ebp + 8] ; arg1 65 | cmp edx, 0 66 | jg .recurrence 67 | mov eax, 0 68 | jmp .result 69 | 70 | ; Recurrence Case, jika X > 0 71 | .recurrence: 72 | dec edx ; X - 1 73 | push edx 74 | call func_recursion ; func_recursion(X - 1) 75 | 76 | pop edx 77 | add eax, dword [ebp + 8] ; X + func_recursion(X - 1) 78 | 79 | .result: 80 | ; function prologue 81 | pop ebp 82 | ret 83 | 84 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/4.cdecl-conv.asm: -------------------------------------------------------------------------------- 1 | ; cdecl-conv.asm 2 | ; 3 | ; Fungsi dengan CDECL calling convention. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o cdecl-conv.o cdecl-conv.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o cdecl-conv.o cdecl-conv.asm 11 | ; 12 | ; Link: 13 | ; $ gcc -m32 -o cdecl-conv cdecl-conv.o 14 | ; 15 | ; Note: 16 | ; Jalankan di lingkungan debugging atau emulator. 17 | ; 18 | ;----------------------------------------------------------------------------- 19 | 20 | global _start 21 | 22 | ; Calling Convention, adalah konvensi (perjanjian) atau aturan yang mengendalikan 23 | ; bagaimana pemanggilan fungsi dilakukan. 24 | ; Umumnya, sebuah calling convention mengatur: 25 | ; - bagaimana argumen diberikan 26 | ; - bagaimana nilai dikembalikan oleh fungsi 27 | ; - bagaimana nilai register dipertahankan ketika pemanggilan fungsi 28 | ; - siapa yang bertanggung jawab membersihkan stack (argumen) setelah pemanggilan. 29 | 30 | ; CDECL adalah standard atau calling convention default di C. 31 | ; 32 | ; Di CDECL Calling Convention 33 | ; - argumen diberikan melalui push ke stack dengan urutan kanan-ke-kiri. 34 | ; - pengembalian nilai bilangan bulat dan alamat memory dengan meletakkan di register EAX, 35 | ; floating point di ST0 36 | ; - EAX, ECX, EDX adalah caller-saved dan selebihnya adalah callee-saved. 37 | ; - Caller bertanggung jawab membersihkan stack. 38 | 39 | section .text 40 | _start: 41 | 42 | ; Argumen di-push ke stack 43 | push 4 ; arg4 44 | push 3 ; arg3 45 | push 2 ; arg2 46 | push 1 ; arg1 47 | 48 | call func_cdecl 49 | 50 | ; Caller bertanggung jawab membersihkan stack setelah pemanggilan fungsi. 51 | add esp, 16 ; karena terjadi push 16 byte 52 | 53 | ; Pembersihan stack dapat dilakukan setiap kali selesai memanggil fungsi atau 54 | ; dilakukan menjelang akhir eksekusi fungsi caller. 55 | 56 | hlt ; Hentikan eksekusi 57 | 58 | 59 | ;----------------------------------------------------------------------------- 60 | 61 | ; Deklarasi fungsi dengan CDECL 62 | ; 63 | ; func_cdecl(arg1, arg2, arg3, arg4) 64 | ; => arg1 + arg2 + arg3 + arg4 65 | 66 | func_cdecl: 67 | 68 | ; Function Prologue 69 | push ebp 70 | mov ebp, esp 71 | 72 | ; Function Body 73 | mov eax, dword [ebp + 8] ; eax = arg1 74 | mov eax, dword [ebp + 12] ; eax += arg2 75 | mov eax, dword [ebp + 16] ; eax += arg3 76 | mov eax, dword [ebp + 20] ; eax += arg4 77 | 78 | ; Function Epilogue 79 | pop ebp 80 | 81 | ret -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/5.stdcall-conv.asm: -------------------------------------------------------------------------------- 1 | ; stdcall-conv.asm 2 | ; 3 | ; Fungsi dengan STDCALL calling convention. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o stdcall-conv.o stdcall-conv.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o stdcall-conv.o stdcall-conv.asm 11 | ; 12 | ; Link: 13 | ; $ gcc -m32 -o stdcall-conv stdcal-convl.o 14 | ; 15 | ; Note: 16 | ; Jalankan di lingkungan debugging atau emulator. 17 | ; 18 | ;----------------------------------------------------------------------------- 19 | 20 | global _start 21 | 22 | ; Calling Convention, adalah konvensi (perjanjian) atau aturan yang mengendalikan 23 | ; bagaimana pemanggilan fungsi dilakukan. 24 | ; Umumnya, sebuah calling convention mengatur: 25 | ; - bagaimana argumen diberikan 26 | ; - bagaimana nilai dikembalikan oleh fungsi 27 | ; - bagaimana nilai register dipertahankan ketika pemanggilan fungsi 28 | ; - siapa yang bertanggung jawab membersihkan stack (argumen) setelah pemanggilan. 29 | 30 | ; STDCALL umumnya merupakan standard yang digunakan Microsoft untuk Win32 API. 31 | ; 32 | ; Di STDCALL Calling Convention, 33 | ; - argumen diberikan melalui push ke stack dengan urutan kanan-ke-kiri. 34 | ; - pengembalian nilai bilangan bulat dengan meletakkan di register EAX 35 | ; - Callee bertanggung jawab membersihkan stack. 36 | ; 37 | ; STDCALL tidak mendukung argumen dengan panjang bervariasi. 38 | 39 | section .text 40 | _start: 41 | 42 | ; Argumen di-push ke stack. 43 | push 4 ; arg4 44 | push 3 ; arg3 45 | push 2 ; arg2 46 | push 1 ; arg1 47 | 48 | call func_stdcall 49 | 50 | hlt ; Hentikan eksekusi 51 | 52 | 53 | 54 | ;----------------------------------------------------------------------------- 55 | 56 | ; Deklarasi fungsi dengan STDCALL. 57 | ; 58 | ; func_stdcall(arg1, arg2, arg3, arg4) 59 | ; => arg1 + arg2 + arg3 + arg4 60 | 61 | func_stdcall: 62 | 63 | ; Function Prologue 64 | push ebp 65 | mov ebp, esp 66 | 67 | ; Function Body 68 | mov eax, dword [ebp + 8] ; eax = arg1 69 | mov eax, dword [ebp + 12] ; eax += arg2 70 | mov eax, dword [ebp + 16] ; eax += arg3 71 | mov eax, dword [ebp + 20] ; eax += arg4 72 | 73 | ; Function Epilogue 74 | pop ebp 75 | 76 | ; Callee bertanggung jawab membersihkan stack. 77 | ; Fungsi ini membutuhkan 16 byte data di stack. 78 | ret 16 -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/6.fastcall-conv.asm: -------------------------------------------------------------------------------- 1 | ; fastcall-conv.asm 2 | ; 3 | ; Fungsi dengan Fastcall calling convention. 4 | ; 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o fastcall-conv.o fastcall-conv.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o fastcall-conv.o fastcall-conv.asm 12 | ; 13 | ; Link: 14 | ; $ gcc -m32 -o fastcall-conv fastcall-conv.o 15 | ; 16 | ; Note: 17 | ; Jalankan di lingkungan debugging atau emulator. 18 | ; 19 | ;----------------------------------------------------------------------------- 20 | 21 | global _start 22 | 23 | ; Calling Convention, adalah konvensi (perjanjian) atau aturan yang mengendalikan 24 | ; bagaimana pemanggilan fungsi dilakukan. 25 | ; Umumnya, sebuah calling convention mengatur: 26 | ; - bagaimana argumen diberikan 27 | ; - bagaimana nilai dikembalikan oleh fungsi 28 | ; - bagaimana nilai register dipertahankan ketika pemanggilan fungsi 29 | ; - siapa yang bertanggung jawab membersihkan stack (argumen) setelah pemanggilan. 30 | 31 | ; Di Fastcall Calling Convention, 32 | ; - dua argumen awal akan disimpan di register, selebihnya akan disimpan ke stack 33 | ; dengan urutan kanan-ke-kiri. 34 | ; - pengembalian nilai bilangan bulat dengan meletakkan di register EAX 35 | ; - Callee bertanggung jawab membersihkan stack. 36 | ; 37 | ; Karena ambiguitasnya, direkomendasikan hanya menggunakan Fastcall di situasi dimana 38 | ; fungsi hanya memiliki 1, 2, atau 3 argumen saja dan ketika kecepatan sangat penting. 39 | 40 | 41 | section .text 42 | _start: 43 | 44 | ; Argumen disimpan di register. 45 | ; Dua argumen awal untuk integer dan pointer disimpan di ECX, EDX. 46 | ; Selebihnya (arg3 dst) akan disimpan di stack. 47 | ; Dalam kasus ini, urutan push ke stack perlu diperhatikan. 48 | 49 | push 4 ; arg4 50 | push 3 ; arg3 51 | mov edx, 2 ; arg2 52 | mov ecx, 1 ; arg1 53 | 54 | call func_fastcall 55 | 56 | 57 | hlt ; Hentikan eksekusi 58 | 59 | 60 | ;----------------------------------------------------------------------------- 61 | 62 | ; Deklarasi fungsi dengan Fastcall 63 | ; 64 | ; func_fastcall(arg1, arg2, arg3 arg4) 65 | ; => arg1 + arg2 + arg3 + arg4 66 | 67 | func_fastcall: 68 | 69 | ; Function Prologue 70 | push ebp 71 | mov ebp, esp 72 | 73 | ; Function Body 74 | ; ECX dan EDX digunakan sebagai argumen pertama dan kedua. 75 | add ecx, edx ; arg1 += arg2 76 | add ecx, dword [ebp + 8] ; arg1 += arg3 77 | add eax, dword [ebp + 16] ; arg1 += arg4 78 | mov eax, ecx 79 | 80 | ; Function Epilogue 81 | pop ebp 82 | 83 | ; Callee bertanggung jawab membersihkan stack. 84 | ; Fungsi ini membutuhkan 4 byte data di stack. 85 | ret 8 -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/7.pascal-conv.asm: -------------------------------------------------------------------------------- 1 | ; pascal-conv.asm 2 | ; 3 | ; Fungsi dengan Pascal calling convention. 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o pascal-conv.o pascal-conv.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o pascal-conv.o pascal-conv.asm 11 | ; 12 | ; Link: 13 | ; $ gcc -m32 -o pascal-conv pascal-conv.o 14 | ; 15 | ; Note: 16 | ; Jalankan di lingkungan debugging atau emulator. 17 | ; 18 | ;----------------------------------------------------------------------------- 19 | 20 | global _start 21 | 22 | ; Calling Convention, adalah konvensi (perjanjian) atau aturan yang mengendalikan 23 | ; bagaimana pemanggilan fungsi dilakukan. 24 | ; Umumnya, sebuah calling convention mengatur: 25 | ; - bagaimana argumen diberikan 26 | ; - bagaimana nilai dikembalikan oleh fungsi 27 | ; - bagaimana nilai register dipertahankan ketika pemanggilan fungsi 28 | ; - siapa yang bertanggung jawab membersihkan stack (argumen) setelah pemanggilan. 29 | 30 | ; Calling Convention ini berdasarkan Calling Convention yang dipakai Borland Pascal 31 | ; 32 | ; Di Pascal, 33 | ; - argumen diberikan melalui push ke stack dengan urutan kiri-ke-kanan. 34 | ; - pengembalian nilai dengan aturan 35 | ; - EAX menyimpan 'Ordinal' dan pointer 36 | ; - DX:BX:AX untuk 'Real' 37 | ; - ST0 untuk floating point. 38 | ; - string diletakkan di lokasi temporer yang ditunjuk @Result 39 | ; - Callee bertanggung jawab membersihkan stack. 40 | 41 | section .text 42 | _start: 43 | 44 | ; Argumen di-push ke stack 45 | push 1 ; arg1 46 | push 2 ; arg2 47 | push 3 ; arg3 48 | push 4 ; arg4 49 | 50 | call func_pascal 51 | 52 | 53 | hlt ; Hentikan eksekusi 54 | 55 | 56 | ;----------------------------------------------------------------------------- 57 | 58 | ; Deklarasi fungsi dengan Pascal 59 | ; 60 | ; func_pascal(arg1, arg2, arg3 arg4) 61 | ; => arg1 + arg2 + arg3 + arg4 62 | 63 | func_pascal: 64 | 65 | ; Function Prologue 66 | push ebp 67 | mov ebp, esp 68 | 69 | ; Function Body 70 | mov eax, dword [ebp + 8] 71 | add eax, dword [ebp + 12] 72 | add eax, dword [ebp + 16] 73 | add eax, dword [ebp + 20] 74 | 75 | ; Function Epilogue 76 | pop ebp 77 | 78 | ; Callee bertanggung jawab membersihkan stack. 79 | ; Fungsi ini membutuhkan 16 byte data di stack. 80 | ret 16 -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/8.optlink-conv.asm: -------------------------------------------------------------------------------- 1 | ; optlink-conv.asm 2 | ; 3 | ; Fungsi dengan Optlink calling convention 4 | ; 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o optlink-conv.o optlink-conv.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o optlink-conv.o optlink-conv.asm 12 | ; 13 | ; Link: 14 | ; $ gcc -m32 -o optlink-conv optlink.o 15 | ; 16 | ; Note: 17 | ; Jalankan di lingkungan debugging atau emulator. 18 | ; 19 | ;----------------------------------------------------------------------------- 20 | 21 | global _start 22 | 23 | ; Calling Convention, adalah konvensi (perjanjian) atau aturan yang mengendalikan 24 | ; bagaimana pemanggilan fungsi dilakukan. 25 | ; Umumnya, sebuah calling convention mengatur: 26 | ; - bagaimana argumen diberikan 27 | ; - bagaimana nilai dikembalikan oleh fungsi 28 | ; - bagaimana nilai register dipertahankan ketika pemanggilan fungsi 29 | ; - siapa yang bertanggung jawab membersihkan stack (argumen) setelah pemanggilan. 30 | 31 | ; Optilink digunakan oleh compiler IBM VisualAge. 32 | ; 33 | ; Di optlink calling convention, 34 | ; - tiga argumen awal akan disimpan di register, selebihnya akan disimpan ke stack 35 | ; dengan urutan kanan-ke-kiri. 36 | ; - pengembalian nilai bilangan bulat dengan meletakkan di register EAX atau ST0 37 | ; - register EBP, EBX, ESI, dan EDI dipertahankan oleh Caller. 38 | ; - Caller bertanggung jawab membersihkan stack. 39 | 40 | section .text 41 | _start: 42 | 43 | ; Argumen disimpan di register. 44 | ; Register paling umum yang digunakan adalah EAX, EDX, dan ECX untuk menyimpan 45 | ; arg1, arg2, dan arg3. Selebihnya (arg4 dst) akan disimpan di stack. 46 | ; Dalam kasus ini, urutan push ke stack perlu diperhatikan. 47 | 48 | ; Empat argumen dengan tipe floating point akan disimpan di ST0 hingga ST3 49 | 50 | push 4 ; arg4 51 | mov ecx, 3 ; arg3 52 | mov edx, 2 ; arg2 53 | mov eax, 1 ; arg1 54 | 55 | call func_optlink 56 | 57 | ; Caller bertanggung jawab membersihkan stack setelah pemanggilan fungsi. 58 | add esp, 4 ; karena terjadi push 4 byte 59 | 60 | ; Pembersihan stack dapat dilakukan setiap kali selesai memanggil fungsi atau 61 | ; dilakukan menjelang akhir eksekusi fungsi caller. 62 | 63 | hlt ; Hentikan eksekusi 64 | 65 | 66 | ;----------------------------------------------------------------------------- 67 | 68 | ; Deklarasi fungsi dengan Optlink. 69 | ; 70 | ; func_optlink(arg1, arg2, arg3, arg4) 71 | ; => arg1 + arg2 + arg3 + arg4 72 | 73 | func_optlink: 74 | 75 | ; Function Prologue 76 | push ebp 77 | mov ebp, esp 78 | 79 | ; Function Body 80 | mov eax, edx ; arg1 += arg2 81 | mov eax, ecx ; arg1 += arg3 82 | mov eax, dword [ebp + 8] ; arg1 += arg4 83 | 84 | ; Function Epilogue 85 | pop ebp 86 | 87 | ret -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/09.subroutine/9.ms-x64-conv.asm: -------------------------------------------------------------------------------- 1 | ; ms-x64-conv.asm 2 | ; 3 | ; Fungsi dengan Microsoft x64 calling convention 4 | ; 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o ms-x64-conv.o ms-x64-conv.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o ms-x64-conv.o ms-x64-conv.asm 12 | ; 13 | ; Link: 14 | ; $ gcc -m32 -o ms-x64-conv ms-x64.o 15 | ; 16 | ; Note: 17 | ; Jalankan di lingkungan debugging atau emulator. 18 | ; 19 | ;----------------------------------------------------------------------------- 20 | 21 | global _start 22 | 23 | ; Calling convention ini spesifik untuk x64. 24 | ; Microsoft x64 calling convention digunakan oleh Windows dan pre-boot UEFI. 25 | 26 | ; Calling Convention, adalah konvensi (perjanjian) atau aturan yang mengendalikan 27 | ; bagaimana pemanggilan fungsi dilakukan. 28 | ; Umumnya, sebuah calling convention mengatur: 29 | ; - bagaimana argumen diberikan 30 | ; - bagaimana nilai dikembalikan oleh fungsi 31 | ; - bagaimana nilai register dipertahankan ketika pemanggilan fungsi 32 | ; - siapa yang bertanggung jawab membersihkan stack (argumen) setelah pemanggilan. 33 | 34 | ; Ini adalah satu-satunya calling-convention untuk Windows x64. 35 | ; 36 | ; Di ms-x64 calling convention, 37 | ; - empat argumen awal akan disimpan di register, selebihnya akan disimpan ke stack 38 | ; dengan urutan kanan-ke-kiri. 39 | ; - pengembalian nilai bilangan bulat dengan meletakkan di register RAX atau XMM0 40 | ; - register EBP, EBX, ESI, dan EDI dipertahankan oleh Caller. 41 | ; - Caller bertanggung jawab membersihkan stack. 42 | 43 | section .text 44 | _start: 45 | 46 | ; Argumen disimpan di register. 47 | ; Empat argumen awal untuk integer dan pointer disimpan di RCX, RDX, R8, dan R9. 48 | ; Empat argumen awal untuk floating point disimpan di XMM0, XMM1, XMM2, dan XMM3. 49 | ; Selebihnya disimpan di Stack dengan urutan kanan-ke-kiri 50 | 51 | mov rcx, 1 ; arg1 52 | mov rdx, 2 ; arg2 53 | mov r8, 3 ; arg3 54 | mov r9, 4 ; arg4 55 | 56 | call func_x64 57 | 58 | ; Caller bertanggung jawab membersihkan stack setelah pemanggilan fungsi. 59 | 60 | ; Pembersihan stack dapat dilakukan setiap kali selesai memanggil fungsi atau 61 | ; dilakukan menjelang akhir eksekusi fungsi caller. 62 | 63 | hlt ; Hentikan eksekusi 64 | 65 | 66 | ;----------------------------------------------------------------------------- 67 | 68 | ; Deklarasi fungsi dengan ms-x64. 69 | ; 70 | ; func_x64(arg1, arg2, arg3, arg4) 71 | ; => arg1 + arg2 + arg3 + arg4 72 | 73 | func_x64: 74 | 75 | ; Function Prologue 76 | push rbp 77 | mov rbp, rsp 78 | 79 | ; Function Body 80 | add rcx, rdx ; arg1 += arg2 81 | add r8, r9 ; arg3 += arg4 82 | add rcx, r8 83 | mov rax, rcx 84 | 85 | ; Function Epilogue 86 | pop rbp 87 | 88 | ret -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/10.macro/0.single.asm: -------------------------------------------------------------------------------- 1 | ; single.asm 2 | ; 3 | ; NASM Macro Preprocessing. 4 | ; Single-Line atau Multiline 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o single.o single.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o single.o single.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o single single.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o single single.o 19 | ; 20 | ; Note: 21 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 22 | ; sebagai sebuah program. 23 | ; 24 | ;----------------------------------------------------------------------------- 25 | 26 | global _start 27 | 28 | ; Semua single-line macro harus didefinisikan dengan directive %define 29 | ; Struktur umum sebuah macro adalah: 30 | ; 31 | ; %define macro_name(parameter) value 32 | 33 | 34 | ; definisikan variabel 35 | ; name value 36 | %define argc esp + 8 37 | %define ctrl 0x1F & 38 | 39 | ; definisikan "fungsi" 40 | %define param(a,b) ((a)+(a)*(b)) 41 | 42 | ; Macro akan dikembangkan menjadi instruksi yang sesuai. 43 | ; Ketika ekspansi, single-line macro yang mengandung token macro lain akan 44 | ; menyebabkan ekspansi dilakukan secara rekursif. 45 | ; Ekspansi dilakukan saat pemanggilan terjadi, bukan saat definisi. 46 | 47 | %define a(x) 1 + b(x) 48 | %define b(x) 2 * x 49 | 50 | ; Macro dapat di-overload sebanyak apapun 51 | 52 | %define foo(x) 1 + x 53 | %define foo(x,y) 1 + x * y 54 | 55 | 56 | 57 | section .text 58 | _start: 59 | ; ekspansi macro terjadi ketika digunakan 60 | 61 | ; argc akan dievaluasi sebagai rsp + 8, sehingga menjadi: 62 | ; mov eax, [rsp + 8] 63 | mov eax, [argc] 64 | 65 | ; ekspansi menjadi 66 | ; mov byte [(2)+(2)*(ebx)], 0x1F & 'D' 67 | mov byte [param(2,ebx)], ctrl 'D' 68 | 69 | ; ekspansi menjadi 70 | ; mov eax, 1 + 2 * 3 71 | ; atau pada akhirnya menjadi 72 | ; mov eax, 7 73 | mov eax, a(3) 74 | 75 | ; ekspansi menjadi 76 | ; mov eax, 1 + 2 77 | mov eax, foo(2) 78 | 79 | ; ekspansi menjadi 80 | ; mov eax, 1 + 2 + 3 81 | mov eax, foo(2,3) 82 | 83 | hlt -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/10.macro/1.multi.asm: -------------------------------------------------------------------------------- 1 | ; multi.asm 2 | ; 3 | ; NASM Macro Preprocessing. 4 | ; Single-Line atau Multiline 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o multi.o multi.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o multi.o multi.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o multi multi.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o multi multi.o 19 | ; 20 | ; Note: 21 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 22 | ; sebagai sebuah program. 23 | ; 24 | ;----------------------------------------------------------------------------- 25 | 26 | global _start 27 | 28 | ; Semua multiline macro harus didefinisikan di dalam directive %macro dan %endmacro. 29 | ; Struktur umum sebuah macro adalah: 30 | ; 31 | ; %macro macro_name number_of_parameters 32 | ; instruction 33 | ; instruction 34 | ; ... 35 | ; %endmacro 36 | 37 | %macro prologue 1 38 | push ebp 39 | mov ebp, esp 40 | ; parameter dirujuk sebagai angka (urutan), contoh %1, %2, dst 41 | sub esp, %1 42 | %endmacro 43 | 44 | 45 | ; Macro dapat memiliki label lokal 46 | ; Setiap pemanggilan terhadap label akan menginstansiasi label unik. 47 | %macro retz 0 48 | jnz %%skip 49 | ret 50 | %%skip: 51 | %endmacro 52 | 53 | 54 | ; Macro akan dikembangkan menjadi instruksi yang sesuai. 55 | ; Ketika ekspansi, single-line macro yang mengandung token macro lain akan 56 | ; menyebabkan ekspansi dilakukan secara rekursif. 57 | ; Ekspansi dilakukan saat pemanggilan terjadi, bukan saat definisi. 58 | 59 | ; seluruh label yang didefinisikan di dalam macro diawali %% 60 | %macro PRINT 1 61 | jmp %%astr 62 | %%str db %1, 0 63 | %%strlen equ $ - %%str 64 | %%astr: _syscall_write %%str, %%strlen 65 | %endmacro 66 | 67 | %macro _syscall_write 2 68 | mov eax, 1 69 | mov edi, 1 70 | mov esi, %1 71 | mov edx, %2 72 | syscall 73 | %endmacro 74 | 75 | 76 | 77 | section .text 78 | _start: 79 | ; ekspansi macro terjadi ketika digunakan 80 | 81 | ; ekspansi prologue menjadi tiga instruksi 82 | prologue 12 83 | ; push ebp 84 | ; mov ebp, esp 85 | ; sub esp, 12 86 | 87 | 88 | ; gunakan macro PRINT 89 | label: PRINT "Hello World!" 90 | 91 | hlt -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/10.macro/2.param-range.asm: -------------------------------------------------------------------------------- 1 | ; param-range.asm 2 | ; 3 | ; NASM Macro Preprocessing. 4 | ; Konstruksi khusus digunakan untuk penanganan rentang dan elemen 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o param-range.o param-range.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o param-range.o param-range.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o param-range param-range.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o param-range param-range.o 19 | ; 20 | ; Note: 21 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 22 | ; sebagai sebuah program. 23 | ; 24 | ;----------------------------------------------------------------------------- 25 | 26 | global _start 27 | 28 | ; NASM dapat ekspansi parameter melalui konstruksi khusus %{x:y} dimana x adalah 29 | ; indeks parameter pertama dan y adalah indeks terakhir. 30 | 31 | ; Indeks dapat berupa bilangan negatif atau positif tapi tidak dapat nol. 32 | 33 | ; macro ini menerima jumlah parameter bervariasi 34 | 35 | ; this macro receive variable number of parameter 36 | %macro mpar 1-* 37 | db %{3:5} 38 | %endmacro 39 | 40 | ; Valid range: 41 | ; Positive range 42 | ; %{1:3} 43 | 44 | ; Negative range, urutan dari belakang ke depan. 45 | ; ekspansi 1,2,3,4 menjadi 4,3,2 46 | ; %{-1:-3} 47 | 48 | ; Mix range 49 | ; %{3:-3} 50 | 51 | ; Single element 52 | ; %{-1:-1} 53 | 54 | 55 | 56 | section .data 57 | ; ekspansi macro terjadi ketika digunakan 58 | 59 | ; ekspansi macro untuk menerima elemen 3, 4, 5 60 | arr: mpr 1,2,3,4,5,6 61 | ; db 3, 4, 5 62 | 63 | section .text 64 | _start: 65 | 66 | hlt -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/11.user-datatype/0.struc.asm: -------------------------------------------------------------------------------- 1 | ; struc.asm 2 | ; 3 | ; Mendefinisikan struktur data dengan macro 4 | ; 5 | ; Assemble: 6 | ; (linux) 7 | ; $ nasm -f elf32 -o struc.o struc.asm 8 | ; 9 | ; (win32) 10 | ; $ nasm -f win32 -o struc.o struc.asm 11 | ; 12 | ; Link: 13 | ; (linux) 14 | ; $ ld -m elf_i386 -o struc struc.o 15 | ; 16 | ; (windows) 17 | ; $ ld -m i386pe -o struc struc.o 18 | ; 19 | ; Note: 20 | ; Potongan kode ini tak lengkap dan tidak dimaksudkan untuk dijalankan 21 | ; sebagai sebuah program. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | ; Sebuah struktur adalah koleksi / kumpulan data yang disusun menjadi satu kesatuan. 26 | ; Semua struc harus didefinisikan di dalam "struc" dan "endstruct". 27 | 28 | ; Definisikan struktur data 29 | struc person 30 | .name: resb 10 31 | .age: resb 1 32 | endstruc 33 | 34 | 35 | global _start 36 | 37 | section .data 38 | ; buat instance dari struktur "person" 39 | xathrya: istruc person 40 | at person.name, db "Xathrya" 41 | at person.age, db 19 42 | iend 43 | 44 | section .text 45 | _start: 46 | ; akses field dari struktur 47 | mov eax, [xathrya + person.name] 48 | 49 | hlt -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/12.mmx/0.feature-check.asm: -------------------------------------------------------------------------------- 1 | ; feature-check.asm 2 | ; 3 | ; Operasi pada register SIMD. 4 | ; Periksa keberadaan register MMX 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o feature-check.o feature-check.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o feature-check.o feature-check.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o feature-check feature-check.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o feature-check.exe feature-check.o 19 | ; 20 | ; Note: 21 | ; Jalankan di lingkungan debugging atau emulator. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | ; Terdapat 8 register MMX 64-bit: 26 | ; MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7 27 | 28 | global _start 29 | 30 | section .data 31 | 32 | 33 | section .text 34 | _start: 35 | 36 | ; Periksa dukungan fitur MMX dengan instruksi CPUID 37 | ; Bit 23 di CPUID akan aktif bila MMX didukung oleh processor 38 | 39 | mov eax, 1 40 | cpuid 41 | 42 | mov eax, edx 43 | shr eax, 23 44 | and eax, 1 45 | 46 | 47 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/12.mmx/3.bitwise.asm: -------------------------------------------------------------------------------- 1 | ; bitwise.asm 2 | ; 3 | ; Operasi pada register SIMD. 4 | ; Operasi bitwise 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o bitwise.o bitwise.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o bitwise.o bitwise.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o bitwise bitwise.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o bitwise bitwise.o 19 | ; 20 | ; Note: 21 | ; Jalankan di lingkungan debugging atau emulator. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | ; Terdapat 8 register MMX 64-bit: 26 | ; MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7 27 | 28 | global _start 29 | 30 | section .data 31 | qblock dq 0xCAFEBABE, 0x13510030 32 | 33 | 34 | section .text 35 | _start: 36 | 37 | ; AND 38 | ; pand mm, mm/m64 39 | pand mm0, mm1 40 | pand mm0, qword [qblock] 41 | 42 | ; AND NOT 43 | ; pandn mm, mm/m64 44 | pandn mm0, mm1 45 | pandn mm0, qword [qblock] 46 | 47 | ; OR 48 | ; por mm, mm/m64 49 | por mm0, mm1 50 | por mm0, qword [qblock] 51 | 52 | ; XOR 53 | ; pxor mm, mm/m64 54 | pxor mm0, mm1 55 | pxor mm0, qword [qblock] 56 | 57 | ; Shift 58 | ; (logical) shift left words, shift in zeros 59 | ; psllw mm1, imm8 60 | psllw mm0, 3 61 | ; psllw mm1, mm/m64 62 | psllw mm0, mm1 63 | psllw mm0, qword [qblock] 64 | 65 | ; pslld mm1, imm8 66 | pslld mm0, 3 67 | ; pslld mm1, mm/m64 68 | pslld mm0, mm1 69 | pslld mm0, qword [qblock] 70 | 71 | ; psllq mm1, imm8 72 | psllq mm0, 3 73 | ; psllq mm1, mm/m64 74 | psllq mm0, mm1 75 | psllq mm0, qword [qblock] 76 | 77 | 78 | ; (arithmetic) shift right words, shift in sign bits 79 | ; psraw mm1, imm8 80 | psraw mm0, 3 81 | ; psraw mm1, mm/m64 82 | psraw mm0, mm1 83 | psraw mm0, qword [qblock] 84 | 85 | ; psrad mm1, imm8 86 | psrad mm0, 3 87 | ; psrad mm1, mm/m64 88 | psrad mm0, mm1 89 | psrad mm0, qword [qblock] 90 | 91 | 92 | ; (logical) shift right words, shift in zeros 93 | ; psrlw mm1, imm8 94 | psrlw mm0, 3 95 | ; psrlw mm1, mm/m64 96 | psrlw mm0, mm1 97 | psrlw mm0, qword [qblock] 98 | 99 | ; psrld mm1, imm8 100 | psrld mm0, 3 101 | ; psrld mm1, mm/m64 102 | psrld mm0, mm1 103 | psrld mm0, qword [qblock] 104 | 105 | ; psrlq mm1, imm8 106 | psrlq mm0, 3 107 | ; psrlq mm1, mm/m64 108 | psrlq mm0, mm1 109 | psrlq mm0, qword [qblock] 110 | 111 | 112 | 113 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/12.mmx/4.comparison.asm: -------------------------------------------------------------------------------- 1 | ; comparison.asm 2 | ; 3 | ; Operasi pada register SIMD. 4 | ; Perbandingan nilai secara paralel. 5 | ; 6 | ; Assemble: 7 | ; (linux) 8 | ; $ nasm -f elf32 -o comparison.o comparison.asm 9 | ; 10 | ; (win32) 11 | ; $ nasm -f win32 -o comparison.o comparison.asm 12 | ; 13 | ; Link: 14 | ; (linux) 15 | ; $ ld -m elf_i386 -o comparison comparison.o 16 | ; 17 | ; (windows) 18 | ; $ ld -m i386pe -o comparison comparison.o 19 | ; 20 | ; Note: 21 | ; Jalankan di lingkungan debugging atau emulator. 22 | ; 23 | ;----------------------------------------------------------------------------- 24 | 25 | ; Terdapat 8 register MMX 64-bit: 26 | ; MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7 27 | 28 | global _start 29 | 30 | section .data 31 | qblock dq 0xCAFEBABE, 0x13510030 32 | 33 | 34 | section .text 35 | _start: 36 | 37 | ; Equality 38 | ; bandingkan setiap unit di grup untuk periksa persamaan 39 | 40 | ; pcmpeqb mm, mm/64 41 | pcmpeqb mm1, mm0 42 | pcmpeqb mm0, qword [qblock] 43 | 44 | ; pcmpeqw mm, mm/64 45 | pcmpeqw mm1, mm0 46 | pcmpeqw mm0, qword [qblock] 47 | 48 | ; pcmpeqd mm, mm/64 49 | pcmpeqd mm1, mm0 50 | pcmpeqd mm0, qword [qblock] 51 | 52 | ; Greater than 53 | ; bandingkan setiap unit di grup untuk nilai lebih besar 54 | 55 | ; pcmpgtb mm, mm/64 56 | pcmpgtb mm1, mm0 57 | pcmpgtb mm0, qword [qblock] 58 | 59 | ; pcmpgtw mm, mm/64 60 | pcmpgtw mm1, mm0 61 | pcmpgtw mm0, qword [qblock] 62 | 63 | ; pcmpgtd mm, mm/64 64 | pcmpgtd mm1, mm0 65 | pcmpgtd mm0, qword [qblock] 66 | 67 | 68 | 69 | hlt ; Hentikan eksekusi -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/linux/cetak.c: -------------------------------------------------------------------------------- 1 | /** 2 | hello-extern.c 3 | 4 | Panggil function eksternal cetak() kemudian exit. 5 | Function akan mencetak "Hello, World!". 6 | 7 | Compile: 8 | $ gcc -c -o cetak.o cetak.c 9 | 10 | */ 11 | #include 12 | 13 | extern int cetak(); 14 | 15 | int cetak() 16 | { 17 | printf("Hello, World\n"); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/linux/hello-32b.asm: -------------------------------------------------------------------------------- 1 | ; hello-32b.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini bergantung pada libc (C library) dari compiler sehingga perlu 5 | ; dilakukan perlakuan ekstra untuk linking. 6 | ; 7 | ; Assemble: 8 | ; $ nasm -felf32 -o hello-32b.o hello-32b.asm 9 | ; 10 | ; Link: 11 | ; (gcc and libc) 12 | ; $ gcc -m32 -o hello-32b hello-32b.o 13 | ; 14 | ;----------------------------------------------------- 15 | 16 | global main 17 | extern printf 18 | 19 | section .data 20 | message: db 'Hello, World!', 10, 0 21 | 22 | section .text 23 | main: 24 | push message 25 | call printf 26 | add esp, 4 27 | 28 | mov eax, 0 29 | 30 | ret 31 | 32 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/linux/hello-64b.asm: -------------------------------------------------------------------------------- 1 | ; hello-64b.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini bergantung pada libc (C library) dari compiler sehingga perlu 5 | ; dilakukan perlakuan ekstra untuk linking. 6 | ; 7 | ; Assemble: 8 | ; $ nasm -felf64 -o hello-64b.o hello-64b.asm 9 | ; 10 | ; Link: 11 | ; (gcc and libc) 12 | ; $ gcc -o hello-64b hello-64b.o 13 | ; 14 | ;----------------------------------------------------- 15 | 16 | global main 17 | extern printf 18 | 19 | section .data 20 | message: db 'Hello, World!', 10, 0 21 | 22 | section .text 23 | main: 24 | ; sesuaikan alignment 25 | sub rsp, 8 26 | 27 | ; push message 28 | mov rdi, message 29 | call printf 30 | 31 | add rsp, 8 32 | ret 33 | 34 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/linux/hello-extern.asm: -------------------------------------------------------------------------------- 1 | ; hello-extern.asm 2 | ; 3 | ; Panggil function eksternal cetak() kemudian exit. 4 | ; Function akan mencetak "Hello, World!". 5 | ; 6 | ; Assemble: 7 | ; $ gcc -c -o cetak.o cetak.c 8 | ; $ nasm -felf64 -o hello-extern.o hello-extern.asm 9 | ; 10 | ; Link: 11 | ; (gcc) 12 | ; $ ld -o hello-extern -dynamic-linker /lib64/ld-linux-x86-64.so.2 -lc cetak.o hello-extern.o 13 | ; 14 | ;----------------------------------------------------- 15 | 16 | global _start 17 | extern cetak 18 | 19 | section .text 20 | _start: 21 | ; Panggil fungsi cetak() 22 | call cetak 23 | 24 | ; Terminate program 25 | mov rax, 60 26 | mov rdi, 0 27 | syscall -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/linux/hello-syscall32.asm: -------------------------------------------------------------------------------- 1 | ; hello-syscall32.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini menggunakan Linux Syscall. 5 | ; 6 | ; Assemble: 7 | ; $ nasm -felf32 -o hello-syscall32.o hello-syscall32.asm 8 | ; 9 | ; Link: 10 | ; (gcc) 11 | ; $ gcc -m32 -o hello-syscall32 hello-syscall32.o 12 | ; 13 | ;----------------------------------------------------- 14 | 15 | ; // Padanan di C program 16 | ; int main() 17 | ; { 18 | ; write(1, message, msglen); 19 | ; } 20 | 21 | global _start 22 | 23 | section .data 24 | message db 'Hello, World', 10 25 | msglen equ $ - message 26 | 27 | ; The ABI 28 | ; syscall di RAX 29 | ; Argumen diletakkan di register, dari kiri ke kanan (awal hingga akhir): 30 | ; EBX, ECX, EDX, ESI, EDI, EBP 31 | ; Nilai kembalian disimpan di RAX 32 | 33 | section .text 34 | _start: 35 | ; cetak pesan 36 | mov eax, 4 ; syscall = 4 (write) 37 | mov ebx, 1 ; file descriptor = 1 (write to stdout) 38 | mov ecx, message ; the message 39 | mov edx, msglen ; the length of message 40 | int 80h ; call the kernel 41 | 42 | ; keluar 43 | mov eax, 1 44 | mov ebx, 0 45 | int 80h -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/linux/hello-syscall64.asm: -------------------------------------------------------------------------------- 1 | ; hello-syscall64.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini menggunakan Linux Syscall. 5 | ; 6 | ; Assemble: 7 | ; $ nasm -felf64 -o hello-syscall64.o hello-syscall64.asm 8 | ; 9 | ; Link: 10 | ; (gcc) 11 | ; $ ld -o hello-syscall64 hello-syscall64.o 12 | ; 13 | ;----------------------------------------------------- 14 | 15 | ; // Padanan C program 16 | ; int main() 17 | ; { 18 | ; write(1, message, msglen); 19 | ; } 20 | 21 | global _start 22 | 23 | section .data 24 | message db 'Hello, World', 10 25 | msglen equ $ - message 26 | 27 | ; The ABI 28 | ; syscall di RAX 29 | ; Argumen diletakkan di register, dari kiri ke kanan (awal hingga akhir): 30 | ; RDI, RSI, RDX, RCX, R10, R8, R9 31 | ; Nilai kembalian disimpan di RAX 32 | 33 | section .text 34 | _start: 35 | ; cetak pesan 36 | mov rax, 1 ; syscall = 1 (write) 37 | mov rdi, 1 ; file descriptor = 1 (write to stdout) 38 | mov rsi, message ; the message 39 | mov rdx, msglen ; the length of message 40 | syscall ; call the kernel 41 | 42 | ; keluar 43 | mov rax, 60 44 | mov rdi, 0 45 | syscall -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/windows/cetak.c: -------------------------------------------------------------------------------- 1 | /** 2 | hello-extern.c 3 | 4 | Panggil function eksternal cetak() kemudian exit. 5 | Function akan mencetak "Hello, World!". 6 | 7 | Compile: 8 | $ gcc -c -o cetak.o cetak.c 9 | 10 | */ 11 | #include 12 | 13 | extern int cetak(); 14 | 15 | int cetak() 16 | { 17 | printf("Hello, World\n"); 18 | return 0; 19 | } -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/windows/hello-32b.asm: -------------------------------------------------------------------------------- 1 | ; hello-32b.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini bergantung pada libc (C library) dari compiler sehingga perlu 5 | ; dilakukan perlakuan ekstra untuk linking. 6 | ; 7 | ; Assemble: 8 | ; $ nasm -fwin32 -o hello-32b.obj hello-32b.asm 9 | ; 10 | ; Link: 11 | ; (gcc and libc) 12 | ; $ gcc -m32 -o hello-32b.exe hello-32b.obj 13 | ; 14 | ;----------------------------------------------------- 15 | 16 | ; GCC di WIndows memerlukan awalan _ (underscore) untuk nama fungsi 17 | global _main 18 | extern _printf 19 | 20 | section .data 21 | message: db 'Hello, World!', 10, 0 22 | 23 | section .text 24 | _main: 25 | push message 26 | call _printf 27 | add esp, 4 28 | ret 29 | 30 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/windows/hello-64b.asm: -------------------------------------------------------------------------------- 1 | ; hello-64b.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini bergantung pada libc (C library) dari compiler sehingga perlu 5 | ; dilakukan perlakuan ekstra untuk linking. 6 | ; 7 | ; Assemble: 8 | ; $ nasm -fwin64 -o hello-64b.obj hello-64b.asm 9 | ; 10 | ; Link: 11 | ; (gcc and libc) 12 | ; $ gcc -o hello-64b.exe hello-64b.obj 13 | ; 14 | ; Note: 15 | ; Kode menghasilkan segmentation fault di akhir eksekusi karena 16 | ; tidak menggunakan CRT. Ketika return dari main(), processor akan 17 | ; mencoba mengeksekusi instruksi pada alamat 0. 18 | ; 19 | ;----------------------------------------------------- 20 | 21 | global main 22 | extern printf 23 | 24 | section .data 25 | message: db 'Hello, World!', 13, 10, 0 26 | 27 | section .text 28 | main: 29 | mov rcx, qword message 30 | call printf 31 | ret 32 | 33 | -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/windows/hello-extern.asm: -------------------------------------------------------------------------------- 1 | ; hello-extern.asm 2 | ; 3 | ; Panggil function eksternal cetak() kemudian exit. 4 | ; Function akan mencetak "Hello, World!". 5 | ; 6 | ; Assemble: 7 | ; $ gcc -c -o cetak.o cetak.c 8 | ; $ nasm -fwin64 -o hello-extern.obj hello-extern.asm 9 | ; 10 | ; Link: 11 | ; (gcc) 12 | ; $ ld -o hello-extern cetak.o hello-extern.obj 13 | ; 14 | ;----------------------------------------------------- 15 | 16 | global _start 17 | extern cetak 18 | 19 | section .text 20 | _start: 21 | ; Panggil fungsi cetak() 22 | call cetak 23 | 24 | ; Hentikan program 25 | mov rax, 60 26 | mov rdi, 0 27 | syscall -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/windows/hello-win32.asm: -------------------------------------------------------------------------------- 1 | ; hello-win32.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini menggunakan Windows API. 5 | ; 6 | ; Assemble: 7 | ; $ nasm -fwin32 hello-win32.asm -o hello-win32.obj 8 | ; 9 | ; Link: 10 | ; (ms link) 11 | ; $ link /MACHINE:X86 /SUBSYSTEM:CONSOLE /OUT:hello-win32.exe /NODEFAULTLIB /ENTRY:main kernel32.lib hello-win32.obj 12 | ; 13 | ; (golink) 14 | ; $ golink /console /entry _main hello-win32.obj kernel32.dll 15 | ; 16 | ; (gcc) 17 | ; $ gcc -m32 -o hello-win32.exe hello-win32.obj 18 | ; 19 | ;----------------------------------------------------- 20 | 21 | ; // Padanan di C program 22 | ; int main() 23 | ; { 24 | ; HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); 25 | ; WriteFile(hStdOut, message, 13, 0, 0); 26 | ; ExitProcess(0); 27 | ; } 28 | 29 | global _main 30 | extern _GetStdHandle@4 31 | extern _WriteFile@20 32 | extern _ExitProcess@4 33 | 34 | section .data 35 | message db 'Hello, World!', 10 36 | msglen equ $ - message 37 | STD_OUTPUT_HANDLE equ -11 38 | 39 | 40 | section .text 41 | _main: 42 | ; DWORD bytes; 43 | mov ebp, esp 44 | sub esp, 4 45 | 46 | ; hStdOut = GetstdHandle( STD_OUTPUT_HANDLE ) 47 | push STD_OUTPUT_HANDLE 48 | call _GetStdHandle@4 49 | mov ebx, eax 50 | 51 | ; WriteFile( hstdOut, message, length(message), &bytes, 0 ); 52 | push 0 53 | lea eax, [ebp-4] 54 | push eax 55 | push msglen 56 | push message 57 | push ebx 58 | call _WriteFile@20 59 | 60 | ; ExitProcess( 0 ) 61 | push 0 62 | call _ExitProcess@4 63 | 64 | ; never reach here 65 | ret -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/13.os-specific/windows/hello-win64.asm: -------------------------------------------------------------------------------- 1 | ; hello-win64.asm 2 | ; 3 | ; Cetak "Hello, World!" kemudian exit. 4 | ; Kode ini menggunakan Windows API. 5 | ; 6 | ; Assemble: 7 | ; $ nasm -fwin64 -o hello-win64.obj hello-win64.asm 8 | ; 9 | ; Link: 10 | ; (ms link) 11 | ; $ link /MACHINE:X64 /SUBSYSTEM:CONSOLE /OUT:hello-win64.exe /NODEFAULTLIB /ENTRY:main kernel32.lib hello-win64.obj 12 | ; 13 | ; (golink) 14 | ; $ golink /console /entry _main hello-win64.obj kernel32.dll 15 | ; 16 | ; (gcc) 17 | ; $ gcc -o hello-win64.exe hello-win64.obj 18 | ; 19 | ;----------------------------------------------------- 20 | 21 | ; // Padanan di C program 22 | ; int main() 23 | ; { 24 | ; HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); 25 | ; WriteFile(hStdOut, message, 13, 0, 0); 26 | ; ExitProcess(0); 27 | ; } 28 | 29 | ; bits 64 30 | 31 | global main 32 | extern GetStdHandle 33 | extern WriteFile 34 | extern ExitProcess 35 | 36 | section .data 37 | message db 'Hello, World!', 13, 10, 0 38 | msglen equ $ - message 39 | STD_OUTPUT_HANDLE equ -11 40 | hFile dd 0 41 | 42 | 43 | section .text 44 | main: 45 | ; DWORD bytes; 46 | mov rbp, rsp 47 | sub rsp, 30h 48 | 49 | ; hStdOut = GetstdHandle( STD_OUTPUT_HANDLE ) 50 | mov ecx, STD_OUTPUT_HANDLE 51 | call GetStdHandle 52 | 53 | ; WriteFile( hstdOut, message, length(message), &bytes, 0 ); 54 | mov rcx, rax ; HANDLE hFile 55 | mov rdx, message ; LPVOID lpBuffer 56 | mov r8d, dword msglen ; DWORD nNumberOfBytesToWrite 57 | xor r9, r9 ; LPDWORD lpNumberOfBytesWritten 58 | push qword 0 ; LPOVERLAPPED lpOverlapped 59 | call WriteFile 60 | 61 | ; ExitProcess( 0 ) 62 | mov rcx, 0 63 | call ExitProcess 64 | 65 | ; never reach here 66 | ret -------------------------------------------------------------------------------- /Codes/assembly/x86/nasm/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Nasm Codes Repository 4 | 5 | ## Nasm Introduction 6 | 7 | Nasm (Netwide Assembler) merupakan assembler lintas platform, dapat berjalan di berbagai operating system dan dapat menghasilkan binary untuk x86 dan x86-64. 8 | 9 | Kami berusaha untuk membuat kode yang bersifat OS-agnostic. Meski demikian kami menyadari bahwa dalam beberapa hal kami merasa perlu untuk mendemonstrasikan kode yang spesifik terhadap platform. 10 | 11 | ## Nasm Installation 12 | 13 | Kunjungi [nasm site](http://nasm.us) dan ikuti petunjuk instalasi yang ada. 14 | 15 | ## Linker 16 | 17 | Nasm hanyalah sebuah assembler. Ia mengubah source code dalam bahasa assembly menjadi sebuah object code. Karena itu, diperlukan tool lain yang disebut `linker` untuk menggabungkan berbagai object code dan menghasilkan sebuah executable. 18 | 19 | -------------------------------------------------------------------------------- /Codes/assembly/xtensa/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for Xtensa processor assembly. 4 | 5 | ## Assembler Vendor 6 | 7 | - gas (GNU Assembler) -------------------------------------------------------------------------------- /Codes/assembly/z80/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Repository for z80 processor assembly. 4 | 5 | ## Assembler Vendor 6 | 7 | - z80asm (GNU Z80 Assembler) 8 | - vasm -------------------------------------------------------------------------------- /Codes/bytecode/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Bytecode. 4 | 5 | ## Bytecode 6 | 7 | `Bytecode,` atau disebut juga `P-Code` (Portable Code), adalah instruction set yang didesain untuk secara efisien dijalankan oleh sebuah interpreter atau `abstract machine`. Bytecode merepresentasikan instruksi dan operasi yang valid, namun tidak terikat pada platform fisik. Pada konteks tertentu, Bytecode dapat disebut sebagai `Assembly` bagi sebuah platform virtual. 8 | 9 | Bytecode termasuk ke dalam `Intermediate-Language` yang umumnya dihasilkan oleh sebuah compiler untuk dijalankan di atas sebuah interpreter. 10 | 11 | Karena terikat dengan interpreter, gaya bahasa sebuah Bytecode akan menyesuaikan dengan tipe dari interpreter tersebut. Sebuah interpreter merupakan mesin virtual yang berbasis `Register` maupun `Stack`. 12 | 13 | ## Advantages 14 | 15 | Pemahaman Bytecode dari sebuah platform memberikan keuntungan bagi Reverse Engineer dan Developer. Penguasaan Bytecode dapat memberikan pemahaman terhadap: 16 | 17 | - bagaimana instruksi mengakses dan memproses data 18 | - bagaimana sebuah interpreter bekerja secara internal. 19 | 20 | Pemahaman terhadap instruksi Bytecode dapat membantu dalam analisis kode yang kompleks dan menjebak (misal: obfuscation). -------------------------------------------------------------------------------- /Codes/bytecode/dalvik/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Introduction to Dalvik VM & Android RunTime bytecode. 4 | 5 | ## Dialect 6 | 7 | Dalvik VM tidak memberikan spesifikasi standard untuk merepresentasikan bytecode dalam bentuk teks. Tidak ada tools standard yang digunakan untuk melakukan reassembler (disassemble - assemble) sebuah bytecode. 8 | 9 | - smali -------------------------------------------------------------------------------- /Codes/bytecode/jvm/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to JVM bytecode. 4 | 5 | ## JVM Bytecode 6 | 7 | JVM Bytecode adalah Instruction Set yang digunakan oleh Java Virtual Machine (JVM). 8 | 9 | JVM merupakan Process Virtual Machine berbasis stack. Instruksi JVM bytecode akan diterjemahkan secara dinamis menjadi kode yang berjalan secara native di host. 10 | 11 | Setiap bytecode terdiri atas satu byte yang merepresentasikan opcode dengan satu atau lebih byte untuk operan. 12 | 13 | Instruksi dalam JVM bytecode dapat dibagi menjadi beberapa kategori: 14 | 15 | - Load and Store 16 | - Arithmetic and Logic 17 | - Type Conversion 18 | - Object Creation and Manipulation 19 | - Operand Stack Management 20 | - Control Transfer 21 | - Method Invocation and Return. 22 | 23 | ## Computation Model 24 | 25 | JVM bytecode berorientasi objek dan berbasis stack. Orientasi objek membuat sebuah program dibagi atas beberapa entitas objek yang saling berinteraksi. Operasi akan menggunakan stack untuk menyimpan operan dan nilai hasil operasi. 26 | 27 | prefix: 28 | 29 | - i: integer 30 | - l: long 31 | - s: short 32 | - b: byte 33 | - c: character 34 | - f: float 35 | - d: double 36 | - z: boolean 37 | - a: reference 38 | 39 | ## Dialect 40 | 41 | Java tidak memberikan spesifikasi standard untuk merepresentasikan bytecode dalam bentuk teks. Tidak ada tools standard yang digunakan untuk melakukan reassemble (disassemble - assemble) sebuah bytecode. Beberapa tools memiliki format representasi masing-masing. 42 | 43 | - Jasmin 44 | - Soot 45 | -------------------------------------------------------------------------------- /Codes/bytecode/net/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to .NET Common Intermediate Language. 4 | 5 | ## .NET CIL Introduction 6 | 7 | .NET CIL (Common Intermediate Language) adalah Instruction Set yang digunakan oleh .NET Common Language Runtime (CLR). Spesifikasi .NET CIL (instruksi, tipe data, grammar, dsb) diatur berdasarkan standard ECMA-335. 8 | 9 | Sebuah CLR merupakan Process Virtual Machine berbasis stack. Instruksi .NET CIL akan diterjemahkan secara dinamis menjadi kode yang berjalan secara native di host. 10 | 11 | Instruksi dalam .NET CL dapat dibagi menjadi beberapa kategori: 12 | 13 | - Load and Store 14 | - Arithmetic 15 | - Type Conversion 16 | - Object Creation and Manipulation 17 | - Operand Stack Management 18 | - Control Transfer 19 | - Exceptions 20 | - Data and Function Pointers Manipulation. 21 | 22 | ## Computation Model 23 | 24 | .NET CIL berorientasi objek dan berbasis stack. Orientasi objek membuat sebuah program dalam CIL dibagi atas beberapa entitas objek yang saling berinteraksi. Operasi akan menggunakan stack untuk menyimpan operan dan nilai hasil operasi. 25 | 26 | ## Dialect 27 | 28 | - cil 29 | -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/00.structure/0.module.il: -------------------------------------------------------------------------------- 1 | /* 2 | Module 3 | 4 | .NET IL terdiri atas beberapa komponen yang tersusun secara terstruktur 5 | dengan berorientasi objek. 6 | 7 | Assembling: 8 | $ ilasm module.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | /* 15 | .NET Assembly 16 | Assembly adalah unit hasil kompilasi, dapat berupa executable maupun 17 | shared library. 18 | 19 | .NET Module 20 | Module merupakan himpunan kode secara logic di dalam Assembly. 21 | Module terdiri atas beberapa Class. 22 | */ 23 | 24 | /* 25 | Directive .assembly menyatakan metadata sebuah Assembly Reference (AssemblyRef). 26 | Sebuah assembly dapat berupa assembly eksternal maupun assembly untuk module 27 | tersebut. 28 | 29 | Atribut eksternal menyatakan bahwa Assembly berada di luar Assembly ini. 30 | 31 | Assembly diidentifikasi dengan nama file tanpa ekstensi. 32 | */ 33 | 34 | // mscorlib, shared library inti dari .NET 35 | .assembly extern mscorlib 36 | { 37 | // informasi tambahan terkait assembly disebutkan di sini 38 | .publickeytoken = (B7 7A 5C 56 19 34 E0 89 ) 39 | .ver 4:0:0:0 40 | } 41 | 42 | // assembly untuk module ini. 43 | .assembly 'module' 44 | { 45 | .custom instance void [mscorlib]System.Runtime.CompilerServices.RuntimeCompatibilityAttribute::.ctor() = ( 46 | 01 00 01 00 54 02 16 57 72 61 70 4E 6F 6E 45 78 // ....T..WrapNonEx 47 | 63 65 70 74 69 6F 6E 54 68 72 6F 77 73 01 ) // ceptionThrows. 48 | 49 | .hash algorithm 0x00008004 50 | .ver 0:0:0:0 51 | } 52 | 53 | 54 | // Directive .module digunakan sebagai identifikasi module ini. 55 | .module 'program.exe' 56 | 57 | // -- Namespace Declaration -- 58 | .namespace RevID 59 | { 60 | // -- Class Declaration -- 61 | .class public auto ansi beforefieldinit 62 | Program extends [mscorlib]System.Object 63 | { 64 | .method public static hidebysig 65 | void Main() cil managed 66 | { 67 | // entrypoint adalah user-defined method yang dieksekusi pertama 68 | // kali dieksekusi. 69 | .entrypoint 70 | .maxstack 8 71 | ret 72 | } 73 | } 74 | } 75 | 76 | // -- Global Items Declaration -- 77 | // deklarasi semua item yang digunakan global terhadap modul ini. 78 | 79 | // Data 80 | .field public static valuetype CharArray8 resource at AddrResource 81 | .data AddrResource = bytearray(01 02 03 04 00 00 00 00) 82 | .class public explicit CharArray8 83 | extends [mscorlib]System.ValueType { .size 8 } 84 | 85 | // Unmanaged code 86 | .method public static pinvokeimpl("library.dll" cdecl) 87 | int32 native_function () cil managed { } 88 | -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/00.structure/3.instruction.il: -------------------------------------------------------------------------------- 1 | /* 2 | Instruction 3 | 4 | .NET IL terdiri atas beberapa komponen yang tersusun secara terstruktur 5 | dengan berorientasi objek. 6 | 7 | Assembling: 8 | $ ilasm instruction.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | // -- Assembly Declaration -- 15 | .assembly extern mscorlib { auto } 16 | .assembly 'instruction' { } 17 | .module 'program.exe' 18 | 19 | 20 | /* 21 | Instruction 22 | Instruction adalah statement dalam satu baris tunggal. 23 | .NET CIL merupakan sebuah Process VM berbasis Stack. 24 | 25 | Setiap instruksi dapat membutuhkan operan dan menghasilkan nilai. 26 | Operan dan hasil akan menggunakan Stack sebagai penyimpanan sementara. 27 | 28 | Setiap instruksi memiliki format umum sebagai berikut: 29 | 30 | [label:] instruction [parameter] 31 | 32 | Jumlah operan suatu instruksi dapat bervariasi. 33 | Eksekusi instruksi tertentu akan mengambil sekian elemen yang 34 | dibutuhkan dari Stack. 35 | Jika instruksi menghasilkan nilai, maka otomatis nilai tersebut akan 36 | disimpan ke Stack. 37 | 38 | Parameter adalah informasi tambahan selain operan yang digunakan oleh 39 | beberapa instruksi. 40 | */ 41 | 42 | // -- Namespace Declaration -- 43 | .namespace RevID 44 | { 45 | // -- Class Declaration -- 46 | .class public auto ansi beforefieldinit 47 | Program extends [mscorlib]System.Object 48 | { 49 | .method public static hidebysig 50 | void Main () cil managed 51 | { 52 | .entrypoint 53 | .maxstack 8 54 | 55 | // Contoh Instruction dengan parameter 56 | // panggil (call) sebuah method static bernama doSomething() di Class Program 57 | // pada namespace RevID 58 | // dalam hal ini, operan adalah nama method dan instruksi adalah "call" 59 | call void class RevID.Program::doSomething () 60 | 61 | // Contoh Instruction dengan dua Operand 62 | // kalikan 15 dan 9 63 | // dalam hal ini, operan adalah dua bilangan yang tersimpan di stack. 64 | ldc.i4.s 0x09 65 | ldc.i4.s 0x0f 66 | mul 67 | 68 | // Contoh Instruction tanpa Operand dan parameter 69 | // mengeluarkan nilai di puncak Stack. 70 | pop 71 | 72 | ret 73 | } 74 | 75 | 76 | .method public static hidebysig default 77 | void doSomething () cil managed 78 | { 79 | .maxstack 8 80 | ret 81 | } 82 | } 83 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/01.type/1.float.il: -------------------------------------------------------------------------------- 1 | /* 2 | Float 3 | .NET CIL Data Type 4 | 5 | Bilangan pecahan dan operasinya. 6 | 7 | Assembling: 8 | $ ilasm float.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | .assembly extern mscorlib { auto } 15 | .assembly 'float' { } 16 | .module 'program.exe' 17 | 18 | 19 | /* 20 | Floating-Point Number 21 | Floating Point atau bilangan pecahan adalah bilangan yang memiliki komponen pecahan 22 | atau nilai di belakang koma. Definisi bilangan Floating Point untuk sistem 23 | komputer didefinisikan melalui beberapa ketentuan seperti IEEE 7544. 24 | 25 | Dalam sistem komputer atau mesin digital, bilangan pecahan direpresentasikan dalam 26 | rentang yang terbatas. Umumnya, terdapat N kemungkinan nilai untuk floating point: 27 | - bilangan positif: F > 0.0 28 | - bilangan negatif: F < 0.0 29 | - nol: 0.0 30 | - inifinity positif: ∞ 31 | - infinity negatif: -∞ 32 | - NaN (Not a Number) 33 | */ 34 | 35 | .namespace RevID 36 | { 37 | .class public 38 | Program extends [mscorlib]System.Object 39 | { 40 | /* 41 | Sebuah floating-point number dideklarasikan dengna tipe yang sesuai. 42 | 43 | Beberapa tipe yang umum: float32, float64 44 | 45 | Tidak seperti integer, float mendefinisikan bentuk signed dan unsigned. 46 | */ 47 | 48 | // -- Deklarasi variabel global -- 49 | .field public float32 g_r4 50 | .field public float64 g_r8 51 | 52 | .method public static 53 | void Main () cil managed 54 | { 55 | .entrypoint 56 | .maxstack 8 57 | ret 58 | } 59 | 60 | 61 | .method public instance 62 | void _algorithm () cil managed 63 | { 64 | .maxstack 8 65 | 66 | // alokasi local variable 67 | .locals init ( 68 | float32 var_0, 69 | float64 var_1 70 | ) 71 | 72 | ldc.r4 1.0 73 | 74 | /* 75 | Store (simpan) nilai ke variabel akan mengambil nilai di puncak Stack. 76 | Load (muat) nilai dari variabel akan menaruh nilai ke puncak Stack. 77 | 78 | Sebuah variabel dapat diidentifikasi berdasarkan indeks deklarasi dan nama. 79 | Akses melalui indeks hanya berlaku untuk variabel dengan indeks 0 hingga 3. 80 | */ 81 | // simpan nilai ke variabel 82 | stloc.0 83 | stloc var_1 84 | 85 | // memuat nilai dari variabel 86 | ldloc.0 87 | ldloc var_1 88 | 89 | // memuat alamat dari variabel 90 | ldloca var_1 91 | 92 | // load nilai konstan float (float32) 93 | ldc.r4 135 94 | 95 | 96 | ret 97 | } 98 | } 99 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/01.type/2.string.il: -------------------------------------------------------------------------------- 1 | /* 2 | String 3 | .NET CIL Data Type 4 | 5 | String dan operasinya. 6 | 7 | Assembling: 8 | $ ilasm string.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | .assembly extern mscorlib { auto } 15 | .assembly 'string' { } 16 | .module 'program.exe' 17 | 18 | 19 | /* 20 | String 21 | String adalah object berisi deretan huruf, angka, dan simbol-simbol teks 22 | yang tersimpan secara read-only. Mekanisme string di CIL tidak menggunakan 23 | NULL atau karakter spesial lain sebagai batas akhir dari string. 24 | 25 | String bersifat immutable, tidak dapat berubah setelah diciptakan. 26 | */ 27 | 28 | .namespace RevID 29 | { 30 | .class public 31 | Program extends [mscorlib]System.Object 32 | { 33 | 34 | // -- Deklarasi variabel global -- 35 | .field public string g_str 36 | 37 | 38 | .method public static 39 | void Main () cil managed 40 | { 41 | .entrypoint 42 | .maxstack 8 43 | ret 44 | } 45 | 46 | 47 | .method public instance 48 | void _algorithm () cil managed 49 | { 50 | .maxstack 8 51 | 52 | // alokasi local variable 53 | .locals init ( 54 | string var_str 55 | ) 56 | 57 | ldstr "Reversing.ID" 58 | 59 | /* 60 | Store (simpan) nilai ke variabel akan mengambil nilai di puncak Stack. 61 | Load (muat) nilai dari variabel akan menaruh nilai ke puncak Stack. 62 | 63 | Sebuah variabel dapat diidentifikasi berdasarkan indeks deklarasi dan nama. 64 | Akses melalui indeks hanya berlaku untuk variabel dengan indeks 0 hingga 3. 65 | */ 66 | // simpan nilai ke variabel 67 | stloc.0 68 | stloc var_str 69 | 70 | // memuat nilai dari variabel 71 | ldloc.0 72 | ldloc var_str 73 | 74 | // memuat alamat dari variabel 75 | ldloca var_str 76 | 77 | 78 | // mendapatkan panjang string 79 | ldloc.0 80 | callvirt instance int32 string::get_Length() 81 | 82 | // penggabungan (concatenation) 83 | ldstr "Reversing" 84 | ldstr "ID" 85 | call string string::Concat(string, string) 86 | stloc var_str 87 | 88 | 89 | ret 90 | } 91 | } 92 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/01.type/4.structure.il: -------------------------------------------------------------------------------- 1 | /* 2 | Structure 3 | .NET CIL Data Type 4 | 5 | Structure dan tipe komposit. 6 | 7 | Assembling: 8 | $ ilasm structure.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | .assembly extern mscorlib { auto } 15 | .assembly 'structure' { } 16 | .module 'program.exe' 17 | 18 | 19 | /* 20 | Structure 21 | Kumpulan beberapa data dengan tipe yang dapat berlainan dan dianggap sebagai satu kesatuan. 22 | 23 | Structure akan menempati ruang memori secara kontigu. 24 | 25 | Tidak ada batasan banyaknya komponen yang membentuk sebuah struktur. Komponen 26 | struktur atau field dapat berupa tipe dasar (integer, float, dsb) maupun tipe 27 | agregasi lain (struct, array, dsb). 28 | 29 | Setiap komponen dapat diakses (load/store) secara individu. 30 | */ 31 | 32 | .namespace RevID 33 | { 34 | /* 35 | Structure merupakan Class dengan karakteristik tertentu dan digunakan 36 | hanya sebagai data. 37 | 38 | Struktur diturunkan dari [mscorlib]System.ValueType 39 | */ 40 | .class private sequential 41 | book_t extends [mscorlib]System.ValueType 42 | { 43 | .field public string title 44 | .field public string author 45 | .field public string subject 46 | .field public int32 id 47 | } 48 | 49 | .class public 50 | Program extends [mscorlib]System.Object 51 | { 52 | .method public static 53 | void Main () cil managed 54 | { 55 | .entrypoint 56 | .maxstack 8 57 | 58 | // -- alokasi variabel lokal -- 59 | .locals init ( 60 | valuetype RevID.book_t l_book 61 | ) 62 | 63 | // -- instansiasi objek -- 64 | ldloca.s 0 // load address dari variabel lokal 65 | initobj RevID.book_t // inisialisasi objek di alamat tujuan 66 | 67 | // -- akses field -- 68 | // store 69 | ldloca.s 0 70 | ldstr ".NET CIL Reversing" 71 | stfld string RevID.book_t::title 72 | 73 | ldloca.s 0 74 | ldc.i4 6495407 75 | stfld int32 RevID.book_t::id 76 | 77 | // load 78 | ldstr "Book title: {0}" 79 | ldloca.s 0 80 | ldfld string RevID.book_t::title 81 | call void class [mscorlib]System.Console::WriteLine(string, object) 82 | 83 | ldstr "Book id: {0}" 84 | ldloca.s 0 85 | ldfld int32 RevID.book_t::id 86 | box [mscorlib]System.Int32 87 | call void class [mscorlib]System.Console::WriteLine(string, object) 88 | 89 | ret 90 | } 91 | } 92 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/01.type/5.enum.il: -------------------------------------------------------------------------------- 1 | /* 2 | Enumeration 3 | .NET CIL Data Type 4 | 5 | Enumerasi dan nilai dalam rentang tertentu. 6 | 7 | Assembling: 8 | $ ilasm enumeration.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | .assembly extern mscorlib { auto } 15 | .assembly 'enumeration' { } 16 | .module 'program.exe' 17 | 18 | 19 | /* 20 | Enumeration 21 | Sekumpulan konstanta bilangan bulat (integer) yang diidentifikasi dengan token. 22 | Enum adalah value data type, mengandung nilai sendiri dan tidak dapat diwariskan. 23 | */ 24 | 25 | .namespace RevID 26 | { 27 | /* 28 | Enum merupakan Class dengan karakteristik tertentu dan digunakan 29 | hanya sebagai tipe data. 30 | 31 | Enum diturunkan dari [mscorlib]System.Enum 32 | */ 33 | .class private 34 | month_t extends [mscorlib]System.Enum 35 | { 36 | .field public specialname rtspecialname int32 value__ 37 | .field public static literal valuetype RevID.month_t Jan = int32(0) 38 | .field public static literal valuetype RevID.month_t Feb = int32(1) 39 | .field public static literal valuetype RevID.month_t Mar = int32(2) 40 | .field public static literal valuetype RevID.month_t Apr = int32(3) 41 | .field public static literal valuetype RevID.month_t May = int32(4) 42 | .field public static literal valuetype RevID.month_t Jun = int32(5) 43 | .field public static literal valuetype RevID.month_t Jul = int32(6) 44 | .field public static literal valuetype RevID.month_t Aug = int32(7) 45 | .field public static literal valuetype RevID.month_t Sep = int32(8) 46 | .field public static literal valuetype RevID.month_t Oct = int32(9) 47 | .field public static literal valuetype RevID.month_t Nov = int32(10) 48 | .field public static literal valuetype RevID.month_t Dec = int32(11) 49 | } 50 | 51 | .class public 52 | Program extends [mscorlib]System.Object 53 | { 54 | .method public static 55 | void Main () cil managed 56 | { 57 | .entrypoint 58 | .maxstack 8 59 | 60 | // -- alokasi variabel lokal -- 61 | .locals init ( 62 | valuetype RevID.month_t ls_month 63 | ) 64 | 65 | // -- assignment nilai -- 66 | ldc.i4.s 7 // month_t::Aug 67 | stloc.0 68 | 69 | ret 70 | } 71 | } 72 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/02.operation/1.bitwise.il: -------------------------------------------------------------------------------- 1 | /* 2 | Bitwise 3 | 4 | Operasi bitwise pada .NET CL 5 | 6 | Assembling: 7 | $ ilasm bitwise.il 8 | 9 | */ 10 | 11 | //----------------------------------------------------------------------------- 12 | 13 | .assembly extern mscorlib { auto } 14 | .assembly 'bitwise' { } 15 | .module 'program.exe' 16 | 17 | 18 | /* 19 | Bitwise 20 | Operasi bitwise adalah operasi logik yang dilakukan pada level bit secara 21 | individual, bit demi bit. Operasi bitwise dilakukan terhadap integer. 22 | 23 | Beberapa operasi bitwise: 24 | - AND 25 | - OR 26 | - XOR (exclusive or) 27 | - NOT 28 | - SHL (shift left) 29 | - SHR (shift right) 30 | 31 | Pada operasi shift, operan 2 menunjukkan pergeseran dalam bit yang memiliki 32 | nilai maksimum sebanyak jumlah bit dalam operan 1. 33 | */ 34 | 35 | .namespace RevID 36 | { 37 | .class public 38 | Program extends [mscorlib]System.Object 39 | { 40 | .method public static 41 | void Main() cil managed 42 | { 43 | .entrypoint 44 | .maxstack 8 45 | ret 46 | } 47 | 48 | .method public instance 49 | void _algorithm () cil managed 50 | { 51 | .maxstack 8 52 | 53 | // AND 54 | ldc.i4 9 55 | ldc.i4 15 56 | and // 9 AND 15 57 | 58 | // OR 59 | ldc.i4 9 60 | ldc.i4 15 61 | or // 9 OR 15 62 | 63 | // XOR 64 | ldc.i4 9 65 | ldc.i4 15 66 | xor // 9 XOR 15 67 | 68 | // NOT 69 | ldc.i4 135 70 | not // NOT 135 71 | 72 | // SHL 73 | ldc.i4 9 74 | ldc.i4 15 75 | shl // 9 << 15 76 | 77 | // terkadang, operan 2 yang menunjukkan jumlah bit shift 78 | // 79 | 80 | // SHR 81 | ldc.i4 9 82 | ldc.i4 15 83 | shr // 9 >> 15 84 | 85 | ldc.i4 9 86 | ldc.i4 15 87 | shr.un // 9 >> 15 88 | 89 | ret 90 | } 91 | } 92 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/02.operation/3.comparison.il: -------------------------------------------------------------------------------- 1 | /* 2 | Comparison 3 | 4 | Mekanisme perbandingan nilai. 5 | 6 | Assembling: 7 | $ ilasm comparison.il 8 | 9 | */ 10 | 11 | //----------------------------------------------------------------------------- 12 | 13 | .assembly extern mscorlib { auto } 14 | .assembly 'comparison' { } 15 | .module 'program.exe' 16 | 17 | 18 | /* 19 | Comparison 20 | Comparison (perbandingan) adalah sekelompok instruksi untuk membandingkan dua 21 | nilai. Perbandingan di .NET CIL secara spesifik menguji hubungan kedua nilai 22 | apakah sama (equal), lebih besar (greater), maupun lebih kecil (less) dan 23 | menghasilkan nilai 1 jika kondisi terpenuhi. 24 | 25 | Pada .NET CIL, tidak ada flag tertentu selain kondisi terpenuhi dan tidak. 26 | Hasil dari perbandingan tidak menjadi mandatory dalam percabangan. 27 | */ 28 | 29 | .namespace RevID 30 | { 31 | .class public 32 | Program extends [mscorlib]System.Object 33 | { 34 | .method public static 35 | void Main() cil managed 36 | { 37 | .entrypoint 38 | .maxstack 8 39 | ret 40 | } 41 | 42 | .method public instance 43 | void _algorithm () cil managed 44 | { 45 | .maxstack 8 46 | 47 | // -- Arithmetic -- 48 | // CEQ (Compare if equal) 49 | // memeriksa apakah kedua operan memiliki nilai yang sama 50 | // menghasilkan 1 (tipe int32) jika kedua value sama, atau 0 jika 51 | // sebaliknya 52 | ldc.i4 4 53 | ldc.i4 3 54 | ceq // 4 == 3 ? 55 | 56 | // CGT (Compare if greater) 57 | // memeriksa apakah operan pertama lebih besar daripada operan kedua 58 | // menghasilkan 1 (tipe int32) jika operan pertama lebih besar, 59 | // atau 0 jika sebaliknya 60 | ldc.i4 4 61 | ldc.i4 3 62 | cgt // 4 > 3 ? 63 | 64 | // memeriksa kedua bilangan yang unsigned 65 | ldc.i4 4 66 | ldc.i4 3 67 | cgt.un 68 | 69 | // CLT (Compare if less than) 70 | // memeriksa apakah operan pertama lebih kecil daripada operan kedua 71 | // menghasilkan 1 (tipe int32) jika operan pertama kecil besar, 72 | // atau 0 jika sebaliknya 73 | ldc.i4 4 74 | ldc.i4 3 75 | clt // 4 < 3 ? 76 | 77 | // memeriksa kedua bilangan yang unsigned 78 | ldc.i4 4 79 | ldc.i4 3 80 | clt.un 81 | 82 | 83 | ret 84 | } 85 | } 86 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/02.operation/decision/if-else.il: -------------------------------------------------------------------------------- 1 | /* 2 | If-Else 3 | Decision-Making 4 | 5 | Percabangan, pengambilan keputusan dengan pengecekan kondisi tunggal, aksi, 6 | dan alternatifnya 7 | 8 | Assembling: 9 | $ ilasm if-else.il 10 | 11 | */ 12 | 13 | //----------------------------------------------------------------------------- 14 | 15 | // -- Assembly Declaration -- 16 | .assembly extern mscorlib { auto } 17 | .assembly 'branching' { } 18 | .module 'program.exe' 19 | 20 | 21 | /* 22 | Branching (percabangan) adalah perpindahan eksekusi ke sekumpulan instruksi 23 | menggunakan satu atau lebih instruksi branching. 24 | 25 | Tujuan: 26 | implementasi statement "If-Else" 27 | percabangan sederhana yang mengarahkan ke sekelompok instruksi jika kondisi 28 | terpenuhi. 29 | 30 | Bentuk umum: 31 | if (condition) then 32 | do_action 33 | else 34 | do_alternative_action 35 | 36 | Padanan: 37 | if not (condition) then goto else; 38 | do_action 39 | goto end 40 | else: 41 | do_alternative_action 42 | end: 43 | 44 | */ 45 | 46 | .namespace RevID 47 | { 48 | .class public 49 | Program extends [mscorlib]System.Object 50 | { 51 | .method public static 52 | void Main() cil managed 53 | { 54 | .entrypoint 55 | .maxstack 8 56 | ret 57 | } 58 | 59 | .method public instance 60 | void _algorithm () cil managed 61 | { 62 | .maxstack 8 63 | 64 | .locals init ( 65 | int32 var 66 | ) 67 | 68 | ldc.i4 0 69 | stloc var 70 | 71 | 72 | /* 73 | if (var == 2) 74 | { 75 | var = 1; 76 | } 77 | else 78 | { 79 | var = 0; 80 | } 81 | 82 | periksa apakah kondisi terpenuhi dan lakukan percabangan jika false 83 | (negasi dari kondisi terpenuhi). 84 | ini adalah implementasi efisien karena hanya butuh satu percabangan. 85 | */ 86 | 87 | // pemeriksaan kondisi 88 | ldloc var 89 | ldc.i4 2 90 | bne.un else // berpindah jika var != 2 91 | 92 | // eksekusi do_action karena kondisi (asli) terpenuhi 93 | ldc.i4 1 94 | stloc var 95 | 96 | // hindari block untuk "else" atau aksi alternatif 97 | br end 98 | 99 | else: 100 | // eksekusi do_alternative_action karena kondisi (asli) tak terpenuhi. 101 | ldc.i4 0 102 | stloc var 103 | 104 | end: 105 | // instruksi ini akan dieksekusi terlepas dari hasil percabangan. 106 | 107 | ret 108 | } 109 | } 110 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/02.operation/decision/if.il: -------------------------------------------------------------------------------- 1 | /* 2 | If 3 | Decision-Making 4 | 5 | Percabangan, pengambilan keputusan dengan pengecekan kondisi tunggal. 6 | 7 | Assembling: 8 | $ ilasm if.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | // -- Assembly Declaration -- 15 | .assembly extern mscorlib { auto } 16 | .assembly 'branching' { } 17 | .module 'program.exe' 18 | 19 | 20 | /* 21 | Branching (percabangan) adalah perpindahan eksekusi ke sekumpulan instruksi 22 | menggunakan satu atau lebih instruksi branching. 23 | 24 | Tujuan: 25 | implementasi statement "If-Then" 26 | percabangan sederhana yang mengarahkan ke sekelompok instruksi jika kondisi 27 | terpenuhi. 28 | 29 | Bentuk umum: 30 | if (condition) then 31 | do_action 32 | 33 | Padanan: 34 | if not (condition) then goto end; 35 | do_action 36 | end: 37 | 38 | */ 39 | 40 | .namespace RevID 41 | { 42 | .class public 43 | Program extends [mscorlib]System.Object 44 | { 45 | .method public static 46 | void Main() cil managed 47 | { 48 | .entrypoint 49 | .maxstack 8 50 | ret 51 | } 52 | 53 | .method public instance 54 | void _algorithm () cil managed 55 | { 56 | .maxstack 8 57 | 58 | .locals init ( 59 | int32 var 60 | ) 61 | 62 | ldc.i4 0 63 | stloc var 64 | 65 | 66 | /* 67 | if (var == 2) 68 | { 69 | var = 1; 70 | } 71 | 72 | periksa apakah kondisi terpenuhi dan lakukan percabangan jika false 73 | (negasi dari kondisi terpenuhi). 74 | ini adalah implementasi efisien karena hanya butuh dua percabangan. 75 | */ 76 | 77 | // pemeriksaan kondisi 78 | ldloc var 79 | ldc.i4 2 80 | bne.un end // berpindah jika var != 2 81 | 82 | // eksekusi do_action karena kondisi (asli) terpenuhi 83 | ldc.i4 1 84 | stloc var 85 | 86 | end: 87 | // instruksi ini akan dieksekusi terlepas dari hasil percabangan. 88 | 89 | ret 90 | } 91 | } 92 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/02.operation/decision/nested-if.il: -------------------------------------------------------------------------------- 1 | /* 2 | Nested-If 3 | Decision-Making 4 | 5 | Pemilihan keputusan secara bersarang. 6 | 7 | Assembling: 8 | $ ilasm nested-if.il 9 | 10 | */ 11 | 12 | //----------------------------------------------------------------------------- 13 | 14 | // -- Assembly Declaration -- 15 | .assembly extern mscorlib { auto } 16 | .assembly 'branching' { } 17 | .module 'program.exe' 18 | 19 | 20 | /* 21 | Branching (percabangan) adalah perpindahan eksekusi ke sekumpulan instruksi 22 | menggunakan satu atau lebih instruksi branching. 23 | 24 | Tujuan: 25 | implementasi percabangan bersarang. 26 | Sebuah percabangan dapat didefinisikan di dalam blok aksi percabangan lain. 27 | 28 | Bentuk umum: 29 | if (condition_1) then 30 | do_action_1 31 | if (condition_2) then 32 | do_action_2 33 | 34 | */ 35 | 36 | .namespace RevID 37 | { 38 | .class public 39 | Program extends [mscorlib]System.Object 40 | { 41 | .method public static 42 | void Main() cil managed 43 | { 44 | .entrypoint 45 | .maxstack 8 46 | ret 47 | } 48 | 49 | .method public instance 50 | void _algorithm () cil managed 51 | { 52 | .maxstack 8 53 | 54 | .locals init ( 55 | int32 var1, 56 | int32 var2 57 | ) 58 | 59 | ldc.i4 0 60 | stloc var1 61 | 62 | ldc.i4 0 63 | stloc var2 64 | 65 | /* 66 | Perlu dicatat bahwa pemeriksaan kondisi condition_2 hanya terjadi jika condition_1 terpenuhi. 67 | Dapat dikatakan bahwa pemeriksaan condition_2 berada pada block sama dengan do_action_1 68 | 69 | if (var1 == 0) 70 | { 71 | var1 = 10; 72 | if (var2 == 0) 73 | var2 = 20; 74 | } 75 | */ 76 | 77 | // pemeriksaan kondisi condition_1 78 | ldloc var1 79 | ldc.i4 0 80 | bne.un end // berpindah jika var1 != 0 81 | 82 | // eksekusi do_action_1 83 | ldc.i4 10 84 | stloc var1 // var1 = 10 85 | 86 | // pemeriksaan kondisi condition_2 87 | ldloc var2 88 | ldc.i4 0 89 | bne.un end // berpindah jika var2 != 0 90 | 91 | // eksekusi do_action_2 92 | ldc.i4 20 93 | stloc var2 94 | 95 | end: 96 | // instruksi ini akan dieksekusi terlepas dari hasil percabangan. 97 | 98 | ret 99 | } 100 | } 101 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/04.object/inheritance/3.castclass.il: -------------------------------------------------------------------------------- 1 | /* 2 | Class Casting 3 | 4 | Typecast objek menjadi tipe lain yang berhubungan. 5 | 6 | Assembling: 7 | $ ilasm classcast.il 8 | 9 | */ 10 | 11 | //----------------------------------------------------------------------------- 12 | 13 | .assembly extern mscorlib { auto } 14 | .assembly 'classcast' { } 15 | .module 'program.exe' 16 | 17 | 18 | /* 19 | Sebuah objek merupakan instansiasi dari sebuah Class. 20 | 21 | Instruksi castclass akan mengubah tipe suatu objek di puncak Stack menjadi 22 | tipe lain yang disebutkan. 23 | 24 | Instruksi ini hanya berhasil jika objek memiliki hubungan warisan dengan tipe 25 | tujuan. Apabila proses casting gagal dilakukan maka CLR akan melempar Exception 26 | System.InvalidCastException. 27 | */ 28 | 29 | .namespace RevID 30 | { 31 | .class public 32 | Program extends [mscorlib]System.Object 33 | { 34 | .method public static 35 | void Main (string [] args) cil managed 36 | { 37 | .entrypoint 38 | .maxstack 8 39 | 40 | .locals init( 41 | class RevID.Derived derived 42 | ) 43 | 44 | // instansiasi objek 45 | newobj instance void class RevID.Derived::'.ctor' () 46 | stloc derived 47 | 48 | // -- Cast Class -- 49 | ldloc derived 50 | castclass class RevID.Base 51 | 52 | ldnull 53 | ceq 54 | brtrue Exit 55 | 56 | ldstr "All Checks!" 57 | call void class [mscorlib]System.Console::WriteLine(string) 58 | 59 | Exit: 60 | ret 61 | } 62 | } 63 | 64 | //----------------------------------------------------------------------------- 65 | 66 | // Deklarasi Class induk 67 | .class public 68 | Base extends [mscorlib]System.Object 69 | { 70 | .method public specialname rtspecialname instance 71 | void '.ctor' () cil managed 72 | { 73 | .maxstack 8 74 | 75 | ldarg.0 76 | call instance void object::'.ctor' () 77 | 78 | ret 79 | } 80 | } 81 | 82 | // Deklarasi Class turunan 83 | .class public 84 | Derived extends RevID.Base 85 | { 86 | .method public specialname rtspecialname instance 87 | void '.ctor' () cil managed 88 | { 89 | .maxstack 8 90 | 91 | ldarg.0 92 | call instance void RevID.Base::'.ctor' () 93 | 94 | ret 95 | } 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/04.object/structure/2.method-overload.il: -------------------------------------------------------------------------------- 1 | /* 2 | Method Overload 3 | 4 | Assembling: 5 | $ ilasm method-overload.il 6 | 7 | */ 8 | 9 | //----------------------------------------------------------------------------- 10 | 11 | .assembly extern mscorlib { auto } 12 | .assembly 'method-overload' { } 13 | .module 'program.exe' 14 | 15 | 16 | /* 17 | Method Overload 18 | C# dan .NET CL mendukung pendefinisian ulang (overload) method sehingga 19 | beberapa method dapat berbagi nama yang sama selama memiliki signature yang 20 | berbeda. 21 | 22 | 23 | Type Signature 24 | Type Signature atau Type Annotation menyatakan tipe yang menjadi penanda 25 | suatu method, identifikasi unik suatu method. 26 | Terdiri atas dua komponen utama: 27 | - tipe return value 28 | - method reference 29 | - tipe dan jenis (value, reference, output) tiap argumen 30 | */ 31 | 32 | .namespace RevID 33 | { 34 | .class public 35 | Program extends [mscorlib]System.Object 36 | { 37 | .method public static 38 | void Main (string [] args) cil managed 39 | { 40 | .entrypoint 41 | .maxstack 8 42 | 43 | // -- Pemanggilan Method -- 44 | // method tanpa argument 45 | call void class RevID.Program::mtd_overloaded () 46 | 47 | // method dengan argument int32 48 | ldc.i4 135 49 | call void class RevID.Program::mtd_overloaded (int32) 50 | 51 | // method dengan argument string 52 | ldstr "Reversing.ID" 53 | call void class RevID.Program::mtd_overloaded (string) 54 | 55 | ret 56 | } 57 | 58 | // Method tanpa argument 59 | .method public static 60 | void mtd_overloaded () cil managed 61 | { 62 | .maxstack 8 63 | ret 64 | } 65 | 66 | // Method dengan argument int32 67 | .method public static 68 | void mtd_overloaded (int32 arg) cil managed 69 | { 70 | .maxstack 8 71 | ret 72 | } 73 | 74 | // Method dengan argument string 75 | .method public static 76 | void mtd_overloaded (string arg) cil managed 77 | { 78 | .maxstack 8 79 | ret 80 | } 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/05.exception/3.defined.il: -------------------------------------------------------------------------------- 1 | /* 2 | User-Defined Exception 3 | 4 | Assembling: 5 | $ ilasm defined.il 6 | 7 | */ 8 | 9 | //----------------------------------------------------------------------------- 10 | 11 | .assembly extern mscorlib { auto } 12 | .assembly 'defined' { } 13 | .module 'program.exe' 14 | 15 | 16 | /* 17 | .NET CIL telah menyertakan beragam Class yang dapat digunakan untuk 18 | merepresentasikan kondisi Exception. Namun, terkadang perlu didefinisikan 19 | Exception baru untuk merepresentasikan event yang belum ada. 20 | 21 | Sebuah Exception haruslah bertipe Class Exception. Dengan demikian, untuk 22 | membuat tipe Exception baru, Exception harus diturunkan dari Class Exception. 23 | */ 24 | 25 | .namespace RevID 26 | { 27 | .class public 28 | Program extends [mscorlib]System.Object 29 | { 30 | /* 31 | Exception baru dapat didefinisikan di dalam atau di luar namespace. 32 | */ 33 | 34 | .method public static 35 | void Main() cil managed 36 | { 37 | .entrypoint 38 | .maxstack 8 39 | 40 | .locals init ( 41 | class RevIDException ex 42 | ) 43 | 44 | // Idealnya, semua kode yang dapat memicu Exception harus 45 | // diletakkan di dalam try agar dapat diteruskan ke handler sesuai 46 | .try { 47 | 48 | // Exception yang dilempar harus dibangun atau diturunkan dari 49 | // System.Exception 50 | ldstr "Raise (User-Defined) Exception" 51 | newobj instance void class RevIDException::'.ctor' (string) 52 | throw 53 | } 54 | // Daftar penanganan Exception. 55 | catch class RevIDException { 56 | // simpan exception ke variabel lokal 57 | stloc ex 58 | 59 | ldloc ex 60 | callvirt instance string class [mscorlib]System.Exception::get_Message () 61 | call void class [mscorlib]System.Console::WriteLine (string) 62 | 63 | // keluar dari bagian kode yang terproteksi (protected region) 64 | leave Exit 65 | } 66 | 67 | Exit: 68 | ret 69 | } 70 | } 71 | } 72 | 73 | // Exception yang didefinisikan di luar namespace RevID 74 | .class public 75 | RevIDException extends [mscorlib]System.Exception 76 | { 77 | .method public specialname rtspecialname instance 78 | void '.ctor' (string msg) cil managed 79 | { 80 | .maxstack 8 81 | 82 | ldarg.0 83 | ldarg.1 84 | call instance void class [mscorlib]System.Exception::'.ctor' (string) 85 | 86 | ret 87 | } 88 | } -------------------------------------------------------------------------------- /Codes/bytecode/net/cil/06.features/pinvoke.il: -------------------------------------------------------------------------------- 1 | /* 2 | Platform Invoke 3 | 4 | Assembling: 5 | $ilasm pinvoke.il 6 | 7 | */ 8 | 9 | //----------------------------------------------------------------------------- 10 | 11 | .assembly extern mscorlib { auto } 12 | .assembly 'call' { } 13 | .module 'program.exe' 14 | 15 | 16 | /* 17 | P/Invoke 18 | P/Invoke, atau Platform Invoke, adalah teknologi yang memungkinkan aplikasi 19 | managed code untuk mengakses struct, callback, dan function di library unmanaged. 20 | 21 | Unmanaged code yang umumnya terletak di library eksternal akan dipetakan sebagai 22 | ke dalam managed code sebagai method maupun struktur yang ekivalen. Selanjutnya, 23 | pemanggilan terhadap method tersebut akan diteruskan kepada kode yang sesuai. 24 | */ 25 | 26 | .namespace RevID 27 | { 28 | .class public 29 | Program extends [mscorlib]System.Object 30 | { 31 | // -- PInvoke Declaration -- 32 | // Memetakan MessageBox di User32.dll sebagai MsgBox 33 | .method assembly static pinvokeimpl ("User32.dll" as "MessageBox" autochar winapi) 34 | int32 MsgBox (int32 hwnd, string text, string caption, unsigned int32 tipe) cil managed preservesig 35 | { } 36 | 37 | .method public static 38 | void Main() cil managed 39 | { 40 | .entrypoint 41 | .maxstack 8 42 | 43 | // Memanggil MsgBox, meneruskan ke MessageBox 44 | ldc.i4.0 45 | ldstr "Text" 46 | ldstr "Caption" 47 | ldc.i4.0 48 | call int32 class RevID.Program::MsgBox(int32, string, string, unsigned int32) 49 | 50 | pop 51 | ret 52 | } 53 | } 54 | } -------------------------------------------------------------------------------- /Codes/bytecode/php/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Introduction to PHP bytecode 4 | 5 | ## Dialect 6 | 7 | - bcompiler 8 | - vld -------------------------------------------------------------------------------- /Codes/bytecode/python/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Python bytecode 4 | 5 | ## Python Bytecode 6 | 7 | Python Bytecode adalah Instruction Set yang digunakan oleh Python Interpreter. 8 | 9 | Python interpreter adalah Process Virtual Machine berbasis stack. Instruksi Python akan diterjemahkan secara dinamis menjadi kode yang berjalan secara native di host. 10 | 11 | ## Computation Model 12 | 13 | Berdasarkan referensi CPython dengan bytecode untuk Python versi 3.x 14 | 15 | CPython menggunakan tiga tipe stack: 16 | - Call Stack 17 | - Evaluation Stack 18 | - Block Stack 19 | 20 | `Call Stack`, berisi informasi tentang fungsi, disebut pula Frame, yang dipanggil secara berurutan. Apabila sebuah fungsi dipanggil, maka Frame baru akan diletakkan di puncak Stack. Apabila fungsi berakhir, maka Frame terkait akan diambil. Dengan menelusuri tumpukan Frame yang ada, alur eksekusi sebuah program dapat ditelusuri. 21 | 22 | `Evaluation Stack` atau `Data Stack`, terdapat di setiap Frame. Evaluation Stack digunakan oleh fungsi terkait untuk menyimpan argumen yang diperlukan oleh sebuah instruksi dan juga nilai kembalian yang dihasilkan. 23 | 24 | `Block Stack`, terdapat di setiap Frame. Block Stack digunakan untuk melacak banyaknya Block (loop, try/except, with, dsb) yang aktif. 25 | 26 | Terdapat tiga jenis block (namespace): module, function body, dan class definition. 27 | 28 | ## Vendor 29 | 30 | Terdapat beberapa implementasi Python: 31 | - CPython 32 | - Jython 33 | - IronPython 34 | 35 | Namun masing-masing menerima format yang didefinisikan oleh CPython atau model yang menjadi rujukan. -------------------------------------------------------------------------------- /Codes/bytecode/ruby/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Ruby bytecode 4 | 5 | ## Ruby Bytecode 6 | 7 | Ruby Bytecode adalah Instruction Set yang digunakan oleh Ruby Interpreter. 8 | 9 | Ruby interpreter adalah Process Virtual Machine berbasis stack. Instruksi Ruby akan diterjemahkan secara dinamis menjadi kode yang berjalan secara native di host. 10 | 11 | ## Computation Model 12 | 13 | ## Dialect 14 | 15 | Ruby tidak memberikan spesifikasi standard untuk merepresentasikan bytecode dalam bentuk teks. Tidak ada tools standard yang digunakan untuk melakukan reassembler (disassemble - assemble) sebuah bytecode. 16 | 17 | Daftar berikut adalah implementasi Ruby dengan bytecode masing-masing: 18 | 19 | - rubinius 20 | - tinyrb 21 | - yarv -------------------------------------------------------------------------------- /Codes/bytecode/swift/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Introduction to SWIFT bytecode. 4 | 5 | ## Dialect 6 | 7 | - sil -------------------------------------------------------------------------------- /Codes/bytecode/web-asm/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Introduction to Web Assembly 4 | 5 | ## Dialect 6 | 7 | - wasm -------------------------------------------------------------------------------- /Codes/control-flows.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | General Overview of Program Control Flow 4 | 5 | ## What is Control Flow? 6 | 7 | `Control flow` atau flow of control adalah pengaturan urutan eksekusi atau evaluasi dari instruksi (statement). 8 | 9 | ## Categories 10 | 11 | Secara umum, control-flow dapat dikategorikan berdasarkan efek: 12 | 13 | - Meneruskan eksekusi instruksi ke lokasi berbeda (unconditional jump) 14 | - Eksekusi sekelompok instruksi ketika sebuah kondisi terpenuhi (choice atau branch) 15 | - Eksekusi sekelompok instruksi sebanyak nol kali atau lebih dalam kondisi tertentu (loop, modifikasi dari conditional jump). 16 | - Eksekusi sekelompok instruksi sebagai satu kesatuan aksi (subroutine, function). 17 | - Menghentikan program, mencegah adanya eksekusi selanjutnya. 18 | 19 | ## Primitives 20 | 21 | Untuk dapat mengubah alur eksekusi instruksi, terdapat setidaknya dua komponen dalam bahasa assembly (serta banyak low-level code lain), yaitu: 22 | 23 | - *Jumps*: statement untuk berpindah posisi, baik berupa unconditional maupun conditional. 24 | - *Labels*: nama atau angka yang secara eksplisit diberikan kepada posisi tertentu dalam kode sehingga dapat digunakan sebagai acuan untuk berpindah sehingga eksekusi selanjutnya akan dimulai dari posisi tersebut. 25 | 26 | ## Branch 27 | 28 | Percabangan (branch) adalah tindakan perubahan lokasi atau urutan ke barisan instruksi di lokasi lain sebagai hasil dari evaluasi kondisi. 29 | 30 | Jika dilihat dari sisi bahasa tingkat tinggi, terdapat beberapa model percabangan antara lain: 31 | 32 | - If-Then-(Else) 33 | - Switch-Case 34 | 35 | ### If-Then-(Else) Statements 36 | 37 | Percabangan yang mengarahkan ke sekelompok instruksi jika kondisi terpenuhi. Percabangan dapat pula terdiri dari beberapa alternatif aksi, masing-masing dengan kondisi yang saling komplemen. 38 | 39 | ### Switch-Case Statements 40 | 41 | Percabangan dengan beragam kondisi alternatif berdasarkan nilai. Sebuah Jump Table digunakan untuk menentukan blok target yang akan dieksekusi ketika melompat. 42 | 43 | ## Loops 44 | 45 | Perulangan (loop) adalah variasi dari percabangan. Loop adalah serangkaian instruksi yang ditulis sekali namun dapat dieksekusi berkali-kali secara berturut-turut. 46 | 47 | Jika dilihat dari sisi bahasa tingkat tinggi, terdapat beberapa model perulangan antara lain: 48 | 49 | - For (Count-Controlled Loop) 50 | - While (Condition-Controlled Loop) 51 | 52 | ### Count-Controlled Loops 53 | 54 | Perulangan yang dikendalikan menggunakan sebuah counter untuk mengeksekusi blok sebanyak sekian kali. Nilai counter berubah seiring waktu dengan setiap langkah perulangan membuat counter mendekati sebuah nilai ambang batas. 55 | 56 | ### Condition-Controlled Loops 57 | 58 | Perulangan yang dikendalikan oleh evaluasi kondisi. Perulangan terjadi apabila suatu kondisi terpenuhi. Evaluasi kondisi dapat dilakukan di awal atau di akhir blok perulangan. -------------------------------------------------------------------------------- /Codes/interrupt-exception.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Interrupt & Exception 4 | 5 | ## Interrupt 6 | 7 | Interrupt adalah signal dari perangkat eksternal (umumnya I/O) kepada processor sebagai pertanda bahwa terdapat suatu kejadian yang harus ditangani oleh processor. 8 | 9 | Kemunculan Interrupt tidak mengubah flow eksekusi suatu program. 10 | 11 | Ketika processor mendapat Interrupt, processor akan menghentikan sementara semua eksekusi yang sedang terjadi kemudian mencari handler yang sesuai di Interrupt Table untuk menangani Interrupt tersebut. Selanjutnya, eksekusi normal akan dilanjutkan. 12 | 13 | ## Exception 14 | 15 | Exception adalah signal yang dibangkitkan ketika suatu kesalahan atau kondisi anomali terjadi saat eksekusi instruksi. Beberapa kesalahan atau anomali yang umum antara lain pembagian dengan nol, akses memori secara ilegal, dsb 16 | 17 | Kemunculan Exception memiliki kemungkinan untuk mengubah flow eksekusi suatu program. 18 | 19 | Exception terdiri atas tiga jenis: Fault, Trap, dan Abort. 20 | -------------------------------------------------------------------------------- /Codes/ir-code/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Intermediate Representation. 4 | 5 | ## Intermediate Representation 6 | 7 | `Intermediate Representation` (IR) adalah representasi yang digunakan secara internal oleh compiler, virtual machine, atau tools analisis untuk mengabstraksi instruksi. 8 | 9 | Untuk merepresentasikan sebuah instruksi spesifik dari platform, IR mendekomposisi instruksi spesifik menjadi satu atau lebih instruksi generik yang ekivalen. IR tidak terikat ke platform tertentu. 10 | 11 | ## IR dan Compiler 12 | 13 | IR digunakan secara intensif oleh infrastruktur compiler modern. Compiler dapat dibagi menjadi tiga komponen: 14 | 15 | - Front End 16 | - Middle End 17 | - Back end 18 | 19 | `Front End` melakukan parsing terhadap source code, melakukan translasi dan menghasilkan IR yang sesuai. Sebagai bentuk antara (intermediate), IR akan mengalami pemrosesan (analisis, optimisasi, transformasi, dan instrumentasi) oleh `Middle End` untuk menghasilkan kode IR yang efektif dan efisien. Terakhir, `Back End` akan menerjemahkan IR menjadi kode instruksi mesin. 20 | 21 | Selain compiler, IR digunakan oleh beberapa tools untuk merepresentasikan instruksi, seperti emulator. 22 | 23 | ## IR dan Emulator 24 | 25 | IR digunakan secara intensif oleh emulator. 26 | 27 | ## IR dan Decompiler 28 | 29 | IR digunakan secara intensif oleh decompiler untuk membalikkan proses yang terjadi dalam tahap kompilasi. Decompiler dapat dibagi menjadi tiga komponen: 30 | 31 | - Front End 32 | - Middle End 33 | - Back End 34 | 35 | ## Advantages 36 | 37 | Memahami Intermediate Representation (dari sebuah platform) memberikan keuntungan bagi Reverse Engineer dan Developer. Penguasaan IR memberikan pemahaman terhadap transformasi yang terjadi di tools dan memberikan keleluasaan untuk melakukan analisis suatu komponen program secara terprogram. -------------------------------------------------------------------------------- /Codes/ir-code/llvm/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to LLVM Intermediate Representation (IR) 4 | 5 | ## LLVM IR Introduction 6 | 7 | LLVM IR adalah Intermediate Representation yang digunakan oleh LLVM Compiler Infrastructure. 8 | 9 | LLVM adalah Compiler Infrastructure yang digunakan untuk membangun compiler, menganalisis dan mentransformasi kode program pada fase-fase kompilasi. 10 | 11 | Sebagai abstraksi komponen-komponen program, LLVM IR dapat dioperasikan dalam tiga wujud berbeda: 12 | 13 | - In-Memory Data Structure 14 | - Bitcode File (.bc) 15 | - Text File (.ll) 16 | 17 | Ketiga wujud LLVM IR digunakan untuk pemrosesan dan analisis dalam tiga kondisi berbeda. 18 | 19 | `In-Memory Data Structure` adalah wujud IR sebagai struktur data yang hidup di memory, Abstract Syntax Tree yang dihasilkan dari proses parse dan translasi source code. 20 | 21 | `Bitcode File` adalah representasi IR secara biner yang dituliskan ke dalam sebuah file menggunakan format yang space-efficient. Wujud ini berguna ketika digunakan oleh tools analisis maupun LLVM Pass. 22 | 23 | `Text File` adalah representasi IR dalam notasi yang dapat dibaca oleh manusia. 24 | 25 | ## LLVM Infrastructure Tools 26 | 27 | LLVM merupakan sebuah infrastruktur pengembangan compiler dan tools analisis program. Sebagai representasi kode program, LLVM IR diolah oleh beragam tools yang dibangun di atas infrastruktur LLVM. 28 | 29 | Beberapa jenis tools yang dapat dikembangkan di atas LLVM dapat dilihat pada [tools](_tools.md). 30 | 31 | ## LLVM IR Layout 32 | 33 | LLVM IR merupakan abstraksi dari sebuah program. Komponen-komponen program dipetakan menjadi komponen-komponen abstrak di LLVM yang independen terhadap machine code spesifik. 34 | 35 | Untuk informasi lebih lanjut, lihat [layout](_layout.md) 36 | 37 | ## LLVM Pass 38 | 39 | Pass adalah unit transformasi dan optimisasi di infrastruktur LLVM. Pass menerima LLVM IR dan melakukan `analisis` serta `transformasi` sesuai dengan aturan yang didefinisikan untuk menghasilkan LLVM IR yang lebih optimal. 40 | 41 | LLVM Pass Framework sangat customizable untuk mengakomodir berbagai keperluan. 42 | 43 | Untuk informasi lebih lanjut, lihat [pass](_pass.md) -------------------------------------------------------------------------------- /Codes/ir-code/llvm/_layout.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | LLVM Intermediate-Representation Layout 4 | 5 | ## Overview 6 | 7 | LLVM IR merupakan intermediate representation yang digunakan di atas LLVM Compiler Infrastructure. LLVM IR bukan merupakan machine code. Beberapa konstruksi terlihat seperti high-level language (seperti fungsi dan strong type). Sementara sebagian terlihat seperti low-level assembly. 8 | 9 | Sebagai abstraksi dari sebuah program (source), LLVM IR merepresentasikan komponen seperti: 10 | 11 | - Module 12 | - Function 13 | - Basic Block 14 | - Instruction 15 | 16 | Operasi terhadap LLVM IR dapat dibagi menjadi dua kategori, yaitu: `Analysis` (analisis) dan `Transformation` (transformasi/perubahan bentuk). Analisis adalah memindai IR untuk mendapatkan informasi tertentu seputar flow dari code. Sementara Transformasi adalah mengubah IR dengan struktur tertentu menjadi struktur lain dengan mempertahankan maksud awal dari code. 17 | 18 | #### Module 19 | 20 | Module merupakan abstraksi dari sebuah module, sebuah source code file, atau sering disebut sebagai translation unit. Module merupakan kontainer untuk komponen-komponen lain. Di dalam sebuah Module dapat pula dideklarasikan beberapa informasi, antara lain: 21 | 22 | - Target Information 23 | - Global Symbols: variable, function declaration, function definition 24 | - Metadata 25 | 26 | #### Function 27 | 28 | Sebuah Function mengabstraksi komponen function/subroutine. Fungsi adalah potongan kode yang diidentifikasi dengan sebuah nama. Istilah high-level seperti function pada paradigma `imperative` dan method pada paradigma `OOP` dipetakan sebagai sebuah "function" di LLVM. 29 | 30 | Sebuah function terdiri dari: 31 | 32 | - Argument: argumen yang dibutuhkan oleh fungsi 33 | - Basic Block: basic block yang ada di dalam fungsi 34 | - Entry Basic Block: basic-block yang dieksekusi pertama kali ketika fungsi dipanggil. 35 | 36 | #### Basic Block 37 | 38 | Sebuah Basic Block mengabstraksi sekumpulan instruksi yang terikat sebagai satu kesatuan. Serangkaian instruksi dapat disebut sebagai Basic Block apabila instruksi tersebut instruksi `non-terminator` dan diakhiri oleh sebuah instruksi `terminator`. 39 | 40 | Sebuah Basic Block terdiri dari: 41 | 42 | - Label 43 | - Instruction 44 | - Phi Instruction 45 | - Terminator Instruction 46 | 47 | Ketika mengabstraksi alur dari program, setiap basic-block dieksekusi dalam urutan tertentu. Sebuah successor adalah sebuah Basic Block yang akan dieksekusi tepat setelah Basic Block terkini. 48 | 49 | #### Instruction 50 | 51 | Sebuah instruksi merepresentasikan operasi tunggal yang dapat dilakukan. -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/00.structure/0.module.ll: -------------------------------------------------------------------------------- 1 | ; Module 2 | ; 3 | ; LLVM IR terdiri atas beberapa komponen yang tersusun secara terstruktur 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as module.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o module.asm module.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | ; LLVM IR - Module 14 | ; Module merupakan abstraksi dari sebuah module atau source code file. 15 | 16 | ; Module terdiri atas beberapa bagian: 17 | ; - Target information 18 | ; - Global symbols 19 | ; - global variables 20 | ; - function declarations 21 | ; - function definition 22 | ; - other stuff 23 | 24 | ; -- Target Information -- 25 | source_filename = "module.c" 26 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 27 | target triple = "x86_64-pc-linux-gnu" 28 | 29 | ; format datalayout: 30 | ; e-m:e-i64:64-f80:128-n8:16:32:64-S128 31 | ; 32 | ; e endian (little) 33 | ; m:e ELF mangling 34 | ; i64:64 ABI alignment i64 35 | ; f80:128 floating point 36 | ; n8:16:32:64 native integer widths 37 | 38 | ; format triple 39 | ; x86_64-pc-linux-gnu 40 | ; 41 | ; x86_64 architecture 42 | ; pc-linux vendor 43 | ; gnu system 44 | 45 | 46 | ; -- Global Symbols -- 47 | ; Simbol global diidentifikasi dengan sebuah nama dan diawali dengan 48 | ; simbol @ sebagai penanda Global Symbol. 49 | 50 | ; Semua simbol yang akan digunakan harus telah terdeklarasi sebelumnya. 51 | 52 | ; Deklarasi (declaration) memberikan informasi keberadaan sebuah simbol. 53 | ; Definisi (definition) memberikan informasi wujud konkret dari sebuah simbol. 54 | ; Deklarasi dapat dilakukan tanpa adanya definisi. 55 | 56 | ; Penjelasan serta contoh deklarasi dan definisi akan diberikan kemudian. 57 | 58 | 59 | ; Global variables 60 | 61 | ; variable 62 | @var = global i32 135, align 4 63 | 64 | ; string constant 65 | @.str = private unnamed_addr constant [13 x i8] c"Hello World\0A\00" 66 | 67 | 68 | ; Function declaration 69 | 70 | ; Function definition 71 | 72 | 73 | ; -- Other Stuffs -- 74 | ; Informasi opsional yang memberikan informasi tambahan terkait modul 75 | ; dan simbol di dalamnya. 76 | 77 | ; Attribute 78 | ; Memberikan informasi bagaimana sebuah komponen diperlakukan. 79 | ; Atrribute diidentifikasi dengan sebuah bilangan 80 | attributes #0 = { noinline nounwind optnone uwtable } 81 | 82 | ; Metadata 83 | ; Memberikan informasi flag dan metadata yang digunakan dalam module. 84 | ; Sebuah flag diidentifikasi dengan sebuah bilangan. 85 | !llvm.module.flags =!{!0, !1} 86 | !llvm.ident = !{!2} 87 | 88 | !0 = !{i32 1, !"wchar_size", i32 2} 89 | !1 = !{i32 7, !"PIC Level", i32 2} 90 | !2 = !{!"RevID LLVM IR"} 91 | -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/00.structure/1.function.ll: -------------------------------------------------------------------------------- 1 | ; Function 2 | ; 3 | ; LLVM IR terdiri atas beberapa komponen yang tersusun secara terstruktur 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as function.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o function.asm function.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | ; LLVM IR - Module 14 | 15 | source_filename = "function.c" 16 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 17 | target triple = "x86_64-pc-linux-gnu" 18 | 19 | 20 | ; LLVM IR - Function 21 | 22 | ; Function terdiri atas beberapa komponen: 23 | ; - Argument 24 | ; - Basic Block 25 | ; - Entry Basic Block 26 | 27 | ; Sebuah fungsi merupakan identitas global yang diidentifikasi melalui sebuah nama 28 | ; dengan diawali simbol @ sebagai penanda Global Symbol. 29 | 30 | ; Setiap fungsi harus dideklarasikan atau didefinisikan sebelum dapat digunakan. 31 | 32 | 33 | ; -- Function Declaration -- 34 | ; Deklarasi (declaration) memberikan informasi keberadaan fungsi di modul. 35 | ; Deklarasi menyatakan bahwa sebuah fungsi didefinisikan di luar (eksternal) module. 36 | 37 | ; Deklarasi sebuah fungsi 38 | ; - diidentifikasi sebagai @fnc_declare 39 | ; - menerima 1 argumen bertipe i32 dengan nama %arg 40 | ; - mengembalikan nilai bertipe i32 41 | declare i32 @fnc_declare (i32 %arg) 42 | 43 | 44 | ; -- Function Definition -- 45 | ; Definisi (definition) memberikan informasi wujud konkret dari fungsi. 46 | ; Definisi menyatakan deklarasi sebuah fungsi beserta badan fungsi tersebut. 47 | 48 | ; Definisi sebuah fungsi 49 | ; - diidentifikasi sebagai @fnc_define 50 | ; - menerima 1 argumen bertipe i32 dengan nama %arg 51 | ; - mengembalikan nilai bertipe i32 52 | ; - pada badan fungsi melakukan pemanggilan terhadap @func_declare 53 | define i32 @fnc_define (i32 %arg) { 54 | %ret = call i32 @func_declare(i32 %arg) 55 | ret i32 %ret 56 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/00.structure/2.basic-block.ll: -------------------------------------------------------------------------------- 1 | ; Basic Block 2 | ; 3 | ; LLVM IR terdiri atas beberapa komponen yang tersusun secara terstruktur 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as basic-block.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o basic-block.asm basic-block.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | ; LLVM IR - Module 14 | 15 | source_filename = "basic-block.c" 16 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 17 | target triple = "x86_64-pc-linux-gnu" 18 | 19 | 20 | ; LLVM IR - Function 21 | ; Implementasi fungsi faktorial 22 | define i32 @algorithm (i32 %arg) { 23 | 24 | 25 | ; LLVM IR - Basic Block 26 | ; Basic Block terdiri atas beberapa komponen: 27 | ; - Label 28 | ; - Instructions 29 | ; - Phi Instruction 30 | ; - Terminator 31 | 32 | ; -- Basic Block -- 33 | ; Basic Block tidak didefinisikan secara eksplisit. 34 | ; Instruksi-instruksi yang diakhiri dengan Terminator akan dianggap sebagai 35 | ; sebuah Basic Block. 36 | ; Terminator dapat berupa: 37 | ; - br (branch) 38 | ; - ret (return) 39 | 40 | ; Basic Block 0 41 | ; melakukan perbandingan nilai 42 | entry: 43 | %is_base_case = icmp eq i32 %arg, 0 44 | br i1 %is_base_case, label %base_case, label %recursive_case 45 | 46 | ; Basic Block 1 47 | ; mengembalikan nilai 1 48 | base_case: 49 | ret i32 1 50 | 51 | ; Basic Block 2 52 | ; menghitung nilai (arg - 1), memanggil @algorithm() secara rekursif 53 | ; menghitung nilai dan mengembalikannya. 54 | recursive_case: 55 | %0 = add i32 -1, %arg 56 | %1 = call i32 @algorithm(i32 %0) 57 | %2 = mul i32 %arg, %1 58 | ret i32 %2 59 | } 60 | 61 | ; Label 62 | ; Label adalah token untuk identifikasi posisi dalam kode (dan memori nantinya). 63 | ; Sebuah label dapat dianggap sebagai tujuan dari branching atau bagian dari loop. 64 | ; Dengan kata lain, label merupakan penanda sebuah Basic Block. 65 | ; Tidak seperti assembly pada arsitektur tertentu, label pada LLVM IR bukan 66 | ; merupakan penanda sebuah fungsi. 67 | 68 | 69 | ; Instructions 70 | ; Instruksi merupakan sebuah operasi tunggal yang dapat dikerjakan oleh pemroses. 71 | ; Terdapat banyak tipe instruksi, lihat juga contoh pada 'data-movement', 72 | ; 'arithmetic-operation', 'comparision', dan 'logical' 73 | 74 | 75 | ; Terminator 76 | ; Terminator atau Terminator Instruction adalah sebuah instruksi yang mengakhiri 77 | ; sebuah Basic Block. Terminator akan mengarahkan alur eksekusi menuju ke 78 | ; Basic Block lain (successor). -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/00.structure/3.instruction.ll: -------------------------------------------------------------------------------- 1 | ; Instruction 2 | ; 3 | ; Instruksi merupakan sebuah operasi tunggal yang dapat dikerjakan oleh pemroses. 4 | ; Sebuah instruction memiliki format. 5 | ; 6 | ; LLVM Bitcode: 7 | ; $ llvm-as instruction.ll 8 | ; 9 | ; Assembly(x86): 10 | ; $ llc -march=x86 -o instruction.asm instruction.ll 11 | ; 12 | ;----------------------------------------------------------------------------- 13 | 14 | ; -- LLVM IR - Module -- 15 | source_filename = "instruction.c" 16 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 17 | target triple = "x86_64-pc-linux-gnu" 18 | 19 | ; -- LLVM IR - Symbols -- 20 | declare i32 @algorithm () 21 | 22 | define i32 @main () { 23 | 24 | ; Instruction adalah statement dalam satu baris tunggal. 25 | ; LLVM IR diklasifikasikan ke dalam RISC (Reduced Instruction Set Computer), dimana 26 | ; semua operasi yang didefinisikan merupakan operasi sederhana dan generik. 27 | 28 | ; Secara sintaksis, instruksi LLVM merupakan Three-Address Code (TAC atau 3AC). 29 | ; Setiap instruksi memiliki paling banyak tiga operan dan umumnya merupakan kombinasi 30 | ; dari assignment dan operator binari. 31 | ; 32 | ; Format umum instruksi adalah sebagai berikut: 33 | ; 34 | ; [label:] [%var = ] instruction [operands] [;comment] 35 | ; 36 | ; Field yang ada di dalam [] merupakan field opsional. 37 | 38 | ; Jumlah operan suatu instruksi dapat bervariasi. Sebagian besar instruksi memiliki dua. 39 | ; Beberapa dapat memiliki lebih dari itu. Sebuah operasi dapat menghasilkan nilai dan 40 | ; disimpan ke sebuah variabel (lokal/global). Hampir semua Instruction mengembalikan 41 | ; nilai. 42 | ; 43 | ; Sebagai bahasa yang Strong Type, LLVM IR mensyaratkan penegasan tipe data yang jelas 44 | ; untuk operasi yang dilakukan. Setiap operan harus memiliki tipe yang sepadan. 45 | 46 | 47 | ; Contoh One-Operand Instruction 48 | ; panggil (call) sebuah fungsi bernama @algorithm 49 | ; dalam hal ini, operan adalah nama fungsi dan instruksi adalah "call" 50 | call i32 @algorithm () 51 | 52 | ; Contoh Two-Operand Instruction 53 | ; kalikan 15 dan 9 kemudian simpan di %result 54 | ; dalam hal ini, operan adalah angka 15 dan 9 dan instruksi adalah mul 55 | %result = mul i32 15, 9 56 | 57 | 58 | ; LLVM IR menggunakan prinsip SSA (Static Single Assignment). 59 | ; SSA adalah prinsip yang menegaskan bahwa: 60 | ; - assignment setiap variabel hanya dapat dilakukan sekali. 61 | ; - setiap variabel harus terdefinisi sebelum digunakan. 62 | ; 63 | ; Implikasinya adalah, dalam sebuah fungsi bisa terdapat banyak variabel untuk 64 | ; menampung nilai masing-masing operasi. 65 | ; 66 | ; Karena kemudahan dalam traceback perubahan nilai, SSA digunakan untuk melakukan 67 | ; optimisasi oleh mesin, namun dapat menjadi kerumitan bagi manusia. 68 | 69 | 70 | ret i32 0 71 | } 72 | -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/01.type/4.string.ll: -------------------------------------------------------------------------------- 1 | ; String 2 | ; LLVM IR Data Type 3 | ; 4 | ; LLVM Bitcode: 5 | ; $ llvm-as string.ll 6 | ; 7 | ; Assembly(x86): 8 | ; $ llc -march=x86 -o string.asm string.ll 9 | ; 10 | ;----------------------------------------------------------------------------- 11 | 12 | source_filename = "string.c" 13 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 14 | target triple = "x86_64-pc-linux-gnu" 15 | 16 | 17 | ; LLVM IR menggunakan prinsip Strong Type yang ketat. Setiap data yang terlibat 18 | ; dalam operasi, setiap nilai yang dihasilkan, harus menyertakan tipe data 19 | ; secara eksplisit. 20 | 21 | ; Pemberlakuan Strong Type memberikan kemudahan dalam menghasilkan kode yang 22 | ; sesuai dengan arsitektur target. 23 | 24 | 25 | ; String 26 | ; String adalah Array karakter, umumnya berupa karakter cetak (printable character). 27 | ; Terdapat banyak style dan jenis string dilihat dari elemen, terminasi string, dsb. 28 | ; Elemen dalam string dapat berupa byte atau multibyte seperti unicode. 29 | 30 | ; LLVM tidak mendefinisikan tipe khusus untuk mengakomodir string jenis tertentu. 31 | ; Namun pemetaan string ke dalam Array karakter dapat dilakukan dengan mudah. 32 | 33 | 34 | ; Deklarasi 35 | ; Deklarasi string tak berbeda dengan deklarasi sebuah Array, namun umumnya 36 | ; diikuti dengan inisialisasi. 37 | 38 | 39 | ; -- Deklarasi String global -- 40 | ; C-Style string 41 | ; null-terminated, string diakhiri dengan NULL (byte 00) 42 | @str_c = private unnamed_addr constant [13 x i8] c"Reversing.ID\00", align 1 43 | 44 | ; Pascal-Style string (short) 45 | ; string diawali dengan sebuah byte yang menyatakan panjang string. Maksimum 255 karakter 46 | @str_pshort = private unnamed_addr constant [13 x i8] c"\0cReversing.ID", align 1 47 | 48 | ; Wide-Char string (4 byte) 49 | ; elemen string merupakan multibyte, 4 byte, dan diakhiri dengan NULL 50 | @str_wide = private unnamed_addr constant [13 x i32] [i32 82, i32 101, i32 118, i32 101, i32 114, i32 115, i32 105, i32 110, i32 103, i32 46, i32 73, i32 68, i32 0], align 16 51 | 52 | ; operasi terhadap string akan bergantung dengan jenis string. 53 | 54 | define i32 @algorithm () { 55 | 56 | ret i32 0 57 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/01.type/5.function.ll: -------------------------------------------------------------------------------- 1 | ; Function 2 | ; LLVM IR Data Type 3 | ; 4 | ; LLVM Bitcode: 5 | ; $ llvm-as function.ll 6 | ; 7 | ; Assembly(x86): 8 | ; $ llc -march=x86 -o function.asm function.ll 9 | ; 10 | ;----------------------------------------------------------------------------- 11 | 12 | source_filename = "function.c" 13 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 14 | target triple = "x86_64-pc-linux-gnu" 15 | 16 | 17 | ; LLVM IR memiliki prinsip strong type. Setiap data yang terlibat dalam operasi 18 | ; harus memiliki tipe data yang eksplisit. 19 | 20 | ; Pemberlakuan Strong Type memberikan kemudahan dalam menghasilkan kode yang 21 | ; sesuai dengan arsitektur target. 22 | 23 | 24 | ; Function 25 | ; LLVM IR mendefinisikan Function sebagai suatu tipe tersendiri dalam Type System. 26 | ; Function dapat dianggap sebagai sebuah function signature yang dapat 27 | ; mengidentifikasi sebuah fungsi dan membedakan dengan fungsi lainnya. 28 | ; Function terdiri atas dua komponen: Return Type dan List of Formal Parameter. 29 | 30 | ; Bentuk umum tipe data Function (Function Signature): 31 | ; 32 | ; RET ( LIST_OF_PARAM ) 33 | 34 | declare i32 @ext_function(i32) 35 | 36 | 37 | define i32 @algorithm () { 38 | 39 | ; Alokasi stack untuk menyimpan function pointer 40 | 41 | ; -- Function Pointer Declaration -- 42 | ; Signature: i32 (i32) * 43 | ; Pointer ke Function dengan 1 argumen i32, mengembalikan i32 44 | %fptr1 = alloca i32 (i32) *, align 8 45 | 46 | ; Signature: float (i16, i32* *) * 47 | ; Pointer ke Function dengan 2 argumen (i16 dan pointer ke i32), 48 | ; mengembalikan float 49 | %fptr2 = alloca float (i16, i32* *) * 50 | 51 | ; i32 (i8*, ...) * 52 | ; Pointer ke Function vararg, argumen pertama adalah pointer ke i8, 53 | ; mengembalikan i32 54 | %fptr3 = alloca i32 (i8*, ...) * 55 | 56 | ; Signature: {i32, i32} (i32) 57 | ; Pointer ke Function dengan 1 argumen i32, 58 | ; mengembalikan struktur dengan dua i32 59 | %fptr4 = alloca i32 (i8*, ...) * 60 | 61 | 62 | ; -- Function Pointer Assignment -- 63 | ; Assign alamat fungsi ke variabel 64 | ; Simpan alamat @ext_fungsi ke variabel yang ditunjuk %fptr1 65 | ; %fptr merupakan sebuah pointer yang mengarah ke type i32(i32)* 66 | store i32 (i32)* @ext_function, i32 (i32)** %fptr1, align 8 67 | 68 | 69 | ; -- Function Pointer Call -- 70 | ; Call fungsi yang ditunjuk oleh funtion pointer 71 | ; dapatkan alamat fungsi 72 | %function = load i32 (i32) *, i32 (i32)** %fptr1, align 8 73 | 74 | ; panggil, ext_function(135) 75 | %retval = call i32 %function (i32 135) 76 | 77 | 78 | ret i32 0 79 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/01.type/7.pointer.ll: -------------------------------------------------------------------------------- 1 | ; Pointer 2 | ; LLVM IR Data Type 3 | ; 4 | ; LLVM Bitcode: 5 | ; $ llvm-as pointer.ll 6 | ; 7 | ; Assembly(x86): 8 | ; $ llc -march=x86 -o pointer.asm pointer.ll 9 | ; 10 | ;----------------------------------------------------------------------------- 11 | 12 | source_filename = "pointer.c" 13 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 14 | target triple = "x86_64-pc-linux-gnu" 15 | 16 | 17 | ; LLVM IR menggunakan prinsip Strong Type yang ketat. Setiap data yang terlibat 18 | ; dalam operasi, setiap nilai yang dihasilkan, harus menyertakan tipe data 19 | ; secara eksplisit. 20 | 21 | ; Pemberlakuan Strong Type memberikan kemudahan dalam menghasilkan kode yang 22 | ; sesuai dengan arsitektur target. 23 | 24 | 25 | ; Pointer 26 | ; Pointer (penunjuk) adalah tipe data yang menyimpan suatu alamat memory, spesifik 27 | ; terhadap suatu lokasi. Umumnya Pointer digunakan untuk melakukan Reference dan 28 | ; Dereference objek di memori. 29 | 30 | ; Pointer merupakan sebuah variabel yang memerlukan alokasi ruang. Implementasi 31 | ; ini bergantung kepada masing-masing arsitektur dimana ukuran Pointer bergantung 32 | ; kepada panjang data yang dapat dioperasikan oleh processor. 33 | 34 | 35 | ; Deklarasi 36 | ; Pointer dideklarasikan dengna sintaks TYPE*, dimana TYPE adalah segala macam 37 | ; tipe data yang valid dan dikenali dalam module. 38 | 39 | 40 | ; -- Deklarasi Pointer global -- 41 | ; Jika sebuah Pointer dideklarasikan secara global namun tidak berisi nilai secara 42 | ; eksplisit, maka Pointer harus merujuk ke null. 43 | @gptr_int = global i32* null, align 8 44 | 45 | ; Ragam deklarasi Pointer dapat dilihat pada bagian selanjutnya. 46 | 47 | 48 | define i32 @algorithm () { 49 | 50 | ; Variabel yang akan ditunjuk oleh Pointer 51 | %ivar = alloca i32, align 4 52 | store i32 135, i32* %ivar, align 4 53 | 54 | ; Array dengan elemen yang akan ditunjuk oleh Pointer 55 | %iarr = alloca [5 x i32], align 16 56 | 57 | ; -- Deklarasi Pointer lokal -- 58 | ; Pointer to Variable 59 | %iptr.addr = alloca i32*, align 8 60 | 61 | ; -- Address Assignment -- 62 | ; Pointer to Variable 63 | ; iptr.addr = &ivar 64 | store i32* %ivar, i32** %iptr.addr, align 8 65 | 66 | ; Pointer to Array element at index 67 | ; iptr.addr = &iarr[2] 68 | %iarr.idx2 = getelementptr inbounds [5 x i32], [5 x i32]* %iarr, i64 0, i64 2 69 | store i32* %iarr.idx2, i32** %iptr.addr, align 8 70 | 71 | 72 | 73 | ret i32 0 74 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/01.type/8.vector.ll: -------------------------------------------------------------------------------- 1 | ; Vector 2 | ; LLVM IR Data Type 3 | ; 4 | ; LLVM Bitcode: 5 | ; $ llvm-as vector.ll 6 | ; 7 | ; Assembly(x86): 8 | ; $ llc -march=x86 -o vector.asm vector.ll 9 | ; 10 | ;----------------------------------------------------------------------------- 11 | 12 | source_filename = "vector.c" 13 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 14 | target triple = "x86_64-pc-linux-gnu" 15 | 16 | 17 | ; LLVM IR menggunakan prinsip Strong Type yang ketat. Setiap data yang terlibat 18 | ; dalam operasi, setiap nilai yang dihasilkan, harus menyertakan tipe data 19 | ; secara eksplisit. 20 | 21 | ; Pemberlakuan Strong Type memberikan kemudahan dalam menghasilkan kode yang 22 | ; sesuai dengan arsitektur target. 23 | 24 | 25 | ; Vector 26 | ; Vector memiliki kesamaan dengan Array, dimana Vector merupakan himpunan objek 27 | ; atau elemen dengan tipe seragam. Namun, Vector secara khusus merupakan tipe 28 | ; yang merepresentasikan vector of elements. 29 | ; 30 | ; Operasi vector merupakan operasi SIMD (Single Instruction Multiple Data) yang 31 | ; diberlakukan kepada data elemen primitif. 32 | 33 | 34 | ; Deklarasi 35 | ; Vector memerlukan jumlah elemen, tipe data primitif, dan skala untuk 36 | ; merepresentasikan vector, menyesuaikan dengan panjang vector di hardware. 37 | 38 | 39 | define i32 @algorithm () { 40 | 41 | ; -- Deklarasi Vector lokal -- 42 | ; Vector dengan 4 elemen i32 43 | %ivec = alloca <4 x i32> 44 | %ivec2 = alloca <4 x i32> 45 | 46 | ; Vector dengan 8 elemen float 47 | %vfloat = alloca <8 x float> 48 | 49 | ; Vector dengan 2 elemen i64 50 | %vlong = alloca <2 x i64> 51 | 52 | 53 | ; -- Akses Elemen Vector -- 54 | 55 | ; Extract & Insert 56 | ; Elemen scalar dapat diekstrak maupun disisipkan secara individu ke/dari vector. 57 | ; load objek terlebih dahulu 58 | %ivec.tmp = load <4 x i32>, <4 x i32>* %ivec 59 | %ivec2.tmp = load <4 x i32>, <4 x i32>* %ivec2 60 | 61 | ; Extract 62 | ; Dapatkan elemen Vector pada indeks tertentu secara individual 63 | 64 | ; Dapatkan elemen di indeks ke-2 dari vector %ivec 65 | %ext.addr = extractelement <4 x i32> %ivec.tmp, i32 2 66 | 67 | ; Insert 68 | ; Ubah nilai elemen Vector pada indeks tertentu secara individual 69 | ; Letakkan elemen di indeks ke-3 dari vector %ivec 70 | insertelement <4 x i32> %ivec.tmp, i32 3, i32 135 71 | 72 | ; Shuffle 73 | ; Lakukan permutasi terhadap elemen Vector, berdasarkan posisi yang diberikan. 74 | %shuffle.val= shufflevector <4 x i32> %ivec.tmp, <4 x i32> %ivec2.tmp, <4 x i32> 75 | 76 | 77 | ret i32 0 78 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/branching.ll: -------------------------------------------------------------------------------- 1 | ; Branching 2 | ; 3 | ; LLVM Bitcode: 4 | ; $ llvm-as branching.ll 5 | ; 6 | ; Assembly(x86): 7 | ; $ llc -march=x86 -o branching.asm branching.ll 8 | ; 9 | ;----------------------------------------------------------------------------- 10 | 11 | source_filename = "branching.c" 12 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 13 | target triple = "x86_64-pc-linux-gnu" 14 | 15 | 16 | ; Control-Flow 17 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 18 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 19 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 20 | ; penanganan kasus. Beberapa kelompok operasi yang berperan dalam pengendalian 21 | ; alur program antara lain jump / branch dan comparison. 22 | 23 | 24 | ; Jump / Branch 25 | ; Jump (lompat) adalah perpindahan alur eksekusi (execution flow) ke lokasi lain. 26 | ; Lokasi tujuan perpindahan ditandai dengan sebuah label, menjadi isyarat sebuah 27 | ; blok kode baru (Basic Block). 28 | ; 29 | ; Terdapat dua tipe jump: unconditional jump dan conditional jump 30 | ; Conditional Jump adalah jump dimana perpindahan hanya terjadi apabila kondisi 31 | ; tertentu terpenuhi. Sementara Unconditional Jump akan mengubah alur apapun kondisi 32 | ; yang terjadi pada saat itu. 33 | 34 | define i32 @branching () { 35 | 36 | ; Branching (percabangan) 37 | ; Unconditional Branch diimplementasikan sebagai branching dengan hanya satu Label. 38 | ; Tidak ada evaluasi kondisi sebelum perpindahan perpindahan alur eksekusi terjadi. 39 | ; 40 | ; Conditional Branc diimplementasikan sebagai pemilihan dua alternatif Branch, 41 | ; berdasarkan nilai kondisi yang dievaluasi. Label pertama dipilih bila kondisi True 42 | ; terjadi, seblaiknya label kedua akan dipilih. 43 | ; 44 | ; Umumnya nilai boolean (i1) didapatkan dari evaluasi perbandingan (comparison) 45 | ; dua buah nilai. 46 | 47 | ; -- Unconditional Branch -- 48 | br label %Execute 49 | 50 | ret i32 2 ; Tidak akan dieksekusi 51 | 52 | ; -- Conditional Branch -- 53 | Execute: 54 | %cond = icmp eq i32 0, 5 55 | br i1 %cond, label %IfEqual, label %IfInequal 56 | 57 | IfEqual: 58 | ret i32 1 59 | 60 | IfInequal: 61 | ret i32 0 62 | 63 | 64 | ; Sebuah label dianggap sebagai sebuah "variabel" yang menyimpan alamat Basic Block. 65 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/decision/if-else.ll: -------------------------------------------------------------------------------- 1 | ; If-Else 2 | ; Decision-Making 3 | ; 4 | ; Percabangan, pengambilan keputusan dengan pengecekan kondisi tunggal, aksi, 5 | ; dan alternatifnya. 6 | ; 7 | ; LLVM Bitcode: 8 | ; $ llvm-as if-else.ll 9 | ; 10 | ; Assembly(x86): 11 | ; $ llc -march=x86 -o if-else.asm if-else.ll 12 | ; 13 | ;----------------------------------------------------------------------------- 14 | 15 | source_filename = "if-else.c" 16 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 17 | target triple = "x86_64-pc-linux-gnu" 18 | 19 | 20 | ; Control-Flow 21 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 22 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 23 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 24 | ; penanganan kasus. 25 | ; 26 | ; Konstruksi control-flow secara high-level dapat diterjemahkan menggunakan 27 | ; kombinasi percabangan antar Basic Block. 28 | 29 | 30 | ; Percabangan adalah perpindahan eksekusi ke sekumpulan instruksi menggunakan 31 | ; satu atau lebih instruksi branching. 32 | ; 33 | ; Tujuan: 34 | ; implementasi statement "If-Else" 35 | ; percabangan sederhana yang mengarahkan ke sekelompok instruksi jika kondisi 36 | ; terpenuhi 37 | ; 38 | ; Bentuk umum: 39 | ; if (condition) then 40 | ; do_action 41 | ; else 42 | ; do_alternative_action 43 | 44 | 45 | define i32 @algorithm () { 46 | entry: 47 | %ivar = alloca i32, align 4 48 | store i32 0, i32* %ivar, align 4 49 | 50 | ; periksa apakah kondisi terpenuhi dan lakukan percabangan jika true 51 | ; ini adalah implementasi efisien di level logic LLVM IR 52 | ; 53 | ; if (var == 2) 54 | ; var = 1; 55 | ; else 56 | ; var = 0; 57 | 58 | 59 | ; pemeriksaan kondisi 60 | %ivar.val = load i32, i32* %ivar, align 4 61 | %cond = icmp eq i32 %ivar.val, 2 62 | br i1 %cond, label %do_action, label %do_alternative_action 63 | 64 | do_action: 65 | ; eksekusi do_action karena kondisi terpenuhi 66 | store i32 1, i32* %ivar, align 4 67 | 68 | ; hindari block untuk "else" atau aksi alternatif 69 | br label %end 70 | 71 | do_alternative_action: 72 | ; eksekusi do_alternative_action karena kondisi tak terpenuhi 73 | store i32 0, i32* %ivar, align 4 74 | 75 | ; secara eksplisit menyebutkan bahwa block penerus adalah block end 76 | br label %end 77 | 78 | end: 79 | ; block ini akan dieksekusi terlepas dari hasil percabangan 80 | ret i32 0 81 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/decision/if.ll: -------------------------------------------------------------------------------- 1 | ; If 2 | ; Decision-Making 3 | ; 4 | ; Percabangan, pengambilan keputusan dengan pengecekan kondisi tunggal. 5 | ; 6 | ; LLVM Bitcode: 7 | ; $ llvm-as if.ll 8 | ; 9 | ; Assembly(x86): 10 | ; $ llc -march=x86 -o if.asm if.ll 11 | ; 12 | ;----------------------------------------------------------------------------- 13 | 14 | source_filename = "if.c" 15 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 16 | target triple = "x86_64-pc-linux-gnu" 17 | 18 | 19 | ; Control-Flow 20 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 21 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 22 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 23 | ; penanganan kasus. 24 | ; 25 | ; Konstruksi control-flow secara high-level dapat diterjemahkan menggunakan 26 | ; kombinasi percabangan antar Basic Block. 27 | 28 | 29 | ; Percabangan adalah perpindahan eksekusi ke sekumpulan instruksi menggunakan 30 | ; satu atau lebih instruksi branching. 31 | ; 32 | ; Tujuan: 33 | ; implementasi statement "If-Then" 34 | ; percabangan sederhana yang mengarahkan ke sekelompok instruksi jika kondisi 35 | ; terpenuhi 36 | ; 37 | ; Bentuk umum: 38 | ; if (condition) then 39 | ; do_action 40 | 41 | 42 | define i32 @algorithm () { 43 | entry: 44 | %ivar = alloca i32, align 4 45 | store i32 0, i32* %ivar, align 4 46 | 47 | ; periksa apakah kondisi terpenuhi dan lakukan percabangan jika true 48 | ; ini adalah implementasi efisien di level logic LLVM IR 49 | ; 50 | ; if (var == 2) 51 | ; var = 1; 52 | 53 | 54 | ; pemeriksaan kondisi 55 | %ivar.val = load i32, i32* %ivar, align 4 56 | %cond = icmp eq i32 %ivar.val, 2 57 | br i1 %cond, label %do_action, label %end 58 | 59 | do_action: 60 | ; eksekusi do_action karena kondisi terpenuhi 61 | store i32 1, i32* %ivar, align 4 62 | br label %end 63 | 64 | end: 65 | ; block ini akan dieksekusi terlepas dari hasil percabangan 66 | ret i32 0 67 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/decision/multi-if.ll: -------------------------------------------------------------------------------- 1 | ; Multi-If 2 | ; Decision-Making 3 | ; 4 | ; Banyak pilihan percabangan dengan masing-masing memiliki kondisi sederhana 5 | ; 6 | ; LLVM Bitcode: 7 | ; $ llvm-as multi-if.ll 8 | ; 9 | ; Assembly(x86): 10 | ; $ llc -march=x86 -o multi-if.asm multi-if.ll 11 | ; 12 | ;----------------------------------------------------------------------------- 13 | 14 | source_filename = "multi-if.c" 15 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 16 | target triple = "x86_64-pc-linux-gnu" 17 | 18 | 19 | ; Control-Flow 20 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 21 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 22 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 23 | ; penanganan kasus. 24 | ; 25 | ; Konstruksi control-flow secara high-level dapat diterjemahkan menggunakan 26 | ; kombinasi percabangan antar Basic Block. 27 | 28 | 29 | ; Percabangan adalah perpindahan eksekusi ke sekumpulan instruksi menggunakan 30 | ; satu atau lebih instruksi branching. 31 | ; 32 | ; Tujuan: 33 | ; implementasi statement "Multi-If" 34 | ; setiap cabang memiliki kondisi sederhana dan akan mengarahkan eksekusi ke blok 35 | ; tertentu jika kondisi terpenuhi. 36 | ; 37 | ; Bentuk umum: 38 | ; if (condition_1) then 39 | ; do_action_1 40 | ; else if (condition_2) then 41 | ; do_action_2 42 | ; else 43 | ; do_alternative_action 44 | 45 | 46 | define i32 @algorithm () { 47 | entry: 48 | %ivar = alloca i32, align 4 49 | store i32 0, i32* %ivar, align 4 50 | 51 | ; periksa apakah kondisi terpenuhi dan lakukan percabangan jika true 52 | ; ini adalah implementasi efisien di level logic LLVM IR 53 | ; 54 | ; if (var == 2) 55 | ; var = 1; 56 | ; else if (var == 1) 57 | ; var = 0; 58 | ; else 59 | ; var = 2; 60 | 61 | 62 | ; pemeriksaan kondisi 63 | %ivar.val = load i32, i32* %ivar, align 4 64 | %cond1 = icmp eq i32 %ivar.val, 2 65 | br i1 %cond1, label %do_action_1, label %check_condition_2 66 | 67 | do_action_1: 68 | ; eksekusi do_action_1 karena kondisi terpenuhi 69 | store i32 1, i32* %ivar, align 4 70 | 71 | ; hindari block lain 72 | br label %end 73 | 74 | check_condition_2: 75 | ; pemeriksaan kondisi untuk condition_2 76 | %cond2 = icmp eq i32 %ivar.val, 1 77 | br i1 %cond2, label %do_action_2, label %do_alternative_action 78 | 79 | do_action_2: 80 | ; eksekusi do_action_2 karena kondisi terpenuhi 81 | store i32 0, i32* %ivar, align 4 82 | 83 | ; hindari block lain 84 | br label %end 85 | 86 | do_alternative_action: 87 | ; eksekusi do_alternative_action karena kondisi tak terpenuhi 88 | store i32 0, i32* %ivar, align 4 89 | 90 | ; secara eksplisit menyebutkan bahwa block penerus adalah block end 91 | br label %end 92 | 93 | end: 94 | ; block ini akan dieksekusi terlepas dari hasil percabangan 95 | ret i32 0 96 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/decision/nested-if.ll: -------------------------------------------------------------------------------- 1 | ; Nested-If 2 | ; Decision-Making 3 | ; 4 | ; Pemilihan keputusan secara bersarang. 5 | ; 6 | ; LLVM Bitcode: 7 | ; $ llvm-as nested-if.ll 8 | ; 9 | ; Assembly(x86): 10 | ; $ llc -march=x86 -o nested-if.asm nested-if.ll 11 | ; 12 | ;----------------------------------------------------------------------------- 13 | 14 | source_filename = "nested-if.c" 15 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 16 | target triple = "x86_64-pc-linux-gnu" 17 | 18 | 19 | ; Control-Flow 20 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 21 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 22 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 23 | ; penanganan kasus. 24 | ; 25 | ; Konstruksi control-flow secara high-level dapat diterjemahkan menggunakan 26 | ; kombinasi percabangan antar Basic Block. 27 | 28 | 29 | ; Percabangan adalah perpindahan eksekusi ke sekumpulan instruksi menggunakan 30 | ; satu atau lebih instruksi branching. 31 | ; 32 | ; Tujuan: 33 | ; implementasi percabangan bersarang. 34 | ; sebuah percabangan dapat didefinisikan di dalam blok aksi percabangan lain. 35 | ; 36 | ; Bentuk umum: 37 | ; if (condition_1) then 38 | ; do_action_1 39 | ; if (condition_2) then 40 | ; do_action_2 41 | 42 | 43 | define i32 @algorithm () { 44 | entry: 45 | %ivar1 = alloca i32, align 4 46 | %ivar2 = alloca i32, align 4 47 | store i32 0, i32* %ivar1, align 4 48 | store i32 0, i32* %ivar2, align 4 49 | 50 | ; perlu dicatat bahwa pemeriksaan kondisi condition_2 hanya terjadi jika 51 | ; condition_1 terpenuhi. 52 | ; Dapat dikatakan bahwa pemeriksaan condition_2 berada pada block sama 53 | ; dengan do_action_1 54 | ; 55 | ; if (var1 == 0) 56 | ; { 57 | ; var1 = 10; 58 | ; if (var2 == 0) 59 | ; var2 = 20; 60 | ; } 61 | 62 | 63 | ; pemeriksaan kondisi condition_1 64 | %ivar1.val = load i32, i32* %ivar1, align 4 65 | %cond1 = icmp eq i32 %ivar1.val, 0 66 | br i1 %cond1, label %do_action_1, label %end 67 | 68 | do_action_1: 69 | ; eksekusi do_action_1 karena kondisi terpenuhi 70 | store i32 10, i32* %ivar1, align 4 71 | 72 | ; pemeriksaan kondisi untuk condition_2 73 | %ivar2.val = load i32, i32* %ivar2, align 4 74 | %cond2 = icmp eq i32 %ivar2.val, 0 75 | br i1 %cond2, label %do_action_2, label %end 76 | 77 | do_action_2: 78 | ; eksekusi do_action_2 karena kondisi terpenuhi 79 | store i32 20, i32* %ivar2, align 4 80 | 81 | ; secara eksplisit menyebutkan bahwa block penerus adalah block end 82 | br label %end 83 | 84 | end: 85 | ; block ini akan dieksekusi terlepas dari hasil percabangan 86 | ret i32 0 87 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/loop/do-while.ll: -------------------------------------------------------------------------------- 1 | ; Do-While 2 | ; Loop 3 | ; 4 | ; Perulangan sederhana dengan satu kondisi. 5 | ; 6 | ; LLVM Bitcode: 7 | ; $ llvm-as do-while.ll 8 | ; 9 | ; Assembly(x86): 10 | ; $ llc -march=x86 -o do-while.asm do-while.ll 11 | ; 12 | ;----------------------------------------------------------------------------- 13 | 14 | source_filename = "do-while.c" 15 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 16 | target triple = "x86_64-pc-linux-gnu" 17 | 18 | 19 | ; Control-Flow 20 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 21 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 22 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 23 | ; penanganan kasus. 24 | ; 25 | ; Konstruksi control-flow secara high-level dapat diterjemahkan menggunakan 26 | ; kombinasi percabangan antar Basic Block. 27 | 28 | 29 | ; Perulangan adalah serangkaian instruksi (dan block) yang ditulis sekali namun 30 | ; dapat dieksekusi berkali-kali secara berturut-turut. 31 | ; 32 | ; Instruksi perulangan dapat dikendalikan berdasarkan banyaknya perulangan 33 | ; maupun kondisi perulangan yang harus terpenuhi. 34 | ; 35 | ; Tujuan: 36 | ; implementasi konstruksi "Do-While" sebagai perulangan sederhana. 37 | ; struktur Do-While adalah struktur perulangan dimana sekelompok instruksi 38 | ; dieksekusi setidaknya sebanyak sekali. 39 | ; Kondisi perulangan akan diperiksa di akhir struktur 40 | ; 41 | ; Bentuk umum: 42 | ; do 43 | ; do_action 44 | ; while (condition) 45 | ; 46 | ; catatan: 47 | ; kondisi kompleks merupakan kombinasi dari berbagai kondisi sederhana. 48 | 49 | 50 | define i32 @algorithm () { 51 | entry: 52 | %ivar = alloca i32, align 4 53 | 54 | ; block instruksi dieksekusi, kondisi diperiksa saat akhir perulangan dan 55 | ; lompat kembali ke awal block jika kondisi terpenuhi 56 | ; 57 | ; do 58 | ; { 59 | ; var ++; 60 | ; } while (var <= 10); 61 | ; 62 | ; pada kasus tertentu, beberapa instruksi dapat mengubah kondisi. 63 | ; misal: perubahan counter, perubahan treshold, dsb. 64 | 65 | 66 | ; lakukan inisialisasi apapun jika diperlukan di sini 67 | store i32 0, i32* %ivar, align 4 68 | 69 | ; secara eksplisit menyebutkan block penerus 70 | br label %loop_body 71 | 72 | loop_body: 73 | ; eksekusi do_action 74 | %ivar.old = load i32, i32* %ivar, align 4 75 | %ivar.new = add nsw i32 %ivar.old, 1 76 | store i32 %ivar.new, i32* %ivar, align 4 77 | 78 | ; secara eksplisit menyebutkan block penerus 79 | br label %condition_check 80 | 81 | condition_check: 82 | ; pemeriksaan kondisi 83 | ; periksa apakah perulangan akan dilakukan lagi 84 | %ivar.val = load i32, i32* %ivar, align 4 85 | %cond = icmp sle i32 %ivar.val, 10 86 | br i1 %cond, label %loop_body, label %end 87 | 88 | end: 89 | ; di luar loop 90 | ret i32 0 91 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/loop/while.ll: -------------------------------------------------------------------------------- 1 | ; While 2 | ; Loop 3 | ; 4 | ; Perulangan sederhana dengan satu kondisi. 5 | ; 6 | ; LLVM Bitcode: 7 | ; $ llvm-as while.ll 8 | ; 9 | ; Assembly(x86): 10 | ; $ llc -march=x86 -o while.asm while.ll 11 | ; 12 | ;----------------------------------------------------------------------------- 13 | 14 | source_filename = "while.c" 15 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 16 | target triple = "x86_64-pc-linux-gnu" 17 | 18 | 19 | ; Control-Flow 20 | ; Ketika suatu program berjalan, eksekusi instruksi dilakukan secara berurutan 21 | ; dari awal hingga akhir. Namun dalam beberapa kondisi tertentu, terdapat 22 | ; kebutuhan untuk mengeksekusi instruksi di lokasi lain sebagai bentuk 23 | ; penanganan kasus. 24 | ; 25 | ; Konstruksi control-flow secara high-level dapat diterjemahkan menggunakan 26 | ; kombinasi percabangan antar Basic Block. 27 | 28 | 29 | ; Perulangan adalah serangkaian instruksi (dan block) yang ditulis sekali namun 30 | ; dapat dieksekusi berkali-kali secara berturut-turut. 31 | ; 32 | ; Instruksi perulangan dapat dikendalikan berdasarkan banyaknya perulangan 33 | ; maupun kondisi perulangan yang harus terpenuhi. 34 | ; 35 | ; Tujuan: 36 | ; implementasi konstruksi "While" sebagai perulangan sederhana. 37 | ; While memiliki konstruksi yang mirip dengan Do-While namun dengan 38 | ; pemeriksaan kondisi terjadi di awal. 39 | ; 40 | ; Bentuk umum: 41 | ; while (condition) 42 | ; do_action 43 | ; 44 | ; catatan: 45 | ; kondisi kompleks merupakan kombinasi dari berbagai kondisi sederhana. 46 | 47 | 48 | define i32 @algorithm () { 49 | entry: 50 | %ivar = alloca i32, align 4 51 | 52 | ; 53 | ; 54 | ; while (var <= 10) 55 | ; { 56 | ; var ++; 57 | ; } 58 | ; 59 | ; pada kasus tertentu, beberapa instruksi dapat mengubah kondisi. 60 | ; misal: perubahan counter, perubahan treshold, dsb. 61 | 62 | 63 | ; lakukan inisialisasi apapun jika diperlukan di sini 64 | store i32 0, i32* %ivar, align 4 65 | 66 | ; secara eksplisit menyebutkan block penerus 67 | br label %condition_check 68 | 69 | condition_check: 70 | ; pemeriksaan kondisi 71 | ; periksa apakah perulangan akan dilakukan 72 | %ivar.val = load i32, i32* %ivar, align 4 73 | %cond = icmp sle i32 %ivar.val, 10 74 | br i1 %cond, label %loop_body, label %end 75 | 76 | loop_body: 77 | ; eksekusi do_action 78 | %ivar.old = load i32, i32* %ivar, align 4 79 | %ivar.new = add nsw i32 %ivar.old, 1 80 | store i32 %ivar.new, i32* %ivar, align 4 81 | 82 | ; secara eksplisit menyebutkan block penerus 83 | br label %condition_check 84 | 85 | end: 86 | ; di luar loop 87 | ret i32 0 88 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/memory.ll: -------------------------------------------------------------------------------- 1 | ; Memory 2 | ; 3 | ; Operasi terhadap alamat memory atau nilai yang disimpan dalam memory. 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as memory.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o memory.asm memory.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | source_filename = "memory.c" 14 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 15 | target triple = "x86_64-pc-linux-gnu" 16 | 17 | 18 | ; Memory Access 19 | ; Operasi pembacaan (read/load) atau penulisan (write/store) terhadap informasi 20 | ; yang disimpan di memory. Akses memory dapat dilakukan terhadap wilayah yang dibatasi 21 | ; sebagai stack, heap, memory mapped, maupun wilayah lain yang tidak dibatasi 22 | ; secara khusus. 23 | ; 24 | ; 25 | ; Memory Allocation 26 | ; Operasi untuk memesan atau menyediakan ruang memory dengan ukuran tertentu untuk 27 | ; digunakan menyimpan data. Alokasi memory dapat dilakukan sebelum akses dapat 28 | ; dilakukan. Alokasi dapat dilakukan secara implisit dan eksplisit. 29 | ; Alokasi implisit dilakukan dengan cara deklarasi variabel atau konstanta global. 30 | ; Alokasi eksplisit dilakukan dengan menggunakan instruksi khusus, umumnya dalam 31 | ; mempersiapkan ruang di lokasi tertentu (stack dan heap). 32 | ; 33 | ; Dalam LLVM IR, alokasi eksplisit yang didukung adalam alokasi Stack. Sementara 34 | ; alokasi lain (contoh: heap) dilakukan oleh API (libc) di luar kewenangan LLVM IR. 35 | 36 | define i32 @algorithm () { 37 | 38 | ; Stack Allocation 39 | ; Alokasi ruang di stack frame fungsi jika fungsi tersebut aktif atau sedang dieksekusi. 40 | ; Ruang yang telah dialokasikan akan dilepas secara otomatis setelah scope berakhir. 41 | ; Penyebutan tipe data dilakukan untuk memberikan kepastian ukuran ruang yang dipesan. 42 | ; 43 | ; Apabila alokasi ruang disimpan ke dalam variabel, maka variabel tersebut bertipe 44 | ; pointer terhadap tipe data yang dialokasikan. 45 | 46 | ; alokasi stack dengan alignment. 47 | %v01.addr = alloca i32, align 4 48 | 49 | ; alokasi stack dengan 10 elemen (tanpa alignment) 50 | %v02.addr = alloca i32, i32 10 51 | 52 | ; Store (Write) 53 | ; Menyimpan nilai ke alamat memory tertentu 54 | ; simpan nilai 135 ke alamat memory yang ditunjuk pointer %v01.addr 55 | store i32 135, i32* %v01.addr 56 | 57 | ; Load (Read) 58 | ; Mengambil nilai yang tersimpan pada alamat memory tertentu. 59 | ; baca nilai yang tersimpan di alamat memory yang ditunjuk pointer %v01.addr 60 | %v11.val = load i32, i32* %v01.addr 61 | 62 | ; Fence 63 | ; 64 | ; fence 65 | 66 | ; 67 | ; cmpxchg 68 | 69 | ; 70 | ; atomicrmw 71 | 72 | ; 73 | ; getelementptr 74 | 75 | 76 | ret i32 0 77 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/phi.ll: -------------------------------------------------------------------------------- 1 | ; Phi 2 | ; 3 | ; LLVM Bitcode: 4 | ; $ llvm-as phi.ll 5 | ; 6 | ; Assembly(x86): 7 | ; $ llc -march=x86 -o phi.asm phi.ll 8 | ; 9 | ;----------------------------------------------------------------------------- 10 | 11 | source_filename = "phi.c" 12 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 13 | target triple = "x86_64-pc-linux-gnu" 14 | 15 | 16 | ; Phi Operator 17 | ; Implementasi Phi Node pada prinsip SSA. 18 | ; Prinsip SSA (Static Single Assignment) mengharuskan bahwa sebuah assignment nilai 19 | ; terhadap sebuah variabel hanya dapat dilakukan sekali selama eksekusi program. 20 | ; Permasalahan terjadi ketika sebuah nilai harus diperbarui secara berkala, misal 21 | ; melalui loop. 22 | ; 23 | ; Phi Node digunakan untuk memilih nilai berdasarkan dua atau lebih kondisi nilai. 24 | ; Jika sebuah Basic Block dapat dicapai dari dua atau lebih jalan, maka Phi Node 25 | ; tinggal memeriksa Basic Block asal dan mengisikan nilai yang sesuai ke variabel. 26 | ; 27 | ; Singkatnya, Phi Node disisipkan untuk menggabungkan dua nilai yang berbeda. 28 | 29 | define i32 @phi (i32 %a, i32 %b) { 30 | entry: 31 | ; percabangan, pindah ke btrue atau bfalse berdasarkan nilai kondisi 32 | %cond = icmp slt i32 %a, %b 33 | br i1 %cond, label %btrue, label %bfalse 34 | 35 | btrue: 36 | ; jika kondisi bernilai true, %retval akan bernilai a 37 | br label %finish 38 | 39 | bfalse: 40 | ; jika kondisi bernilai false, %retval akan bernilai b 41 | br label %finish 42 | 43 | ; nilai kembalian %retval didapat dari %a atau %b. 44 | ; terdapat dua path berbeda untuk mengisi %retval, yaitu %btrue dan %bfalse. 45 | ; SSA tidak mengijinkan redefinisi dan reassignment sebuah variabel, sehingga 46 | ; jika terdapat dua kemungkinan nilai dari dua path berbeda maka proses merge 47 | ; harus dilakukan. 48 | finish: 49 | ; %retval akan berisi nilai dari %b jika block sebelumnya adalah %bfalse 50 | ; %retval akan berisi nilai dari %a jika block sebelumnya adalah %btrue 51 | %retval = phi i32 [ %b, %bfalse ], [ %a, %btrue ] 52 | 53 | ret i32 %retval 54 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/02.operation/select.ll: -------------------------------------------------------------------------------- 1 | ; Value Selection 2 | ; 3 | ; Pemilihan nilai berdasarkan kondisi. 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as select.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o select.asm select.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | source_filename = "select.c" 14 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 15 | target triple = "x86_64-pc-linux-gnu" 16 | 17 | 18 | ; Selection 19 | ; Pemilihan nilai dari dua pilihan nilai berdasarkan kondisi yang harus dipenuhi. 20 | 21 | define i32 @selection () { 22 | 23 | ; Selection (pemilihan) 24 | ; Instruksi pemilihan menerima sebuah nilai kondisi boolean. Dua nilai sebagai opsi 25 | ; nilai akan dipilih berdasarkan kondisi yang diberikan. Nilai pertama dipilih bila 26 | ; kondisi True terjadi, sebaliknya nilai kedua akan dipilih. 27 | ; 28 | ; Umumnya nilai boolean (i1) didapatkan dari evaluasi perbandingan (comparison) 29 | ; dua buah nilai. 30 | 31 | ; Kondisi didapat dari evaluasi instruksi perbandingan 32 | %cond = icmp eq i32 0, 5 33 | %value = select i1 %cond, i8 135, i8 182 34 | 35 | ; Kondisi true diberikan untuk memaksa pemilihan nilai pertama 36 | %value2 = select i1 true, i8 135, i8 182 37 | 38 | ret i32 0 39 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/03.subroutine/0.call.ll: -------------------------------------------------------------------------------- 1 | ; Function Call 2 | ; 3 | ; Pemanggilan fungsi secara langsung dan tak langsung 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as call.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o call.asm call.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | source_filename = "call.c" 14 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 15 | target triple = "x86_64-pc-linux-gnu" 16 | 17 | 18 | ; Function Call 19 | ; Pemanggilan fungsi merupakan sebuah aksi untuk memindahkan alur eksekusi sehingga 20 | ; instruksi di dalam fungsi dapat dieksekusi. 21 | ; Terdapat dua jenis pemanggilan, yaitu pemanggilan langsung dan tak langsung. 22 | ; 23 | ; Pemanggilan secara langsung (direct call) terhadap fungsi adalah pemanggilan tanpa 24 | ; melalui pointer. Nama fungsi yang akan dipanggil disebut dengan menyertakan argumen 25 | ; yang diperlukan, lengkap dengan tipe data yang diperlukan. 26 | ; 27 | ; Pemanggilan secara tak langsung (indirect call) terhadap fungsi adalah pemanggilan 28 | ; melalui media pointer. Sebuah pointer akan menyimpan alamat sebuah fungsi. Pointer 29 | ; tersebut kemudian disebut dengna menyertakan argumen yang diperlukan, lengkap dengan 30 | ; tipe data yang diperlukan. 31 | 32 | 33 | define i32 @function (i32) { 34 | ret i32 0 35 | } 36 | 37 | 38 | define i32 @algorithm () { 39 | 40 | %fncvar = alloca i32 (i32)*, align 8 41 | store i32 (i32)* @function, i32 (i32)** %fncvar, align 8 42 | 43 | ; direct call (pemanggilan langsung) 44 | ; return-value daftar argumen 45 | call i32 @function (i32 0) 46 | ; nama fungsi 47 | 48 | ; indirect call (pemanggilan tak langsung) 49 | ; menyimpan alamat fungsi yang akan dipanggil ke sebuah pointer. 50 | %fncptr = load i32 (i32)*, i32 (i32)** %fncvar, align 8 51 | 52 | ; return-value daftar argumen 53 | call i32 %fncptr (i32 0) 54 | ; variabel memuat fungsi 55 | 56 | ret i32 0 57 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/03.subroutine/3.vararg.ll: -------------------------------------------------------------------------------- 1 | ; Vararg & Variadic Function 2 | ; 3 | ; Deklarasi dan penggunaan fungsi dengan argumen dinamis 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as vararg.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o vararg.asm vararg.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | source_filename = "vararg.c" 14 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 15 | target triple = "x86_64-pc-linux-gnu" 16 | 17 | 18 | ; Vararg 19 | ; Variable Argument (vararg) adalah argumen sebuah method yang dapat menerima 20 | ; sembarang jumlah argumen yang diberikan. Fungsi yang mengimplementasikan vararg 21 | ; disebut sebagai Variadic Function atau fungsi yang memiliki arity tak tentu. 22 | 23 | ; Normalnya sebuah fungsi dideklarasikan dengan jumlah dan tipe argumen yang pasti. 24 | ; Setiap fungsi memiliki signature berdasarkan tipe kembalian dan tipe tiap argumen 25 | ; yang dimiliki. 26 | 27 | ; Variadic Function tidak mendeklarasikan jumlah argumen yang pasti. Tidak pula tipe 28 | ; argumen yang diterima. 29 | 30 | 31 | ; Variadic function 32 | define i32 @variadic_func (...) { 33 | ret i32 0 34 | } 35 | 36 | ; Variadic function dengan 1 argumen pasti 37 | define i32 @variadic_func2 (i32, ...) { 38 | ret i32 0 39 | } 40 | 41 | define i32 @algorithm () { 42 | ; pemanggilan dengan 4 argumen 43 | call i32 (...) @variadic_func (i32 1, i32 2, i32 3, i32 4) 44 | 45 | ; pemanggilan dengan 2 argumen 46 | call i32 (...) @variadic_func (i32 8, i32 9) 47 | 48 | ; pemanggilan dengan 3 argumen: 1 argumen pasti, 2 vararg 49 | call i32 (i32, ...) @variadic_func2 (i32 1, i32 2, i32 3) 50 | 51 | 52 | ret i32 0 53 | } -------------------------------------------------------------------------------- /Codes/ir-code/llvm/ir/03.subroutine/4.private.ll: -------------------------------------------------------------------------------- 1 | ; Private Function 2 | ; 3 | ; Deklarasi private function 4 | ; 5 | ; LLVM Bitcode: 6 | ; $ llvm-as private.ll 7 | ; 8 | ; Assembly(x86): 9 | ; $ llc -march=x86 -o private.asm private.ll 10 | ; 11 | ;----------------------------------------------------------------------------- 12 | 13 | source_filename = "private.c" 14 | target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" 15 | target triple = "x86_64-pc-linux-gnu" 16 | 17 | ; Private Function 18 | ; Sebuah fungsi dapat dibatasi penggunaan atau akses terhadapnya. 19 | ; Pembatasan dapat berupa isolasi sehingga fungsi hanya dapat dikenali dan diakses 20 | ; di dalam sebuah modul. Dalam hal ini, referensi di luar module (yang mendefinisikan) 21 | ; tidak akan dapat dilakukan. 22 | 23 | 24 | ; Definisi sebuah fungsi 25 | ; - diidentifikasi sebagai @priv_func 26 | ; - tidak menerima argumen 27 | ; - mengembalikan nilai bertipe i32 28 | define private i32 @priv_func () { 29 | ret i32 135 30 | } -------------------------------------------------------------------------------- /Codes/ir-code/qemu/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Qemu Tiny Code Generator (TCG) Intermediate Representation (IR) 4 | 5 | ## Qemu TCG IR Introduction 6 | 7 | TCG IR adalah Intermediate Representation yang digunakan oleh Qemu. `TCG (Tiny Code Generator)` adalah sebuah Code Generator, module yang digunakan oleh Qemu untuk menerjemahkan potongan kode (Basic Block) dari target ke host. 8 | 9 | Qemu (Quick EMUlator) adalah hardware virtualization yang digunakan sebagai emulator untuk beragam processor, menjalankan dan monitor program yang berjalan untuk platform tertentu. 10 | 11 | Sebagai emulator, Qemu melakukan penerjemahan berdasarkan potongan-potongan kode yang disebut sebagai Translation Block. -------------------------------------------------------------------------------- /Codes/ir-code/radare2/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Introduction to Radare2 Evaluable Strings Intermediate Language (ESIL). 4 | 5 | ## Radare2 ESIL Introduction 6 | 7 | `ESIL (Evaluable Strings Intermediate Language)` adalah Intermediate Language yang digunakan oleh Radare2 untuk mendeskripsikan aksi yang dilakukan oleh setiap instruksi dari setiap CPU. 8 | 9 | Radare2 adalah framework dengan fokus terhadap Reverse Engineering dan analisis binary. Radare2 dapat melakukan Static Analysis dan Dynamic Analysis (debugging) terhadap beragam format binary. 10 | 11 | ESIL digunakan secara luas di Radare2 sebagai: 12 | 13 | - Code Emulation: emulate block code 14 | - Branch Prediction 15 | - Assisted Debugging: mengimplementasikan Software Watchpoints. 16 | - VM Emulation 17 | - Code Analysis 18 | - Decompilation: menciptakan AST dari ESIL 19 | - dsb -------------------------------------------------------------------------------- /Codes/ir-code/soot/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Repository 2 | 3 | Introduction to Soot Jimple 4 | 5 | ## Soot Jimple Introduction 6 | 7 | Soot Jimple adalah (salah satu) Intermediate Representation yang digunakan oleh Soot Framework. 8 | 9 | Soot adalah framework untuk analisis dan optimisasi program Java. 10 | -------------------------------------------------------------------------------- /Codes/ir-code/valgrind/README.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Valgrind VEX Intermediate Representation (IR) 4 | 5 | ## Valgrind IR Introduction 6 | 7 | Valgrind VEX IR adalah Intermediate Representation yang digunakan oleh Valgrind framework. VEX adalah Binary Translation layer yang digunakan Valgrind untuk menerjemahkan potongan kode dari target ke host. 8 | 9 | Valgrind adalah framework untuk Dynamic Analysis (Memory Debugging, Memory Leak Detection, Checker, Profiling, dsb). Secara arsitektur, Valgrind adalah Virtual Machine dengan teknik kompilasi JIT (Just-In-Time). Tidak ada bagian binary yang akan berjalan di host processor secara langsung. Valgrind menerjemahkan kode program menjadi IR yang independen, SSA-based. 10 | 11 | -------------------------------------------------------------------------------- /Codes/numeric-system.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Introduction to Numerical System 4 | 5 | ## Numeric System 6 | 7 | Komputasi adalah manipulasi angka. Sebuah nilai dapat direpresentasikan ke dalam bentuk atau notasi berbeda. 8 | 9 | #### Binary Number System 10 | 11 | Sistem bilangan dengan basis 2. 12 | 13 | Untk setiap digit angka terdapat 2 kemungkinan angka, yaitu: 0 dan 1. 14 | 15 | #### Octal Number System 16 | 17 | Sistem bilangan dengan basis 8. 18 | 19 | Untk setiap digit angka terdapat 8 kemungkinan angka, yaitu: 0, 1, 2, 3, 4, 5, 6, 7. 20 | 21 | #### Hexadecimal Number System 22 | 23 | Sistem bilangan dengan basis 16. 24 | 25 | Untk setiap digit angka terdapat 16 kemungkinan angka, yaitu: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F. -------------------------------------------------------------------------------- /Tools/ir-code/llvm/anvill.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Decompiler Toolchain 4 | 5 | * Github: https://github.com/lifting-bits/anvill 6 | 7 | Category: 8 | 9 | - decompiler 10 | - binary lifting 11 | - executable 12 | 13 | ## Introduction 14 | 15 | Anvill adalah implementasi decompiler sederhana dengan [Remill](remill.md) dan [Rellic](rellic.md). 16 | 17 | Dalam prosesnya, Bitcode akan dihasilkan dari Executable Binary oleh Remill. Bitcode kemudian diolah sehingga didapatkan padanan kode dalam bahasa C menggunakan Rellic. 18 | 19 | #### Notes 20 | 21 | - Anvill adalah executable yang menggunakan beberapa library. 22 | - Dekompilasi dapat dikonfigurasi melalui file JSON. 23 | 24 | ## Reference 25 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/bin2llvm.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Binary to LLVM Translator 4 | 5 | * Github: https://github.com/cojocar/bin2llvm 6 | 7 | Category: 8 | 9 | - binary lifting 10 | - recompiler 11 | - executable 12 | 13 | ## Introduction 14 | 15 | Tool berbasis [S2E](s2e.md) untuk menerjemahkan binary menjadi LLVM IR. 16 | 17 | Tidak seperti tools sejenis, bin2llvm menggunakan Qemu sebagai front en untuk menghasilkan Intermediate Representation (TCG IR) sebagai front end dan menerjemahkannya ke LLVM IR yang sesuai. 18 | 19 | #### Notes 20 | 21 | ## Reference 22 | 23 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/dagger.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Binary Translator to LLVM IR 4 | 5 | * Github: https://github.com/ahmedbougacha/dagger 6 | 7 | Category: 8 | 9 | - binary lifting 10 | - executable 11 | 12 | ## Introduction 13 | 14 | Dagger adalah library yang menerjemahkan binary menjadi LLVM IR dengan tujuan sebagai library native di LLVM Infrastructure. 15 | 16 | #### Notes 17 | 18 | - Dagger melakukan fork terhadap LLVM 19 | 20 | ## Reference -------------------------------------------------------------------------------- /Tools/ir-code/llvm/fcd.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Optimizing Decompiler 4 | 5 | * Github: https://github.com/zneak/fcd 6 | * Site: http://zneak.github.io/fcd/ 7 | 8 | Category: 9 | 10 | - decompiler 11 | - executable 12 | 13 | ## Introduction 14 | 15 | fcd adalah decompiler berbasis LLVM. 16 | 17 | #### Notes 18 | 19 | - menggunakan [Capstone](https://github.com/aquynh/capstone) sebagai disassembler. 20 | - mengimplementasikan algoritma Pattern-Independent Structuring. 21 | - mendukung plugin berupa LLVM Pass. 22 | 23 | ## Reference 24 | 25 | - [Write custom optimization passes](http://zneak.github.io/fcd/2016/02/21/csaw-wyvern.html) 26 | - [Discover function prototypes by header files](http://zneak.github.io/fcd/2016/09/04/parsing-headers.html) -------------------------------------------------------------------------------- /Tools/ir-code/llvm/fracture.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Architecture-Independent Decompiler to LLVM IR 4 | 5 | * Github: https://github.com/draperlaboratory/fracture 6 | 7 | Category: 8 | 9 | - binary lifting 10 | - library 11 | - executable 12 | 13 | ## Introduction 14 | 15 | Fracture adalah tool yang menerjemahkan instruksi mesin menjadi LLVM IR. Sebagai tool Binary Lifting, Fracture menghasilkan LLVM IR berdasarkan file executable yang diberikan. 16 | 17 | #### Notes 18 | 19 | ## Reference -------------------------------------------------------------------------------- /Tools/ir-code/llvm/hikari.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | LLVM Obfuscator 4 | 5 | * Github: https://github.com/HikariObfuscator/Hikari 6 | 7 | Category: 8 | 9 | - obfuscator 10 | - executable 11 | 12 | ## Introduction 13 | 14 | Hikari adalah obfuscator berbasis LLVM dengan berfokus kepada penggunaan LLVM Pass untuk melakukan transformasi source code program. 15 | 16 | #### Design 17 | 18 | Hikari didesain dengan tiga tujuan utama: 19 | 20 | - __Minimal Impact__: Core dari Hikari harus mudah dipindahkan (port) ke compiler lain dengan LLVM sebagai backend. 21 | - __Focus on the Compiler__: Tidak ada penambahan fitur yang memerlukan pustaka luar. 22 | - __Keep it Abstract__: Lakukan obfuscation di level IR, bukan di backend sehingga menjamin abstraksi dan platform independent. 23 | 24 | #### Pass 25 | 26 | - __Bogus Control Flow__: modifikasi Control Flow Graph dengan menambahkan Basic Block sebelum Basic Block saat ini. Basic Block baru mengandung Opaque Predicate sehingga terjadi Conditional Jump ke Basic Block asli. 27 | - __Control Flow Flattening__: memodifikasi Control Flow Graph dengan membuat semua Basic Block berada pada level yang sama. 28 | - __Function Call Obfuscate__: mengganti semua pemanggilan suatu fungsi ke fungsi lain berdasarkan pemetaan yang telah ditentukan . 29 | - __Function Wrapper__: membuat dummy function yang membungkus pemanggilan ke fungsi sesungguhnya, sehingga terdapat beberapa pemanggilan yang harus dilakukan sebelum memanggil fungsi asli. 30 | - __Indirect Branching__: instruksi Branching digantikan oleh Indirect Branching, sehingga menjadikan pemanggilan bersifat dinamis. 31 | - __String Encryption__: enkripsi string dan buat sebuah stub untuk melakukan dekripsi sebelum string digunakan. 32 | 33 | #### Notes 34 | 35 | - Dikembangkan sebagai peningkatan (improvement) terhadap [Obfuscator-LLVM](https://github.com/obfuscator-llvm/obfuscator). 36 | 37 | ## Reference 38 | 39 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/klee.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | KLEE LLVM Execution Engine. 4 | 5 | * Github: https://github.com/klee/klee 6 | * Site: https://klee.github.io/ 7 | 8 | Category: 9 | 10 | - symbolic execution 11 | - executable 12 | 13 | ## Introduction 14 | 15 | KLEE adalah symbolic virtual machine dibangun di atas LLVM Compiler Infrastructure. 16 | 17 | #### Design 18 | 19 | KLEE didesain dengan dua komponen: 20 | 21 | - __Core Symbolic Virtual Machine__: bertanggung jawab atas eksekusi LLVM bitcode dengan dukungan terhadap symbolic values. 22 | - __POSIX Emulation Layer__: menggunakan uClibc untuk memberikan dukungan lingkungan eksekusi program. 23 | 24 | #### Notes 25 | 26 | ## Reference 27 | 28 | - [Tutorials](https://klee.github.io/tutorials) -------------------------------------------------------------------------------- /Tools/ir-code/llvm/llvm-mctoll.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Framework for Lifting x86, amd64, and aarch64 Binaries to LLVM Bitcode 4 | 5 | * Github: https://github.com/microsoft/llvm-mctoll 6 | 7 | Category: 8 | 9 | - binary lifting 10 | - executable 11 | 12 | ## Introduction 13 | 14 | LLVM-McToll adalah tool Binary Lifting, menerjemahkan executable binaries dari kode mesin menjadi LLVM IR. 15 | 16 | #### Targets 17 | 18 | - Architecture: 19 | - 32 bit: ARM 20 | - 64 bit: x86-64 21 | - File Format: ELF 22 | 23 | #### Notes 24 | 25 | ## Reference -------------------------------------------------------------------------------- /Tools/ir-code/llvm/mcsema.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Framework for Lifting x86, amd64, and aarch64 Binaries to LLVM Bitcode 4 | 5 | * Github: https://github.com/lifting-bits/mcsema 6 | 7 | Category: 8 | 9 | - binary lifting 10 | 11 | ## Introduction 12 | 13 | McSema adalah framework Binary Lifting, menerjemahkan (lift) executable binaries dari kode mesin menjadi LLVM bitcode. McSema juga dapat dikombinasikan dengan libFuzzer untuk melakukan fuzzing. 14 | 15 | Secara garis besar, McSema digunakan untuk: 16 | 17 | - Binary Lifting 18 | - Static Binary Rewriting 19 | - Binary Translation 20 | - BInary Recompilation 21 | 22 | McSema mendukung beberapa format executable seperti ELF (Linux) dan PE (Windows), serta sebagian besar instruksi untuk x86 dan amd64. 23 | 24 | #### Notes 25 | 26 | - terdiri atas dua komponen: `mcsema-disass` dan `mcsema-lift`. 27 | - `mcsema-disass` melakukan Control-Flow Recovery dan Instruction Translation menggunakan dukungan dari IDA Pro, Binary Ninja, atau DynInst. 28 | - `mcsema-lift` melakukan Instruction Translation ke LLVM Bitcode menggunakan pustaka [Remill](remill.md) 29 | 30 | ## Reference 31 | 32 | Official 33 | 34 | - [Walktrough](https://github.com/lifting-bits/mcsema/blob/master/docs/McSemaWalkthrough.md) 35 | - [Using libFuzzer](https://github.com/lifting-bits/mcsema/blob/master/docs/UsingLibFuzzer.md) 36 | - [Using KLEE](https://blog.trailofbits.com/2014/12/04/close-encounters-with-symbolic-execution-part-2/) 37 | 38 | Unofficial -------------------------------------------------------------------------------- /Tools/ir-code/llvm/noctilucence.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Embedded Bitcode Recompiler 4 | 5 | * Github: https://github.com/HikariObfuscator/Noctilucence 6 | 7 | Category: 8 | 9 | - misc 10 | 11 | ## Introduction 12 | 13 | Ekstrak bitcode dari sebuah object file, jalankan Pass, dan rekompilasi / link kembali menjadi object file. 14 | 15 | catatan: hanya mendukung MachO. -------------------------------------------------------------------------------- /Tools/ir-code/llvm/obfuscator-llvm.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | LLVM Obfuscator 4 | 5 | * Github: https://github.com/obfuscator-llvm/obfuscator 6 | 7 | Category: 8 | 9 | - obfuscator 10 | - executable 11 | 12 | ## Introduction 13 | 14 | Obfuscator berbasis LLVM dengan berfokus kepada penggunaan LLVM Pass untuk melakukan transformasi source code program. 15 | 16 | #### Pass 17 | 18 | - __Bogus Control Flow__: modifikasi Control Flow Graph dengan menambahkan Basic Block sebelum Basic Block saat ini. Basic Block baru mengandung Opaque Predicate sehingga terjadi Conditional Jump ke Basic Block asli. 19 | - __Control Flow Flattening__: memodifikasi Control Flow Graph dengan membuat semua Basic Block berada pada level yang sama. 20 | 21 | ## Reference 22 | 23 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/qbdi.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Dynamic Binary Instrumentation based on LLVM 4 | 5 | * Github: https://github.com/QBDI/QBDI 6 | * Site: https://qbdi.quarkslab.com 7 | 8 | Category: 9 | 10 | - dynamic binary instrumentation 11 | - executable 12 | - scripting 13 | 14 | ## Introduction 15 | 16 | QBDI (QuarkslaB Dynamic binary Instrumentation) adalah framework Dynamic Binary Instrumentation yang bersifat modular, Cross-Platform dan Cross-Architecture. 17 | 18 | #### Targets 19 | 20 | - Architecture: 21 | - 32 bit: x86, ARM 22 | - 64-bit: x86-64, AArch64 23 | - Operating System: Linux, MacOS, iOS, Windows 24 | 25 | #### Notes 26 | 27 | - kode instrumentasi menggunakan API C/C++ 28 | - kode instrumentasi akan dikompilasi menjadi Dynamic Library, yang akan dimuat oleh process dengan beragam tools injection. 29 | - menggunakan Python sebagai loader 30 | - dapat diintegrasikan dengan [Frida](https://github.com/frida/frida) 31 | 32 | ## Reference 33 | 34 | - [User Documentation](https://qbdi.readthedocs.io/en/stable/user.html) -------------------------------------------------------------------------------- /Tools/ir-code/llvm/rellic.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Decompile LLVM Bitcode to goto-free C Code. 4 | 5 | * Github: https://github.com/lifting-bits/rellic 6 | 7 | Category: 8 | 9 | - decompiler 10 | 11 | ## Introduction 12 | 13 | Rellic adalah decompiler sederhana yang menghasilkan kode C yang bebas dari goto. 14 | 15 | #### Notes 16 | 17 | - mengimplementasikan algoritma Pattern-Independent Structuring. 18 | 19 | ## Reference 20 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/remill.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Library for Lifting x86, amd64, and aarch64 Machine Code to LLVM Bitcode. 4 | 5 | * Github: https://github.com/lifting-bits/remill 6 | 7 | Category: 8 | 9 | - binary lifting 10 | 11 | ## Introduction 12 | 13 | Remill adalah Static Binary Translator yang menerjemahkan instruksi ke LLVM Bitcode. Remill diimplementasikan sebagai pustaka (library) dan digunakan oleh projek lain seperti [McSema](mcsema.md) dan [Anvill](anvill.md). 14 | 15 | 16 | #### Notes 17 | 18 | - Anvill adalah executable yang menggunakan beberapa library. 19 | - Dekompilasi dapat dikonfigurasi melalui file JSON. 20 | 21 | ## Reference 22 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/reopt.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Tool for Analyzing x86-64 Binaries 4 | 5 | * Github: https://github.com/GaloisInc/reopt 6 | 7 | Category: 8 | 9 | - recompiler 10 | - binary lifting 11 | - disassembler 12 | - optimizer 13 | 14 | ## Introduction 15 | 16 | Reopt adalah tool yang berfokus kepada operasi dekompilasi dan rekompilasi kode. Reopt bekerja dengan melakukan binary lifting, memetakan binary ke LLVM bitcode kemudian melakukan optimisasi hingga akhirnya menerjemahkan kembali ke executable baru. 17 | 18 | #### Targets 19 | 20 | - Architecture: 21 | - 64-bit: x86-64 22 | - Operating System: Linux, MacOS, iOS, Windows 23 | 24 | #### Notes: 25 | 26 | - membutuhkan Haskell 27 | 28 | ## Reference 29 | 30 | - -------------------------------------------------------------------------------- /Tools/ir-code/llvm/retdec.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Retargetable Machine-Code Decompiler based on LLVM 4 | 5 | * Github: https://github.com/avast/retdec 6 | * Site: https://retdec.com/ 7 | 8 | Category: 9 | 10 | - binary lifting 11 | - decompiler 12 | - static analysis 13 | 14 | ## Introduction 15 | 16 | RetDec adalah decompiler yang tidak terbatas terhadap arsitektur, operating system, dan executable format tertentu. 17 | 18 | #### Targets 19 | 20 | - File formats: ELF, PE, MachO, COFF, AR (archive), Intel HEX, raw machine code 21 | - Architecture: 22 | - 32 bit: x86, ARM, MIPS, PIC32, PowerPC 23 | - 64 bit: x86-64, AArch64 24 | 25 | #### Features 26 | 27 | - static analysis 28 | - compiler and packer detection 29 | - OS loader simulation 30 | - loading and instruction decoding 31 | - signature based removal of statically linked library code 32 | - extraction and utilizing debugging information (DWARF, PDB) 33 | - reconstruction of instruction idioms 34 | - detection and reconstruction of C++ class hierarchies (RTTI, vtables) 35 | - symbol demangling (GCC, MSVC, Borland) 36 | - reconstruction of functions, types, and high-level constructs 37 | - integrated disassembler 38 | - generate call graph, control-flow graph, and various statistic. 39 | 40 | #### Notes 41 | 42 | - RetDec menggunakan Python sebagai script pemanggilan. 43 | - unpacking terbatas kepada beberapa packer populer (UPX, MPRESS) 44 | 45 | ## Reference 46 | 47 | Talks: 48 | 49 | - Botconf 2017: [slide](https://retdec.com/static/publications/retdec-slides-botconf-2017.pdf), [video](https://www.youtube.com/watch?v=HHFvtt5b6yY) 50 | - REcon Montreal 2018: [slide](https://retdec.com/static/publications/retdec-slides-recon-2018.pdf) 51 | 52 | Publications: 53 | 54 | - [RetDec](https://retdec.com/publications/) -------------------------------------------------------------------------------- /Tools/ir-code/llvm/rev.ng.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Static Binary Translator 4 | 5 | * Github: https://github.com/revng/revng 6 | * Site: https://rev.ng/revng 7 | 8 | Category: 9 | 10 | - binary lifting 11 | - recompiler 12 | - executable 13 | 14 | ## Introduction 15 | 16 | Revng adalah Static Binary Translator, melakukan lifting dari sembarang ELF binary yang didukung (MIPS, ARM, x86-64) dan menghasilkan LLVM IR. Tidak seperti tools sejenis, revng menggunakan Qemu sebagai front end untuk menghasilkan Intermediate Representation (TCG IR) dan menerjemahkannya ke LLVM IR yang sesuai. 17 | 18 | Revng dapat digunakan untuk menghasilkan binary baru untuk target berbeda. 19 | 20 | #### Notes 21 | 22 | ## Reference 23 | 24 | -------------------------------------------------------------------------------- /Tools/ir-code/llvm/revgen.md: -------------------------------------------------------------------------------- 1 | # Low-Level Code Reference 2 | 3 | Binary to LLVM Translator 4 | 5 | * Github: https://github.com/S2E/tools 6 | 7 | Category: 8 | 9 | - binary lifting 10 | - recompiler 11 | - executable 12 | 13 | ## Introduction 14 | 15 | Tool berbasis [S2E](s2e.md) untuk menerjemahkan binary menjadi LLVM IR. 16 | 17 | Proess penerjemahan dilakukan dalam empat langkah: 18 | 19 | - Disassemble binary menggunakan IDA Pro 20 | - Recover Congrol Flow Graph (CFG) dengan McSema 21 | - Terjemahkan setiap Basic Block dalam CFG menjadi potongan LLVM Bitcode dengan Qemu translator 22 | - Susun keseluruhan Basic Block menjadi fungsi utuh. 23 | 24 | Dengan demikian terdapat beberapa dependensi seperti IDA Pro, McSema, dan Qemu. 25 | 26 | #### Notes 27 | 28 | ## Reference 29 | 30 | --------------------------------------------------------------------------------