Percobaan I

Compiler Bahasa c dan Bahasa

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

Abstrak—The module will do nine experiment, start from
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
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 program fibbonachi. There are some program or
software must be installed in advanced Notepade++, CodeBlock,
and HexEdit. Elsewhere, the labor can understand and analysis
of compiling assembly language and C language and understand
use stack memory in procedure call.
Kata Kunci—Bahasa Assembly, GCC, Optimasi,
memory.
I. PENDAHULUAN
II.LANDASAN TEORETIS
Kompilasi menggunakan GCC
Proses menerjemahkan baris kode program dalam bahasa C
menjadi file executable dilakukan dalam empat langkah yaitu
preprocessor, compiler, assembler, dan linker yang
seluruhnya disebut sistem kompilasi.
Gambar 1 Proses Kompilasi
 Preprocessor
Stack
Semua perintah preprocessoryang ditulis dalam bahasa tingkat
tinggi akan diproses terlebih dahulu oleh preprocessor
sebelum compiler melaksanakan tugasnya. Beberapa tugas
dari preprocessor ini adalah sebagai berikut.

D
alam proses pembuatan suatu program, bahasa tingkat
tinggi lebih banyak digunakan karena bahasa
tersebut lebih mudah dimengerti dan dipahami oleh manusia
seperti Bahasa C. Namun, bahasa tersebut tidak dapat dibaca
oleh mesin (mikroposessor) yang berbasis bahasa tingkat
rendah, sehingga program tersebut tidak akan di eksekusi.
Oleh karena itu akan diperlukan suatu penghubung antara
bahasa tingkat tinggi dan bahasa tingkat rendah yaitu berupa
bahasa assembly yang menjadi penerjemah pemrograman
tingkat tinggi menjadi Bahasa tingkat rendah yang berisi
urutan instruksi yang dimengerti oleh mesin. Proses
penerjemahan dari Bahasa tingkat tinggi menjadi Bahasa
Assembly yang dimengerti oleh mesin disebut compilation.
Pada praktikum ini tujuan yang ingin dicapai antara lain :
1. Praktikan memahami tahap-tahap kompilasi program
dalam bahasa C sebagai bahasa tingkat tinggi hingga
diperoleh bahasa tingkat rendah yang dapat
dieksekusi oleh mesin.
2. Praktikan mampu melakukan kompilasi program
bahasa C menggunakan compiler GCC beserta
penggunaan makefile dan batch file.
3. Praktikan memahami bahasa assembly dan mampu
melakukan analisis terhadap bahasa assembly Intel®
x86 yang dihasilkan oleh compiler GCC.
4. Praktikan memahami penggunaan stack memory pada
setiap procedure call.
o Semua komentar dalam file program diganti dengan
spasi satu buah.
o Semua \n (backslash-newline) yang menandakan
baris baru akan dihapus tidak peduli dimanapun dia
berada. Fitur ini memungkinkan kita untuk membagi
baris program yang panjang ke dalam beberapa baris
tanpa mengubah arti.
o Macro yang telah didefinisikan diganti dengan
definisinya.
Contohnya, pada perintah #define MAX_ROWS 10,
preprocessor akan mengganti semua kataMAX_ROWS
dengan 10.Pada perintah #include <stdio.h>, preprocessor
akan mengganti baris tersebut dengan isi file stdio.h
 Compiler
Compiler akan menerjemahkan bahasa tingkat tinggi C
menjadi kode assembly. Kode assembly ini berisi instruksi-
instruksi yang sesuai dengan instruction set yang dimiliki oleh
mesin. File yang dihasilkan pada tahap ini masih berupa file
teks (.s).
 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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; .type32; .endef
.text
.globl _main
.def _main; .scl 2; .type32; .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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// 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 : 26 September 2016
// Kelompok : 4
// Rombongan : 1
// Nama (NIM) 1 : Dedi Bob Lumban Tobing (14S14008)
// Nama (NIM) 2 : Daniel Fernando Purba (14S14020)
// Nama File : inputn.h
// Deskripsi : program fibonacci
#ifdef accum
extern int
input;
#endif