Percobaan I

Compiler Bahasa C dan Bahasa

Assembly Intel x86
Aldo Erwin Manurung (14S14022)
Tanggal Percobaan : 26/09/2016
NWS3103 Praktikum Arsitektur Sistem Komputer
Laboratorium Sistem Digital Teknik Elektro
Institut Teknologi Del

AbstrakIn the first module of this course, there are nine task
that relating to the compilation of C Language program and
Assembly Language. The software used for the first module is the
GNU C Compiler (GCC), Codeblock, Notepad++, and HexEdit.
The experiments were performed that stages of compiling,
comparing the results of each phase compilation, compilation
techniques with GCC, comparing results compilation is done with
Makefile and batchfile, and the use of stack memory on a
procedure call. At the last of the experiment (the 9th experiment),
the students asked to make Fibonacci program in C Language.
From the first module, the students expected to understand stages
of the compilation of the C Language to be Machine Language,
and be able to compile it with GCC, makefile, and batch file. The
others, the students are also expected to understand and to analyze
Intel X86 Assembly Language and know to use stack memory on
procedure calls..
KeywordAssembly
Language,
Compilation, Stack Memory

GCC,

Optimation,

I. PENDAHULUAN

ada proses pembuatan program di beberapa platform

electronic device, umumnya menggunakan Bahasa tingkat
tinggi karena bahasa lebih mudah dimengerti dan dipahami oleh
manusia seperti halnya Bahasa C. Di satu sisi Bahasa tingkat
tinggi mudah dipahami dan dimengerti oleh manusia, namun
hal sebaliknya terjadi pada mesin (mikroprosesor) yang tidak
dapat mengerti Bahasa tingkat tinggi. Oleh karena itu,
diperlukan suatu Bahasa yang dapat menjadi penghubung
antara kedua Bahasa tersebut (dari Bahasa tingkat tinggi ke
Bahasa tingkat rendah). Kemudian dibuatlah Bahasa Assembly
yang menjadi solusi sebagai penerjemah pemrograman dengan
Bahasa tingkat tinggi menjadi Bahasa tingkat rendah yang
berisi urutan instruksi yang dimengerti oleh mesin. Selanjutnya,
urutan instruksi tersebut akan dikemas kedalam suatu bentuk
executable object program yang disimpan dalam bentuk file
biner. Proses penerjemahan dari Bahasa tingkat tinggi menjadi
Bahasa Assembly (Bahasa tingkat rendah) yang dimengerti
oleh mesin disebut compilation. Dari sisi instruction
set (kumpulan instruksi dalam Bahasa mesin), terdapat dua

penggolongan mesin (mikroprosessor) yaitu Complex

Instruction Set Computer (CISC), contohnya miroprosessor
Intel, dan Reduce Instruction Set Computer (RISC),
contohnya MIPS32. Pada praktikum modul 1 ini, diharapkan
praktikan
mencapai
beberapa
tujuan,
yaitu
:
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 bahaca 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 pengunaan stack memory pada
setiap procedure call.
II. LANDASAN TEORETIS
A. 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 seperti ditunjukkan
pada diagram berikut:

Preprocessor
Semua perintah preprocessor yang ditulis dalam bahasa
tingkat tinggi akan diproses terlebih dahulu oleh
preprocessor sebelum compiler melaksanakan tugasnya.
Beberapa tugas dari preprocessor ini adalah sebagai
berikut.
o Semua komentar dalam file program diganti degan 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.

C. Optimisasi 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.

Contohnya, pada perintah #define MAX_ROWS 10,

preprocessor akan mengganti semua kata MAX_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).

gcc O2 -o Program.exe Program.c

Untuk melakukan proses kompilasi menggunakan GCC,

dapat digunakan Command Prompt pada Microsoft
Windows.
B. 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. Untuk
melakukan disassembly, kita dapat menggunakan perintah
berikut.
objdump -d Program.o
objdump -d Program.exe
Hasil dari proses disassembly ditampilkan pada jendela
Command
Prompt.
Agar
hasil
dari
proses
disassembly dapat disimpan ke dalam suatu file, kita dapat
menggunakan perintah berikut
objdump -d Program.o > Program.s
objdump -d Program.exe > Program.s

Dengan demikian, hasil proses disassembly akan disimpan

dalam file Program.s.

Flag O2 tersebut menandakan bahwa proses kompilasi

dilakukan dengan optimisasi tingkat dua. Beberapa flag
optimisasi yang dikenali oleh GCC adalah O0, O1,
O2, O3, Os, dan Ofast. Perbedaan masing-masing
level optimisasi diberikan sebagai berikut.
-O0 : tidak melakukan optimalisasi sama sekali namun
mengorbankan waktu kompilasi yang lama, dan
menggunakan RAM yang amat besar baik selama
proses kompialasi atau binari nantinya, namun
baiknya binari akan sangat stabil.
-O1 : opstimasi yang dilakukan sedikit dan
menghasilkan waktu kompilasi yang lama, binary
berukuran besar, dan memakan banyak RAM.
-O2 : optimalisasi lebih ditingkatkan (dari O1),
waktu kompilasi lebih cepat, menghasilkan binari
dengan ukuran tidak terlalu besar dan lebih sedikit
menggunakan RAM
-O3
:
optimalisasi
penuh,
memanfaatkan
multithreading, waktu kompilasi yang cepat, binari
berukuran kecil dan menggunakan RAM seminum
mungkin binarinya nanti, namun potensi crash amat
besar jika sistem tidak mendukung atau source code
tidak mendukung opsi ini.
-Os : optimasi dilakukan dengan mengoptimalkan
pada ukuran yang kecil pada binari saja,
-Ofast : mengaktifkan semua optimasi pada O3 dan
pilihan ffast-math dan fortrand specific
D. Makefile dan Batch File
GCC memiliki fitur makefile yang berfungsi untuk
menulis daftar nama file kode di dalam project tersebut.
Kita 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
kita. Contoh isi dari makefile adalah sebagai berikut.

E. 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.
GCC dapat diperintahkan untuk melakukan kompilasi
makefile dengan perintah sebagai berikut.
mingw32-make -f makefile
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 perintahperintah tersebut, kita cukup menjalankan file .bat tersebut
sehingga command prompt terbuka dan perintahperintah
yang kita tuliskan dieksekusi secara otomatis. Contoh
Windows Batch File adalah sebagai berikut.
%~d0
cd "%~dp0"
gcc -O2 -E code.c > Program.l
gcc -O2 -S code.c
gcc -O2 -c code.c
gcc -O2 -o code.c
pause
objdump -d code.o > dump_o.dmp
objdump -d prog.exe > dump_exe.dmp
pause

Windows Batch File tersebut berisi perintah sebagai

berikut. 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.

EAX, EBX, ECX, dan EDX adalah register 32-bit yang

bersifat general storage.
ESI dan EDI adalah register 32-bit yang digunakan
sebagai indexing register. Register ini juga dapat
digunakan sebagai general storage.
ESP adalah register 32-bit yang digunakan sebagai stack
pointer. Dengan demikian, ESP akan 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 yang tersimpan pada
ESP sedangkan 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. Dengan demikian, EIP akan berisi
alamat dari instruksi selanjutnya yang akan dieksekusi.
F. 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. Ke tika
suatu program (caller) memanggil sebuah prosedur
(callee), caller akan memasukkan argumenargumen untuk
memanggil callee dari argumen terakhir hingga argumen
paling awal secara berurutan ke dalam stack. Selanjutnya,
caller akan memasukkan return address ke dalam stack.
Ke mudian, callee memasukkan alamat old base pointer
milik caller ke dalam stack dan memperbarui nilai
base pointer yang sesuai dengan frame callee (nilai base
pointer yang baru sama dengan nilai stack pointer setelah
old base pointer disimpan ke dalam stack). Kemudian
callee
melakukan
alokasi
terhadap
variabel
lokal dan melakukan komputasi sesuai dengan fungsi
callee tersebut. Ke tika callee selesai dieksekusi, callee
akan menyimpan return value pada register EAX.
Kemudian, callee akan membersihkan framenya sendiri
dengan mengganti alamat base pointer dengan old base

pointer yang telah disimpan pada stack. Kemudian, return

address digunakan untuk melanjutkan eksekusi instruksi
pada caller.
III. HASIL DAN ANALISIS
A. Tugas 1 :Proses Kompilasi Bahasa C Menggunakan GCC
Proses kompilasi Bahasa C menggunakan GCC
dimulai dengan membuat code program dalam Bahasa C maka
file yang dibuat berextensi file dot c (.c).
Kemudian dilakukan preprocessing untuk mengubah
file code.c menjadi file code.i. Kedua file ini sam-sama bertype
filetext, sehingga apabila dibuka pada Notepad++
menghasilkan code seperti pada Lampiran 1a dan 1b. Perbedaan
antara kedua code tersebut terlihat pada komentar yang menjadi
tidak ada / hilang pada file code.i, kemudian nilai N_LOOP
yang di definisikan menjadi 500, pada file code.i nilai sudah
langsung terganti. Lalu pada bagian fungsi main, code di dalam
fungsi main bergeser sebesar 1 tab ke kanan.
Pada kompilasi kedua dilakukan proses compiling.
Pada proses ini dilakukan penerjemahan code.c (Bahasa C)
menjadi code.s (Bahasa Assembly). Kedua file ini 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 namun sulit untuk dipahami manusia.
Pada kompilasi ketiga dilakukan proses Assembler.
Pada proses ini dilakukan proses penerjemahkan 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 :

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, misalnya
library.
B. Tugas 2 : Proses Kompilasi Bahasa C Menggunakan GCC
dengan Bantuan Batch File
Pada tugas 2 masih menggunakan code.c yang telah
dibuat pada tugas 1. Sehingga file harus dicopy terlebih dahulu
ke folder tugas 2. Akan dilakukan kompilasi program code.c
yang telah di-copy. 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

Namun apabila dibuka dengan menggunakan HexEdit,

maka tampilan dengan pola tertentu dalam bentuk perintah
biner (dapat dilihat pada Lampiran d).
Pada kompilasi terakhir dilakukan proses Linker. Pada
proses ini dilakukan proses penerjemahan code.o (file objek)
menjadi file code.exe (executable file). File executable bertipe
file biner, sehingga apabila dibuka menggunakan text editor
(misalnya Notepad++) akan menampilkan karakter yang tidak
dapat dipahami juga yaitu seperti:

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 sama dengan file pada tugas 1. Kompilasi dengan batch file
melalakukan operasi yang sama dengan command prompt.
Namun dapat lebih praktis dikarenakan user hanya perlu
melakukan eksekusi file (.bat) tanpa perlu mengetikan perintah
pada command prompt setiap kali akan melakukan kompilasi.
Perbandingan kedua folder seperti berikut:

Isi folder tugas 1

Isi folder tugas 2

C. Tugas 3 : Disassembly File Objek

Pada tugas 3 akan dilakukan proses disassembly file
objek dengan menggunakan file yang sudah ada pada tugas 2.
Maka terlebih dahulu file code.o dan code.exe dari folder tugas
2 di-copy ke folder tugas 3. Pertama-tama dilakukan
disassembly file code.c sehingga menghasilkan file
disassembly_code_o.asm (Lampiran 2a). Kemudian dilakukan
pula disassembly file code.exe dan diperoleh file
disassembly_code_exe.asm (Lampiran 2b).
Proses disassembly yang 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 seperti gambar berikut:

D. Tugas 4: Optimisasi Kompilasi Program pada GCC

Pada tugas 4 yang akan dilihat adalah optimisasi

kompilasi program pada GCC dengan menggunakan file code.c
pada tugas 2 yang di-copy dan digandakan mejadi 5 file pada
folder tugas 4 dengan masing-masing nama yaitu code_O1.c,
code_O2.c, code_O3.c, code_Os.c, dan code_Ofast.c.
Kemudian dilakukan kompilasi kelima file kode
tersebut dengan pilihan optimisasi yang berbeda lalu secara
otomatis melakukan proses disassembly kelima file objek yang
dihasilkan. Adapun batch file pada tugas 4 yaitu seperti berikut:

%~d0
cd "%~dp0"
gcc -O0 -c
gcc -O1 -c
gcc -O2 -c
gcc -O3 -c
gcc -Os -c
gcc -Ofast
objdump -d
objdump -d
objdump -d
objdump -d
objdump -d
objdump -d
pause

code_O0.c
code_O1.c
code_O2.c
code_O3.c
code_Os.c
-c code_Ofast.c
code_O0.o > code_O0.s
code_O1.o > code_O1.s
code_O2.o > code_O2.s
code_O3.o > code_O3.s
code_Os.o > code_Os.s
code_Ofast.o > code_Ofast.s

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
landasan teori 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 masingmasing 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. Ke 5 file
setelah dibuka dengan teks editor dapat dilihat pada lampiran 3.
E. Tugas 5: Kompilasi Beberapa File Kode dengan GCC
Pada tugas 5 akan dilakukan proses kompilasi
beberapa file kode dengan GCC. Maka terlebih dahulu
membuat file main_text.c dan file text.c yang terlampir pada
lampiran 4a dan 4b. 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. Isi dari file
header yaitu text.h terlampir pada lampiran 4c. Hasil kompilasi
file main_text.c dan file text.c untuk menghasilkan
main_text.exe yang kemudian dijalankan yang ditampilkan
pada command prompt sebagai berikut:

Program berjalan sudah sebaimana mestinya proses

penjumlahan (accumlator). Maka dapat dikatakan bahwa
integrase file add.c, main.c dan add.h (sebagai header file) telah
berhasil.
Hasil eksekusi file 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 akan dilakukan penggunaan Makefile pada GCC
dengan menggunakan file yang sudah ada sebelumnya pada
tugas 5 yaitu file main_text.c, text.c dan text.h, maka semua file
di-copy terlebih dahulu ke folder tugas 6. Kemudian 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

H. Tugas 8: Pemanggilan Prosedur dan Stack Memory

Pada tugas 8 dilakukan proses pemanggilan prosedur dan stack
memory untuk lebih memahami pemanggilan prosedur dan
stack pada memory. Isi kode file main.c yang digunakan adalah
kode pada isi file tugas pendahuluan (sumofquare.c). 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 proses
penyimpanan dan pengeluaran datanya pun dilakukan secara
berurutan. Memory computer yang digunakan sifatnya dinamis,
dimana ukurannya dapat membesar atau mengecil sesuai
kebutuhan. Hal ini dipengaruhi oleh banyaknya data dan
optimasi yang dilakukan. Memory akan dihapus setelah
dilakukan pengembalian return address. Berikut nilai memory
di antara addres yang ditunjukkan oleh EBP dan ESP pada
setiap kode yang diinstruksikan.
return squaresum(a,b);

text.o: text.c
gcc -c text.c

Setelah dilakukan eksekusi dengan command prompt,

diperoleh hasil kompilasi yang sama seperti hasil
kompilasi pada tugas 5. Sehingga dapat disimpulkan bahwa
makefile merupakan cara lain melakukan kompilasi yang
praktis selain menggunakan batch file. Hasil kompilasi adalah
sebagai berikut:

Nilai memory

int temp1 = square(y);

Nilai memory
G. Tugas 7: Header File
Pada tugas 7 akan belajar untuk membuat dan
memanfaatkan header file dan memahami bagaimana extern
pada header file bekerja. Untuk memulai tugas 7 maka dibuat
file add.c, header file add.h yang akan di-include pada main.c
dan file main.c yang meminta pengguna memasukkan dua buah
bilangan lalu menjumlahkan kedua bilangan tersebut dengan
memanggil fungsi sum. Masing-masing isi file terlampir pada
lampiran 5a-5d.
Proses pemanggilan fungsi yang telah didefinisikan
pada add.c akan mengalami masalah apabila variabel accum
(pada add.c) tidak di-extern terlebih dahulu sehingga variabel
tidak terdefinisi pada main.c Fungsi extern pada header yaitu
agar suatu variabel dalam sebuah file dapat digunakan pada file
.c lainnya. Berikut perintah eksekusi program:

return x*x;

Nilai memory

int temp2 = square(z);

Nilai memory

return x*x;

Nilai memory

IV. SIMPULAN

return temp1+temp2;

Nilai memory
I. Tugas 9: Program Fibonacci
Pada tugas 9 akan dibuat program penghitung deret Fibonacci
yang sederhana untuk menampilkan deret Fibonacci. Untuk
membuat sebuah program penghitung deret Fibonacci yang
sederhana dibutuhkan prosedur ataupun kode yaitu fibo.c,
fibo.h, inputn.c, inputn.h, dan fibo_main.c, yang terlampir
pada lampiran 6a-6c. Adapun kode untuk header yaitu:

Fibo.h

Inputn.h

Fibo.c adalahh 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. Eksekusi
program yaitu sebagai berikut:

Kompilasi pada GCC terdiri dari 4 tahap yaitu

preprocessing, compiling, assembling, dan linking. File
hasil preprocessing yaitu berekstensi .i . File hasil
compiling berekstensi file .s. File hasil ssembling
berekstensi file .o serta file hasil proses linking
berekstensi .exe . File .o dan .exe bertype file biner
sedangkan ketiga ekstensi file lainnya bertype file text.
Proses 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.
Compiler GCC dapat melakukan disassembly file objek dan
file executable yaitu dengan mengubah file.o dan file.exe
manjadi bertype file assembly.
Kompilasi pada GCC dapat dilakukan dengan beberapa
jenis optimasi (disesuaikan dengan kebutuhan), seperti O0,
-O1,-O2, -O3, -Os, dan Ofast. Trade off yang
dipertimbangkan yaitu ukuran source code, runtime
program, kecepatan kompilasi, serta kemudahan dalam
debugging.
Header file berfungsi sebagai penghubung antara dua file
atau lebih sehingga fungsi atau prosedur pada suatu fungsi
juga dapat digunakan pada fungsi lain (yang dihubungkan).
Extern berfungsi untuk mendeklarasikan sebuah variable
global agar dapat dipakai pada semua file yang telah
diubungkan dengan header.
Pemanggilan prosedur dapat direpresentasikan sebagai
stack memory yang bersifat dinamis (ukuran dapat
membesar dan mengecil sesuai kebutuhan program yang
dijalankan).

REFERENSI
[1] Bryant, Randal, dan David OHallaron. Computer Systems : A Programmers
Perspective 2nd Edition. 2011. Massachusetts : Pearson Education Inc. Patterson,
[2] David, dan John Hennessy. Computer Organization and Design : The
Hardware/Software Interface. 2012. Waltham : Elsevier Inc.

Lampiran
1. Source code untuk tugas I
a. code.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul
:1
// Percobaan
:1
// Tanggal
: 26 September 2016
// Kelompok
:5
// Rombongan
:1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang (14S14010)
// 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. code.i
# 1 "code.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "code.c"
# 14 "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. code.s
.file
.def
.text
.globl _main
.def
_main:
pushl
movl

"code.c"
___main;

.scl

2;

.type

32;

_main; .scl

2;

.type

32;

.endef

%ebp
%esp, %ebp

.endef

subl
andl
movl
movl
movl
call
call
movl
movl

$24, %esp
$-16, %esp
$0, %eax
%eax, -12(%ebp)
-12(%ebp), %eax
__alloca
___main
$0, -4(%ebp)
$0, -8(%ebp)

cmpl
jle
jmp

$499, -4(%ebp)
L4
L3

movl
leal
addl
leal
incl
jmp

-4(%ebp), %eax
-8(%ebp), %edx
%eax, (%edx)
-4(%ebp), %eax
(%eax)
L2

movl
leave
ret

-8(%ebp), %eax

L2:

L4:

L3:

d. code.o

e. code.exe

2. Hasil 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 e4 f0 and $0xfffffff0,%esp
6:83 ec 10 sub $0x10,%esp
9:e8 00 00 00 00 call e <_main+0xe>
e:c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
15:00
16:c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
1d:00
1e:eb 0c jmp 2c <_main+0x2c>
20:8b 44 24 0c mov 0xc(%esp),%eax
24:01 44 24 08 add %eax,0x8(%esp)
28:ff 44 24 0c incl 0xc(%esp)
2c:81 7c 24 0c f3 01 00 cmpl $0x1f3,0xc(%esp)

33:00
34:7e
36:8b
3a:c9
3b:c3

b.

3.

ea jle 20 <_main+0x20>
44 24 08 mov 0x8(%esp),%eax
leave
ret

Disassembly_code_exe.asm (hanya sebagian screen shoot code

Hasil 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 e4 f0 and $0xfffffff0,%esp
6:83 ec 10 sub $0x10,%esp
9:e8 00 00 00 00 call e <_main+0xe>
e:c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)

15:00
16:c7
1d:00
1e:eb
20:8b
24:01
28:ff
2c:81
33:00
34:7e
36:8b
3a:c9
3b:c3

b.

44 24 08 00 00 00 movl $0x0,0x8(%esp)
0c
44
44
44
7c

jmp 2c <_main+0x2c>
24 0c mov 0xc(%esp),%eax
24 08 add %eax,0x8(%esp)
24 0c incl 0xc(%esp)
24 0c f3 01 00 cmpl $0x1f3,0xc(%esp)

ea jle 20 <_main+0x20>
44 24 08 mov 0x8(%esp),%eax
leave
ret

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 e4 f0 and $0xfffffff0,%esp
6:e8 00 00 00 00 call b <_main+0xb>
b:b8 00 00 00 00 mov $0x0,%eax
10:40 inc %eax
11:3d f4 01 00 00 cmp $0x1f4,%eax
16:75 f8 jne 10 <_main+0x10>
18:b8 4e e7 01 00 mov $0x1e74e,%eax
1d:c9 leave
1e:c3 ret
1f:90 nop

c.

Code_O2.s
code_O2.o: file format pe-i386
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:b8 4e e7 01 00 mov $0x1e74e,%eax
10:c9 leave
11:c3 ret
12:90 nop
13:90 nop

d.

Code_O3.s
code_O3.o: file format pe-i386
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:b8 4e e7 01 00 mov $0x1e74e,%eax
10:c9 leave
11:c3 ret
12:90 nop
13:90 nop

e.

Code_Os.s
code_Os.o: file format pe-i386
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:b8 4e e7 01 00 mov $0x1e74e,%eax
10:c9 leave
11:c3 ret
12:90 nop
13:90 nop

f.

Code_Ofast.s
code_Ofast.o: file format pe-i386
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:b8 4e e7 01 00 mov $0x1e74e,%eax
10:c9 leave
11:c3 ret
12:90 nop
13:90 nop

4.

Hasil Tugas 5
a. Main_text.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul
: 1
// Percobaan : 5
// Tanggal
: 26 September 2016
// Kelompok : 5
// Rombongan : 1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
// 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 : 5
// Rombongan : 1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
// 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
#ifndef TES_H
#define TES_H 100
void test(void);
#endif

5.

Hasil Tugas 7
a. Add.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul
: 1
// Percobaan : 7
// Tanggal
: 26 September 2016
// Kelompok : 5
// Rombongan : 1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
// 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 : 5
// Rombongan : 1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
// Nama File : main.c
// Deskripsi : Demonstrasi header file
// Menjumlahkan dua bilangan
#include <stdio.h>
#include "add.h"
int main(void)
{
int x,y,z;
scanf("%d", &x);
scanf("%d", &y);
z = sum(x,y);
printf("%d", z);
return 0;
}

c.

Add.h
#ifndef accum
extern int sum (int x, int y);
#endif

d.

Makefile
all: main.exe
main.exe: main.o add.o
gcc main.o add.o -o main.exe
main.o: main.c
gcc -c main.c
add.o: add.c
gcc -c add.c

6.

Kode program untuk tugas 9

a. Inputn.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul
: 1
// Percobaan : 9
// Tanggal
: 26 September 2016
// Kelompok : 5
// Rombongan : 1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
// 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);
}

b.

Fibo.c
// Praktikum NWS3103 Arsitektur Sistem Komputer
// Modul
: 1
// Percobaan : 9
// Tanggal
: 26 September 2016
// Kelompok : 5
// Rombongan : 1
// Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
// Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
// 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;
}

c.

Fibo_main.c
//
//
//
//
//
//
//
//
//

Praktikum NWS3103 Arsitektur Sistem Komputer

Modul
: 1
Percobaan : 9
Tanggal
: 26 September 2016
Kelompok : 5
Rombongan : 1
Nama (NIM) 1 : Aldo Erwin Manurung (14S14022)
Nama (NIM) 2 : Grace La Rosa Sihotang(14S14022)
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 ;
}