Percobaan I

Compiler Bahasa c dan Bahasa

Assembly Intel ®x86
Friyogi Tampubolon (14S15025)
Tanggal Percobaan : 28/09/2017
NWS3103 Praktikum Arsitektur Sistem Komputer
Laboratorium Sistem Digital – Teknik Elektro
Institut Teknologi Del

4. Praktikan memahami penggunaan stack memory pada

Abstrak—The module will do nine experiment, start from setiap procedure call.
process of compile the C language using GCC, the process of
compiling will help by a batch file, the disassembly of object files,
optimization compilation program at GCC, compiling some code
II. LANDASAN TEORETIS
file with the GCC, using the makefile in the makefille in the GCC,
header files, call the procedure with a stack memory and run the Kompilasi menggunakan GCC
program fibbonachi. There are some program or software must be Proses menerjemahkan baris kode program dalam bahasa C
installed in advanced Notepade++, CodeBlock, and HexEdit. menjadi file executable dilakukan dalam empat langkah yaitu
Elsewhere, the labor can understand and analysis of compiling preprocessor, compiler, assembler, dan linker yang seluruhnya
assembly language and C language and understand use stack disebut sistem kompilasi.
memory in procedure call.

Kata Kunci—Bahasa Assembly, GCC, Optimasi, Stack

memory.
Gambar 1 Proses Kompilasi

I. PENDAHULUAN • Preprocessor
Semua perintah preprocessoryang ditulis dalam bahasa tingkat
D alam proses pembuatan suatu program, bahasa tingkat
tinggi lebih banyak digunakan karena bahasa tersebut
lebih mudah dimengerti dan dipahami oleh manusia seperti
tinggi akan diproses terlebih dahulu oleh preprocessor sebelum
compiler melaksanakan tugasnya. Beberapa tugas dari
preprocessor ini adalah sebagai berikut.
Bahasa C. Namun, bahasa tersebut tidak dapat dibaca oleh
o Semua komentar dalam file program diganti dengan
mesin (mikroposessor) yang berbasis bahasa tingkat rendah,
spasi satu buah.
sehingga program tersebut tidak akan di eksekusi. Oleh karena
o Semua \n (backslash-newline) yang menandakan baris
itu akan diperlukan suatu penghubung antara bahasa tingkat
baru akan dihapus tidak peduli dimanapun dia berada.
tinggi dan bahasa tingkat rendah yaitu berupa bahasa assembly
Fitur ini memungkinkan kita untuk membagi baris
yang menjadi penerjemah pemrograman tingkat tinggi
program yang panjang ke dalam beberapa baris tanpa
menjadi Bahasa tingkat rendah yang berisi urutan instruksi
mengubah arti.
yang dimengerti oleh mesin. Proses penerjemahan dari Bahasa
o Macro yang telah didefinisikan diganti dengan
tingkat tinggi menjadi Bahasa Assembly yang dimengerti
definisinya.
oleh mesin disebut compilation. Contohnya, pada perintah #define MAX_ROWS 10,
Pada praktikum ini tujuan yang ingin dicapai antara lain : preprocessor akan mengganti semua kataMAX_ROWS dengan
1. Praktikan memahami tahap-tahap kompilasi program
10.Pada perintah #include <stdio.h>, preprocessor akan
dalam bahasa C sebagai bahasa tingkat tinggi hingga
mengganti baris tersebut dengan isi file stdio.h
diperoleh bahasa tingkat rendah yang dapat
dieksekusi oleh mesin.
2. Praktikan mampu melakukan kompilasi program • Compiler
bahasa C menggunakan compiler GCC beserta Compiler akan menerjemahkan bahasa tingkat tinggi C menjadi
penggunaan makefile dan batch file. kode assembly. Kode assembly ini berisi instruksi-instruksi
3. Praktikan memahami bahasa assembly dan mampu yang sesuai dengan instruction set yang dimiliki oleh mesin.
melakukan analisis terhadap bahasa assembly Intel® File yang dihasilkan pada tahap ini masih berupa file teks (.s).
x86 yang dihasilkan oleh compiler GCC.

• Assembler
Assembler akan menerjemahkan bahasa assembly menjadi file
objek. File objek ini merupakan file biner (.o).
• Linker
Linker akan menggabungkan file biner yang diperoleh pada
tahap sebelumnya dengan file biner lain yang merupakan
dependency dari program yang dibuat, contohnya library
untuk menjalankan fungsi printf. Hasil dari linker berupa file
biner executable (dalam platform Microsoft® Windows™,
file ini memiliki akhiran .exe).
A. Disassembly menggunakan GCC
Selain dapat melakukan kompilasi, paket compiler GCC juga
menyertakan sebuah disassembler yang mampu melakukan
disassembly file biner (.o atau .exe) menjadi file assembly (.s)
bernama Object Dump
B. Optimasi Program melalui Proses Kompilasi
GCC mendukung beberapa tingkat optimisasi program yang
dapat dilakukan saat proses kompilasi dilakukan. Terdapat
beberapa tingkat optimisasi program yang dapat dipilih dengan
menambahkan flag optimisasi saat melakukan kompilasi
program. Umumnya optimisasi program merupakan trade-off
antara execution speed, program size, compilation time, dan
kemudahan dalam melakukan debugging. Beberapa flag
optimisasi yang dikenali oleh GCC adalah –O0, –O1, –O2, –
O3, –Os, dan –Ofast.
C. Makefile dan Batch File
GCC memiliki fitur makefile yang berfungsi untuk menulis
daftar nama file kode di dalam project. Cukup memberikan
GCC nama makefile lalu GCC akan melakukan proses
kompilasi untuk semua file tersebut untuk kemudian
menggabungkannya pada file executable. Makefile dapat
bersifat sederhana hingga kompleks, bergantung pada sejauh
mana kita menggunakan makefile untuk mengorganisasikan
project. Contoh isi dari makefile adalah sebagai berikut :
Gambar 2 Contoh Makefile
Kemudian untuk melakukan kompilasi makefile diberikan
perintah sebagai berikut:
Gambar 3 Perintah Kompilasi
Perintah tersebut akan melakukan kompilasi terhadap
makefile yang diberikan menjadi sebuah program bernama
contoh.exe. Program ini dihasilkan oleh hasil linker terhadap
dua file objek bernama main.o dan text.o (tentunya termasuk
dengan library yang lain yang dibutuhkan). Untuk memperoleh
main.o, GCC harus melakukan kompilasi source code main.c
menjadi file objek. Begitupula untuk memperoleh text.o, GCC
harus melakukan kompilasi source code text.c.
Pada platform Microsoft® Windows™, terdapat sebuah file
shell script bernama Windows™ Batch File. Kita dapat
menuliskan perintah-perintah yang biasa kita tuliskan secara
terpisah pada command prompt dalam suatu file yang disimpan
dengan ekstensi .bat. Untuk mengeksekusi perintah-perintah
tersebut, kita cukup menjalankan file .bat tersebut sehingga
command prompt terbuka dan perintah-perintah yang kita
tuliskan dieksekusi secara otomatis. Contoh Windows™ Batch
File adalah sebagai berikut.
%~d0
cd "%~dp0"
gcc -E code.c > code.i
gcc -S code.c
gcc -c code.c
gcc -o code.exe code.c
code.exe
pause
Gambar 4 Windows Batch file
Perintah %~d0 memerintahkan command prompt untuk
berpindah drive letter ke drive letter yang sesuai dengan lokasi
Windows™ Batch File berada. Selanjutnya, perintah cd
"%~dp0" memerintahkan command prompt untuk berpindah
folder ke lokasi Windows™ Batch File berada. Selanjutnya,
command prompt mengeksekusi perintah yang memanggil
GCC secara berurutan hingga berhenti akibat adanya perintah
pause. Untuk melanjutkan eksekusi, kita cukup menekan
sebarang tombol pada keyboard sehingga command prompt
mengeksekusi perintah selanjutnya yaitu Object Dump.
D. Instruksi dan Bahasa Assembly Intel® x86
Arsitektur mikroprosesor Intel® x86 merupakan salah satu
arsitektur mikroprosesor yang banyak digunakan. Dengan
mempelajari bahasa assembly dan instruksi Intel® x86, kita
akan sangat terbantu dalam melakukan proses debugging dan
optimisasi program yang kita buat. Dalam mikroprosesor
Intel® x86, terdapat banyak register yang dapat digunakan.
Namun, pada praktikum kali ini, kita cukup mempelajari
beberapa register berikut :
• EAX, EBX, ECX, dan EDX adalah register32-bit
yang bersifat general storage. 

• ESI dan EDIadalah register32-bit yang digunakan
sebagai indexing register. Registerini juga dapat
digunakan sebagai general storage. 

• ESP adalah register32-bit yang digunakan sebagai
stack pointer. Dengan demikian, ESPakan berisi nilai
alamat (address) elemen puncak (top element) dari
stack. Perlu diingat bahwa stack membesar dari alamat
tinggi (high address) ke arah alamat rendah (low
address). Dengan demikian, memasukkan elemen
 baru ke dalam stack akan mengurangi nilai alamat
yangtersimpan pada ESPsedangkan mengeluarkan
elemen dari dalam stack akan menambah ESP.
• EBP adalah register 32-bit yang digunakan sebagai
base pointer. Dengan demikian, EBP akan berisi
alamat dari current activation frame pada stack.
• EIP adalah register 32-bit yang digunakan sebagai
instruction pointer
E. Stack dan Procedure Call
Stack pada umumnya disusun atas beberapa activation
frame. Setiap frame memiliki sebuah base pointer yang
menunjukkan alamat tertinggi (highest address) pada frame
tersebut. Karena stack tumbuh dari high address menuju low
address, base pointer akan menunjukkan alamat tertinggi
frame tersebut.
III. HASIL DAN ANALISIS
A. Tugas 1 : Proses Kompilasi Bahasa C Menggunakan
GCC
Pada tugas 1 ini dilakukan kompilasi program secara
bertahap dengan menggunakan GCC. Proses kompilasi dimulai
dengan membuat code program dalam Bahasa C. Kode tersebut
berextensi file “.c “(dapat dilihat pada Lampiran 1a).
Proses kompilasi diawali dengan preprocessing yang
berperan untuk mengubah file code.c menjadi file code.i. Kedua
file ini sama-sama bertype filetext, sehingga apabila dibuka
pada Notepad++ menghasilkan tampilan code seperti pada
Lampiran 1a dan 1b. Perbedaan yang terlihat antara kedua code
tersebut yaitu pada code.i.
Proses kompilasi kedua yaitu compiling. Pada proses ini
dilakukan penerjemahan code.i (Bahasa C) menjadi code.s
(Bahasa Assembly). Kedua file ini juga masih berupa filetext
sehingga dapa dibuka menggunakan notepad++ (dapat dilihat
pada Lampiran 1b dan 1c). code.s yang sudah dalam Bahasa
assembly ini berisi instruksi-instruksi yang dapat dimengerti
mesin.
Proses selanjutnya yaitu Assembler. Proses ini berperan
untuk menerjemahkan code.s (Bahasa assembly) menjadi
code.o (file objek). Pada tahap ini, file code.o bertipe file
biner,(bukan filetext) sehingga apa bila dibuka dengan text
editor maka akan menghasilkan tampilan karakter yang kurang
dapat dimengerti sebagai berikut :
Gambar 5 Tampilan code.o dibuka dengan text editor
Namun apabila dibuka dengan menggunakan HexEdit, maka
tampilan dengan pola tertentu dalam bentuk perintah biner
(dapat dilihat pada Lampiran 1d).
Proses terakhir yaitu Linker. Proses ini berperan untuk
mengubah code.o (file objek) menjadi code.exe (executable
file). File executable ini juga bertipe file biner, sehingga apabila
dibuka menggunakan text editor akan menampilkan kumpulan
karakter yang tidak dapat dipahami sebagai berikut:
Gambar 6 Tampilan code.exe dibuka dengan text editor
Namun saat dibuka dengan HexEdit maka tampilan akan
berupa suatu pola bilangan biner (seperti pada Lampiran 1e).
Perbedaannya dengan file objek adalah pada executable file ini
ukurannya lebih besar dan isinya lebih banyak dikarenakan file
merupakan gabungan dari semua file yang terkait,
B. Tugas 2 : Proses Kompilasi Bahasa C Menggunakan GCC
dengan Bantuan Batch File
Pada tugas 2 ini dilakukan kompilasi program code.c yang
sama dengan tugas 1. Akan tetapi proses kompilasi tidak
dilakukan dengan memberikan perintah satu persatu pada GCC
melainkan dengan membuat suatu batch file. Batch file yang
digunakan sesuai dengan instruksi pada modul yaitu sebagai
berikut :
%~d0
cd "%~dp0"
gcc -E code.c > code.i
gcc -S code.c
gcc -c code.c
gcc -o code.exe code.c
code.exe
pause
Gambar 7 Batch File
File batch dengan extensi .bat diatas hanya dapat dijalankan
pada platform DOS dan Windows. File batch berisi perintah
yang mampu diterjemahkan oleh command interpreter. Jadi,
file tersebut memiliki cara kerja yang sama dengan command
prompt hanya saya berbeda pada acara eksekusinya.
Proses kompilasi yang dilakukan dengan bantuan batch file
hanya membutuhkan waktu yang singkat karena kompilasi
tidak dilakukan tahap demi tahap melainkan hanya perlu
melakukan double click pada file batch.bat. Hasilnya diperoleh
yaitu berupa file code.i, code.s, code.o, dan code.exe yang
identic sama dengan file pada modul 1 (kompilasi pertahap
dengan GCC).
C. Tugas 3 : Disassembly File Objek
Pada tugas 3 ini akan dilakukan dissassembly file objek dengan
menggunaka objump. Pertama-tama dilakukan dissassembly
file code.c sehingga menghasilkan file
dissassembly_code_o.asm (Lampiran 2a). Kemudian dilakukan
pula disassembly file code.exe dan diperoleh file
disassembly_code_exe.asm (Lampiran 2b).
Gambar 8 Perbandingan hasil disassembly file code.o dan code.exe
Proses disassembly telah dilakukan pada kedua file (code.o
dan code.exe) membuktikan bahwa suatu file binary dapat
diubah kembali menjadi bentuk assembly-nya. Namun terdapat
perbedaan pada kedua file assembly tersebut, yaitu pada file
assembly code.o hanya terdapat bagian main dari program,
sedangkan pada file assembly code.exe tidak hanya terdapat
main program tetapi juga disertain library program serta file-
file lain pendukung program. Hal ini yang menyebabkan
disassembly_code_exe.asm memiliki ukuran file yang jauh
lebih besar dibandingkan dengan disassembly_code_o.asm
D. Tugas 4: Optimisasi Kompilasi Program pada GCC
Pada tugas 4 ini dilakukan 4 jenis optimasi dari file code.c
(diantaranya optimasi -O1, -O2, -O3, -Os, dan –Ofast) yang
kemudian akan dibandingkan hasil file assembly-nya.File
assembly hasil optimasi dapat dilihat pada Lampiran 3.
Pada file original tanpa optimasi (code_O0.s) menghasilkan
file assembly terpanjang dibandingkan dengan file lainnnya
yaitu dengan jumlah baris sebanyak 29 baris.
Pada optimasi –O1, terlihat bahwa jumlah baris yang
dihasilkan (19 baris) menjadi lebih sedikit daripada file code
tanpa optimasi (code_O0.s). Hal ini telah sesuai dengan
referensi yang menyatakan bahwa optimasi dengan –O1 lebih
optimal untuk mengecilkan ukuran file.
Pada optimasi dengan –O2, -O3, -Os, dan –Ofast memiliki
jumlah baris yang sama yaitu 16 baris. Pada masing-masing
optimasi (–O2, -O3, -Os, dan –Ofast) telah dilakukan
pengaktifan flag yang berbeda-beda, namun dikarenakan hasil
optimasi yang diperoleh sama maka dapat dikatakan bahwa
optimasi dengan –O2 saja sudah cukup optimal untuk optimasi
pajang file sehingga flag-flag tambahan tidak terlalu
berpengaruh.
Selain dituinjau dari ukuran file, proses optimasi juga dapat
diamati dari segi runtime program. Pada optimasi –O2, -O3,
dan –Ofast kemungkinan terdapat perbedaan runtime namun
karena tidak dilakukannya pengujian pada praktikum ini, maka
tidak dapat dikertahui perbedaan antar optimasi dari segi
runtime program. Runtime program sendiri dapat dilakukan
dengan mencatat timestamp dari tiap proses yang dilakukan
dengan bantuan library tambahan sehingga dapat mengakses
informasi waktu dati system operasi
E. Tugas 5 : Kompilasi Beberapa File Kode dengan GCC
Pada tugas 5 ini dilakukan proses kompilasi terlebih dahulu
pada file main_text.c (Lampiran 4a) dan text.c (Lampiran 4b)
hingga didapatkan executable file-nya (main_text.exe).
Perintah eksekusi pada command prompt adalah sebagai
berikut :
Gambar 9 Perintah eksekusi pada command prompt
Untuk melakukan kompilasi kedua file, maka dibutuhkan file
header yang berfungsi untuk menghubungkan file main_text.c dan
text.c . File header ini memuat deklarasi fungsi test pada text.c yang
selanjutnya akan diterjemahkan dan digunakan pada file
main_text.c . Hasil eksekusi file diatas menunjukan bahwa GCC
juga dapat digunakan untuk melakukan kompilasi beberapa file
sekaligus serta menjadi penghubung antar file (dengan header)
hingga menjadi satu program yang utuh.
F. Tugas 6: Penggunaan Makefile pada GCC
Pada tugas 6 dengan menggunakan make_file.c dan text.c
seperti pada tugas 5, dilakukan kompilasi kedua file tersebut
dengan memanfaatkan metode makefile. Perintah untuk
makefile adalah sebagai berikut :
all: main_text.exe
main_text.exe: main_text.o text.o
gcc main_text.o text.o -o
main_text.exe
main_text.o: main_text.c
gcc -c main_text.c
text.o: text.c
gcc -c text.c
Gambar 10 Makefile
Setelah dilakukan eksekusi dengan command prompt,
diperoleh hasil kompilasi yang identic sama seperti hasil
kompilasi pada tugas 5. Sehingga dapat disimpulkan bahwa
makefile merupakan cara lain melakukan kompilasi yang
praktis selain menggunakan batch file.
G. Tugas 7 : Header File
Pada tugas 7 ini dilakukan beberapa penggunaan header file
dan extern pada header. Pertama-tama dibuat file add.c (Lampiran
5a), file main.c (Lampiran 5b), file add.h (Lampiran 5c). Program
main.c berfungsi untuk memanggil fungi yang telah didefinisikan
pada add.c . Untuk itu dibutuhkan sebuah header file yang akan
di-include pada main.c sehingga dapat memanggil fungsi pada
add.c .
Gambar 11 Hasil Compiler Tugas 6
Seperti dapat dilihat pada gambar diatas, bahwa program berjalan
sudah sebaimana mestinya proses penjumlahan (accumlator).
Maka dapat dikatakan bahwa integrase file add.c dan main.c serta
add.h (sebagai header file) sudah berhasil
H. Tugas 8 : Pemanggilan Prosedur dan Stack Memory
Pada tugas 8 ini dilakukan percobaan untuk lebih memahami
pemanggilan prosedur dan stack pada memory. Pada proses
pemanggilan prosedur, memory dapat dimodelkan sebagai
stack. Hal ini karena proses pemanggilan memory tersebut
berbasis stacking data. Proses kompilasi Bahasa C dilakukan
secara berurutan yang mengakibatkan prose penyimpanan dan
pengeluaran datanya pun dilakukan secara berurutan. Memory
computer yang kita gunakan sifatnya dinamis, dimana
ukurannya dapat membesar atau mengecil sesuai kebutuhan.
Hal ini dipengaruhi oleh banyaknya data dan optimasi yang
dilakukan. Memory akan dihapus saat telah dilakukan
pengembalian return address. Berikut urutan proses yang
dilakukan pada stack memory :
1. Saat return squaresum (a,b)
Call stack :function:main()
2. Saat int temp1 =square(y)
Call stack :function :
squaresum(y=5,z=9)
3. int temp2 = square(z)
Call stack : function : squaresum(y-5,z=9)
4. return x*x
Call stack : function : square(x=9)
5. return temp1+temp2
Call stack : function : squaresum(y=5,z=9)
7. akhir program
Call stack : mingw CRTStartup()
I. Tugas 9 : Program Fibonacci
Pada tugas 9 ini akan dilakukan eksekusi program fibonacci
hasil dari gabungan file fibo_main.c, inputn.c dan fibo.c.
Ketiga file dihubungkan dengan membuat dua buah header
file yaitu fibo.h dan inputn.h . Dalam pembuatan deret
fibonacci diperlukan aturan untuk menuliskan deret bilangan
fibonachi yaitu Fn = F(n-1)+F(n-2)
Fibo.c adalah file yang berisi code untuk menampilkan
deret bilangan Fibonacci sebanyak n input yang dimasukan
oleh user. Input diperoleh dari fungsi inputn.c . Sedangkan file
fibo_main.c adalah main program yang akan memanggil
kedua fungsi tersebut (fibo.c serta inputn.c). Header fibo.h
berisi deklarasi untuk fungsi fibo sedangkan header inputn.h
berisi deklarasi untuk fungsi inputn.h . Kedua header ini akan
di-include pada fibo_main.c kedua fungsi (fibo.c serta
inputn.c) dapat digunakan pada main program. Lampiran
untuk kode dari setiap program dapat dilihat pada lembar
lampiran.
Hasil dari eksekusi file fibonnaci :
Gambar 12 Hasil eksekusi fibonacci
IV. SIMPULAN
• Pada saat melakukan kompilasi ada 4 tahap yang akan
dilalui apabila menggunakan GCC, yaitu : preprocessing,
compiling, assembling dan linking. Sebuah file yang telah
selesai melalui Preprocessing akan berekstensi “.i”. Untuk
file hasil compiling akan berekstensi “.s”. Untuk file yang
telah melalui proses assembling akan berekstensi “.o”. Dan
untuk file yang telah di linking akan berekstensi “.exe”.
• Kompilasi pada GCC dapat dilakukan dengan beberapa
metode, yaitu menuliskan perintah tahap pertahap pada
command prompt, batch file, dan juga makefile. Metode
batch file pada dasarnya sama seperti melakukan compiling
satu per satu, namun ditulis dalam satu file sehingga hanya
memerlukan sedikit langkah pengerjaan. Sedangkan metode
kompilasi dengan makefile membuat perintah eksekusi file
menjadi lebih mudah
• Penggunaan stack memory dalam setiap pemanggilan
prosedur call akan bersifat dinamis dimana ukuran stack
memory akan membesar sesuai dengan kebutuhan program
yang sedang dijalankan dan juga akan mengecil sesuai
dengan kebutuhan program yang sedang dijalankan.
 REFERENSI
[1] Bryant, Randal, dan David O’Hallaron. Computer Systems
: A Programmer’s Perspective 2nd Edition. Massachusett.
2011.
 Lampiran
1. Source code untuk tugas I
a. Code.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 1
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : code.c
// Deskripsi : Demonstrasi proses kompilasi C
// Menjumlahkan deret bilangan sebanyak N_LOOP

#define N_LOOP 500

int main(void)
{
int indeks;
int accumulator;
indeks = 0;
accumulator = 0;
while(indeks<N_LOOP)
{
accumulator = accumulator + indeks;
indeks = indeks + 1;
}
return accumulator;
}

b. file code.i
# 1 "code.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "code.c"
# 15 "code.c"
int main(void)
{
int indeks;
int accumulator;
indeks = 0;
accumulator = 0;
while(indeks<500)
{
accumulator = accumulator + indeks;
indeks = indeks + 1;
}
return accumulator;
}

c. file code.s
.file "code.c"
.def ___main; .scl 2; .type 32; .endef
.text
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
pushl %ebp
movl %esp, %ebp
subl $24, %esp
andl $-16, %esp
movl $0, %eax
movl %eax, -12(%ebp)
movl -12(%ebp), %eax
call __alloca
call ___main
movl $0, -4(%ebp)
movl $0, -8(%ebp)
L2:
cmpl $499, -4(%ebp)
jle L4
jmp L3
L4:
movl -4(%ebp), %eax
leal -8(%ebp), %edx
addl %eax, (%edx)
leal -4(%ebp), %eax
incl (%eax)
jmp L2
L3:
movl -8(%ebp), %eax
leave
ret

d. file code.o
 e. file code.exe

2. Source code untuk tugas 3

a. Disasssembly_code_o.asm

code.o: file format pe-i386

Disassembly of section .text:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 18 sub $0x18,%esp
6: 83 e4 f0 and $0xfffffff0,%esp
9: b8 00 00 00 00 mov $0x0,%eax
e: 89 45 f4 mov %eax,0xfffffff4(%ebp)
11: 8b 45 f4 mov 0xfffffff4(%ebp),%eax
14: e8 00 00 00 00 call 19 <_main+0x19>
 19: e8 00 00 00 00 call 1e <_main+0x1e>
1e: c7 45 fc 00 00 00 00 movl $0x0,0xfffffffc(%ebp)
25: c7 45 f8 00 00 00 00 movl $0x0,0xfffffff8(%ebp)
2c: 81 7d fc f3 01 00 00 cmpl $0x1f3,0xfffffffc(%ebp)
33: 7e 02 jle 37 <_main+0x37>
35: eb 0f jmp 46 <_main+0x46>
37: 8b 45 fc mov 0xfffffffc(%ebp),%eax
3a: 8d 55 f8 lea 0xfffffff8(%ebp),%edx
3d: 01 02 add %eax,(%edx)
3f: 8d 45 fc lea 0xfffffffc(%ebp),%eax
42: ff 00 incl (%eax)
44: eb e6 jmp 2c <_main+0x2c>
46: 8b 45 f8 mov 0xfffffff8(%ebp),%eax
49: c9 leave
4a: c3 ret
4b: 90 nop
4c: 90 nop
4d: 90 nop
4e: 90 nop
4f: 90 nop

b. Disassembly_code_exe.asm (hanya sebagian screen shoot code)

code.exe: file format pei-i386

Disassembly of section .text:

00401000 <__RUNTIME_PSEUDO_RELOC_LIST_END__>:
401000: 55 push %ebp
401001: 89 e5 mov %esp,%ebp
401003: 83 ec 28 sub $0x28,%esp
401006: c7 44 24 04 04 20 40 movl $0x402004,0x4(%esp,1)
40100d: 00
40100e: 8d 45 fc lea 0xfffffffc(%ebp),%eax
401011: 89 44 24 10 mov %eax,0x10(%esp,1)
401015: a1 10 20 40 00 mov 0x402010,%eax
40101a: c7 45 fc 00 00 00 00 movl $0x0,0xfffffffc(%ebp)
401021: c7 04 24 00 20 40 00 movl $0x402000,(%esp,1)
401028: 89 44 24 0c mov %eax,0xc(%esp,1)
40102c: 8d 45 f8 lea 0xfffffff8(%ebp),%eax
40102f: 89 44 24 08 mov %eax,0x8(%esp,1)
401033: e8 b8 07 00 00 call 4017f0 <___getmainargs>
401038: 89 ec mov %ebp,%esp
40103a: 5d pop %ebp
40103b: c3 ret
40103c: 8d 74 26 00 lea 0x0(%esi,1),%esi

00401040 <__mingw32_init_fmode>:
401040: 55 push %ebp
401041: 89 e5 mov %esp,%ebp
401043: 83 ec 08 sub $0x8,%esp
401046: a1 20 20 40 00 mov 0x402020,%eax
40104b: 85 c0 test %eax,%eax
40104d: 74 57 je 4010a6 <__mingw32_init_fmode+0x66>
40104f: a3 30 20 40 00 mov %eax,0x402030
401054: a1 d0 40 40 00 mov 0x4040d0,%eax
401059: 85 c0 test %eax,%eax
40105b: 75 5a jne 4010b7 <__mingw32_init_fmode+0x77>
40105d: 83 f8 e0 cmp $0xffffffe0,%eax
 401060: 74 22 je 401084 <__mingw32_init_fmode+0x44>
3. Source code untuk Tugas 4
a. code_O0.s

code_O0.o: file format pe-i386

Disassembly of section .text:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 18 sub $0x18,%esp
6: 83 e4 f0 and $0xfffffff0,%esp
9: b8 00 00 00 00 mov $0x0,%eax
e: 89 45 f4 mov %eax,0xfffffff4(%ebp)
11: 8b 45 f4 mov 0xfffffff4(%ebp),%eax
14: e8 00 00 00 00 call 19 <_main+0x19>
19: e8 00 00 00 00 call 1e <_main+0x1e>
1e: c7 45 fc 00 00 00 00 movl $0x0,0xfffffffc(%ebp)
25: c7 45 f8 00 00 00 00 movl $0x0,0xfffffff8(%ebp)
2c: 81 7d fc f3 01 00 00 cmpl $0x1f3,0xfffffffc(%ebp)
33: 7e 02 jle 37 <_main+0x37>
35: eb 0f jmp 46 <_main+0x46>
37: 8b 45 fc mov 0xfffffffc(%ebp),%eax
3a: 8d 55 f8 lea 0xfffffff8(%ebp),%edx
3d: 01 02 add %eax,(%edx)
3f: 8d 45 fc lea 0xfffffffc(%ebp),%eax
42: ff 00 incl (%eax)
44: eb e6 jmp 2c <_main+0x2c>
46: 8b 45 f8 mov 0xfffffff8(%ebp),%eax
49: c9 leave
4a: c3 ret
4b: 90 nop
4c: 90 nop
4d: 90 nop
4e: 90 nop
4f: 90 nop

b. code_O1.s

code_O1.o: file format pe-i386

Disassembly of section .text:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 ec 08 sub $0x8,%esp
6: 83 e4 f0 and $0xfffffff0,%esp
9: b8 00 00 00 00 mov $0x0,%eax
e: e8 00 00 00 00 call 13 <_main+0x13>
13: e8 00 00 00 00 call 18 <_main+0x18>
18: ba 00 00 00 00 mov $0x0,%edx
1d: b8 00 00 00 00 mov $0x0,%eax
22: 01 d0 add %edx,%eax
24: 42 inc %edx
25: 81 fa f3 01 00 00 cmp $0x1f3,%edx
2b: 7e f5 jle 22 <_main+0x22>
2d: c9 leave
 2e: c3 ret
2f: 90 nop

c. code_O2.s

code_O2.o: file format pe-i386

Disassembly of section .text:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 50 push %eax
4: 50 push %eax
5: 31 c0 xor %eax,%eax
7: 83 e4 f0 and $0xfffffff0,%esp
a: e8 00 00 00 00 call f <_main+0xf>
f: e8 00 00 00 00 call 14 <_main+0x14>
14: 31 c0 xor %eax,%eax
16: 31 d2 xor %edx,%edx
18: 01 d0 add %edx,%eax
1a: 42 inc %edx
1b: 81 fa f3 01 00 00 cmp $0x1f3,%edx
21: 7e f5 jle 18 <_main+0x18>
23: c9 leave
24: c3 ret
25: 90 nop
26: 90 nop
27: 90 nop
28: 90 nop
29: 90 nop
2a: 90 nop
2b: 90 nop
2c: 90 nop
2d: 90 nop
2e: 90 nop
2f: 90 nop

d. code_O3.s

code_O3.o: file format pe-i386

Disassembly of section .text:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 50 push %eax
4: 50 push %eax
5: 31 c0 xor %eax,%eax
7: 83 e4 f0 and $0xfffffff0,%esp
a: e8 00 00 00 00 call f <_main+0xf>
f: e8 00 00 00 00 call 14 <_main+0x14>
14: 31 c0 xor %eax,%eax
16: 31 d2 xor %edx,%edx
18: 01 d0 add %edx,%eax
1a: 42 inc %edx
1b: 81 fa f3 01 00 00 cmp $0x1f3,%edx
 21: 7e f5 jle 18 <_main+0x18>
23: c9 leave
24: c3 ret
25: 90 nop
26: 90 nop
27: 90 nop
28: 90 nop
29: 90 nop
2a: 90 nop
2b: 90 nop
2c: 90 nop
2d: 90 nop
2e: 90 nop
2f: 90 nop

e. code_Os.s

code_Os.o: file format pe-i386

Disassembly of section .text:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: e8 00 00 00 00 call 8 <_main+0x8>
8: 31 c0 xor %eax,%eax
a: 31 d2 xor %edx,%edx
c: 01 d0 add %edx,%eax
e: 42 inc %edx
f: 81 fa f3 01 00 00 cmp $0x1f3,%edx
15: 7e f5 jle c <_main+0xc>
17: 5d pop %ebp
18: c3 ret
19: 90 nop
1a: 90 nop
1b: 90 nop
1c: 90 nop
1d: 90 nop
1e: 90 nop
1f: 90 nop

f. code_Ofast.s

code_Ofast.o: file format pe-i386

Disassembly of section .text:

Disassembly of section .text.startup:

00000000 <_main>:
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 e4 f0 and $0xfffffff0,%esp
6: e8 00 00 00 00 call b <_main+0xb>
b: 31 c0 xor %eax,%eax
d: 31 d2 xor %edx,%edx
f: 90 nop
10: 01 d0 add %edx,%eax
12: 83 c2 01 add $0x1,%edx
 15: 81 fa f4 01 00 00 cmp $0x1f4,%edx
1b: 75 f3 jne 10 <_main+0x10>
1d: c9 leave
1e: c3 ret
1f: 90 nop

4. Source code untuk Tugas 5

a. Main Text
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 5
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : main_text.c
// Deskripsi : Demonstrasi MakeFile
// Memanggil prosedur test pada text.c
#include "text.h"
void main(void)
{
test();
}

b. Text.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 5
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : text.c
// Deskripsi : Demonstrasi MakeFile, Mencetak string ke layar
#include <stdio.h>
#include "text.h"
void test(void)
{
printf("Arsitektur Sistem Komputer sangat menyenangkan!\n");
}

c. Text.h
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 5
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
 // Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : text.h
// Deskripsi : Demonstrasi MakeFile, Mencetak string ke layar
#ifndef TES_H
#define TES_H 100
void test(void);
#endif

5. Source code untuk Tugas 7

a. Add.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 7
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : add.c
// Deskripsi : Demonstrasi header file
// Menjumlahkan dua bilangan
#define START_VAL 0

int accum = START_VAL;

int sum(int x, int y)
{
int t = x + y;
accum += t;
return t;
}

b. Main.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 7
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : main.c
// Deskripsi : Demonstrasi header file
// Menjumlahkan dua bilangan
#include<stdio.h>

#include"add.h"
int x , y;
int main()
{
printf("Masukkan nilai x : \n");
scanf("%d",&x);
printf("Masukkan nilai y : \n");
scanf("%d",&y);

int z = sum(x,y);
printf("\n%d",z);
 }

c. Add.h
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 7
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : add.h
// Deskripsi : Demonstrasi header file
// Menjumlahkan dua bilangan
#ifndef ADD_H
#define ADD_H
int sum(int x, int y);

#endif

6. Source code untuk Tugas 9

a. Fibo.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 9
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : fibo.c
// Deskripsi : program fibonacci

#include <stdio.h>

int fibo (int n)

{
int i;
int a = 1;
int b = 1;
int c;
printf("1, 1, ");
for (i=1;i<=n-2;i++)
{
c = a+b;
printf("%d, ",c);
a = b;
b = c;
}
return 0;
}

b. Fibo_main.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
 // Percobaan : 9
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : fibo_main.c
// Deskripsi : program fibonacci

#include <stdio.h>
#include "inputn.h"
#include "fibo.h"

int main(void)
{
int a;
a = input();
fibo(a);
return 0 ;
}

c. Inputn.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 9
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : inputn.c
// Deskripsi : program fibonacci

#include <stdio.h>
#define START_VAL 0

int accum = START_VAL;

int input (void)
{
int n; scanf("%d", &n);
while (n<2)
{
scanf("%d", &n);

}
return (n);
}

d. Fibo.h
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 9
// Tanggal : 28 September 2017
 // Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 2 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 3 : Adi Silaen (14S15061)
// Nama File : fibo.h
// Deskripsi : program fibonacci

#ifdef accum
extern int fibo (int n);
#endif

e. Inputn.h
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul : 1
// Percobaan : 9
// Tanggal : 28 September 2017
// Kelompok : 9
// Rombongan : 1
// Nama (NIM) 1 : Andri Simanjuntak (14S15003)
// Nama (NIM) 1 : Friyogi Tampubolon (14S15025)
// Nama (NIM) 2 : Adi Silaen (14S15061)
// Nama File : inputn.h
// Deskripsi : program fibonacci
#ifdef accum
extern int
input;
#endif