asfa

1. Abstrak— Pada percobaan 1 di praktikum ASK tentang
“Compiler Bahasa C dan Bahasa Assembly Intel R X 86”
bertujuan agar Praktikan dapat memahami tahap kompilasi
program dalam bahasa C, mampu melakukan kompilasi program
bahasa C menggunakan compiler GCC, memahami bahasa
assembly, dan memahami penggunaan stack memory. Dalam
melakukan percobaan, praktikan melakukan beberapa
percobaan yaitu : kompilasi menggunakan GCC, disassembly
menggunakan GCC, optimasi program melalui proses kompilasi,
make file dan batch file, instruksi dan bahasa assembly intel R x
86, stack dan procedure call. Semua perintah preprocessor yang
ditulis dalam bahasa tingkat tinggi akan diproses terlebih dahulu
oleh preprocessor sebelum compiler melaksanakan tugasnya
Compiler akan menerjemahkan bahasa tingkat tinggi C menjadi
kode assembly. Assembler akan menerjemahkan bahasa
assembly menjadi file objek. Pada praktikum ini para praktikan
akan memerlukan aplikasi dalam praktikum adapun
Windows7/8/8.1, compiler GCC dalam paket program
CodeBlocks, notepad++
Keyword— Bahasa C, assembly, makefile, batch file,
stack memory, GCC.
I. PENDAHULUAN
ada praktikum ini kita akan membahas mengenai
bagaimana cara compile Bahasa C sebagai Bahasa
tingkat tinggi dan Bahasa assembly. Pada pembuatan
suatu program pada perangkat elektronik umumnya
menggunakan Bahasa C sebagai Bahasa tingkat tinggi yang
mudah dipahami oleh manusia. Namun mesin
(mikroprosesor) tidak dapat memahami Bahasa tingkat
tinggi. Bahasa Assembly yang dimengerti oleh mesin
disebut dengan compilation. Karena itu dibuatlah Bahasa
assembly sebagai Bahasa penghubung antara Bahasa tingkat
tinggi dan Bahasa tingkat rendah. Bahasa tingkat rendah
merupakan deretan instruksi yang dimengerti oleh mesin,
instruksi ini lah yang dibentuk menjadi bentuk executable
object program yang disimpan dalam bentuk file biner. Dari
sisi instruction set, terdapat dua penggolongan mesin
(mikroprosesor) yaitu CISC (complex instruction set
computer) dan RISC (reduced instruction set computer).
Adapun tujuan dari praktikum ini adalah :
a. Praktikan akan memahami tahap-tahap
kompilasi program dalam Bahasa C sebagai
Bahasa tingkat tinggi hingga diperoleh Bahasa
tingkat rendah yang dapat dieksekusi oleh mesin.
b. Praktikan mampu melakukan kompilasi program
Bahasa C menggunakan compiler GCC beserta
penggunaan makefile dan batch file.
c. Praktikan memahami Bahasa assembly dan
mampu melakukan analisis terhadap Bahasa
assembly Intel® x86 yang dihasilkan oleh
compiler GCC.
d. Praktikan memahami penggunaan stack memory
pada setiap procedure call.
II. LANDASAN TEORETIS
A. Kompilasi Menggunakan GCC
Proses menerjemahkan baris kode program kedalam Bahasa
C menjadi sebuah file .exe (executable) terjadi melalui 4
proses yang digambarkan pada diagram diatas.
 Preprocessor
Semua perintah dalam Bahasa tingkat tinggi akan
diproses oleh preprocessor dahulu sebelum
compiler bekerja.
Adapun tugas dan cara kerja dari preprocessor
adalah:
1. Semua komentar dalam file program diganti
dengan spasi satu buah.
Percobaan I
Compiler Bahasa C dan Bahasa Assembly
Intel® X86
Sandro Maruli Tua Siagian (14S16010)
Tanggal Percobaan : 27/09/2018
[NWS3103] [Computer System Architecture Laboratory]
[Nama Lab] – Teknik Elektro
Institut Teknologi Del
P

2. 2. Semua n (backslash-newline) yang
menandakan baris baru akan dihapus,
dimanapun itu berada. Fitur ini memungkinkan
kita untuk membagi baris program yang
panjang ke dalam beberapa baris tanpa
mengubah arti.
3. Macro yang tela didefinisikan digantikan
dengan definisinya.
 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).
Untuk melakukan proses kompilasi menggunakan
GCC, kita dapat menggunakan Command Prompt
pada Microsoft® Windows™.
B. Diassembly 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.
C. Ompitmasi 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.
gcc –O2 -o Program.exe Program.c
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.
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.
all: contoh
contoh: main.o text.o gcc main.o text.o -o contoh.exe
main.o: main.c gcc -c main.c
text.o: text.c gcc -c text.c
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.

3. %~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.
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.
- 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. Ketika 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 I : Proses Kompilasi Bahasa C Menggunakan
GCC
Code pada pemrograman Bahasa C
// Praktikum NWS3103 Arsitektur Sistem
Komputer
// Modul : 1
// Percobaan: 1
// Tanggal : 27 September 2018
// Kelompok : NA
// Rombongan : 1
// Nama (NIM): Sandro Siagian (14S16010)
// 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;
}

4. Hasil dalam Hex Edit
Pada tugas 1 ini dilakukan kompilasi program secara
bertahap dengan menggunakan GCC.Proses kompilasi
dimulai dengan membuat code program dalam Bahasa C.
Proses kompilasi diawali dengan preprocessing yang
berperan untuk mengubah file code.c menjadi code.i.
Apabila program dijalankan dalam suatu mikroprocessor
yang berbeda, maka assembler harus didesain sedemikian
rupa agar file bahasa C dapat menghasilkan terjemahan
bahasa mesin yang sama.
B. Tugas 2 : Judul Tugas
%~d0
cd "%~d0 "
gcc -E code.c > code.i
gcc -S code.c
gcc -C code.c
gcc -O code.exe code.c
code.exe
pause
# 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;
}
Pada tugas 2 ini dilakukan komilasi program code.c yang
sama dengan menggunakan tugas 1.
Akan tetapi proses kompilasi tidak dilakukan dengan
memberikan perintah satu per satu pada GCC melainkan
dengan membuat suatu batch file. Sesuai dengan landasan
teoritis yang kita gunakan, batc file dapat mengeksekusi
perintah – perintah dan menjalankan command prompt dapat
terbuka otomatis dan melakukan scan otomatis.
C. Tugas 3 : Judul Tugas
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
Pada percobaan 3 ini dilakukan assembly file objek dengan
menggunakan objdump. Proses assembly yang telah
dilakukan pada kedua file code.o dan code.exe
membuktikan suatu file binary dapat diubah kembali
menjadi bentuk assemblnya. Hal yang menyebabkan file
assembly nya memiliki ukuran file yang lebih besar
dibandingkan dengan assembly_code_o.asm.

5. D. Tugas 4
%~d0
cd "%~d0 "
gcc -O0 -c code_O0.c
gcc -O1 -c code_O1.c
gcc -O2 -c code_O2.c
gcc -O3 -c code_O3.c
gcc -Os -c code_Os.c
gcc -Ofast -c code_Ofast.c
objdump -d code_O0.o > code_O0.s
objdump -d code_O1.o > code_O1.s
objdump -d code_O2.o > code_O2.s
objdump -d code_O3.o > code_O3.s
objdump -d code_Os.o > code_Os.s
objdump -d code_Ofast > code_Ofast.s
pause
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. 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
E. Tugas 5
//Praktikum NWS3103 Arsitektur Sistem
Komputer
//Modul : 1
//Percobaan : NA
//Tanggal : 26 September 2016
//Kelompok : NA
//Rombongan : NA
//Nama(NIM)1: Praktikan 1 (NIM_1)
//Nama(NIM)2: Praktikan 2 (NIM_2)
//NamaFile : text.c
//Deskripsi : DemonstrasiMakeFile,Mencetak
string ke layar
#include <stdio.h>
#include <stdlib.h>
#include "text.h"
void test (void)
{
printf("Arsitektur Sistem Komputer sangat
menyenangkan!n");
}
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. 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
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
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. 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.

6. G. Tugas 7
Pada tugas 7 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.
IV. SIMPULAN
 Kompilasi pada GCC terdiri dari 4 tahap yaitu
preprocessing, compiling, assembling, dan linking.
 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.
 Pemanggilan prosedur dapat dipresentasikan seagai
stack memory yag bersifat dinamis.
REFERENSI
[1] Bryant, Randal, dan David O’Hallaron. Computer
Systems : A Programmer’s 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.
[3] Hanindhito, Bagus. Modul Praktikum EL3111
Arsitektur Sistem Komputer, Sekolah Teknik Elektro dan
Informatika, Bandung, 2014.

7. Lampiran
. Lampiran Tugas 1
//Praktikum NWS3103 Arsitektur Sistem
Komputer
//Modul : 1
//Percobaan : NA
//Tanggal : 27 September 2018
//Kelompok : NA
//Rombongan : NA
//Nama (NIM) : Sandro Siagian
(14S16010)
//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;
}
File program.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)

8. jle L4
jmpL3
L4:
movl -4(%ebp), %eax
leal -8(%ebp), %edx
addl %eax, (%edx)
leal -4(%ebp), %eax
incl (%eax)
jmpL2
L3:
movl -8(%ebp), %eax
leave
ret
File program.o
File program.exe
B. Lampiran Tugas 2

9. C. Lampiran Tugas 4
D. Lampiran Tugas 5
//Praktikum NWS3103 Arsitektur Sistem Komputer
//Modul : 1
//Percobaan : Kompilasi Beberapa File Kode dengan
GCC
//Tanggal : 27 September 2018
//Kelompok : NA
//Rombongan : NA
//Nama (NIM) : Sandro Siagian (14S16010)
//Nama File : main_text.c
//Deskripsi : Demonstrasi MakeFile Memanggil Prosedur
// test pada text.c
#include "text.h"
int main (void)
{
test();
system ("pause");
}
File text.c
//Praktikum NWS3103 Arsitektur Sistem Komputer
//Modul : 1
//Percobaan : Kompilasi Beberapa File Kode dengan
GCC
//Tanggal : 27 September 2018
//Kelompok : NA
//Rombongan : NA
//Nama (NIM) : Sandro Siagian (14S16010)
//Nama File : text.c
//Deskripsi : Demonstrasi proses kompilasi C
Menjumlahkan Deret bilangan sebanyak N_loop
#include <stdio.h>
#include <stdlib.h>

10. #include "text.h"
void test (void)
{
printf("Arsitektur Sistem Komputer Sangat
Menyenangkan! n");
}
E. Lampiran Tugas 6
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
Hasil tugas 5 batch file
F. Lampiran Tugas 7
//Praktikum NWS3103 Arsitektur Sistem Komputer
//Modul : 1
//Percobaan : Kompilasi Beberapa File Kode dengan
GCC
//Tanggal : 27 September 2018
//Kelompok : NA
//Rombongan : NA
//Nama (NIM) : Sandro Siagian (14S16010)
//Nama File : add.c
//Deskripsi : Demonstrasi proses kompilasi C
Menjumlahkan Deret bilangan sebanyak N_loop
#include <stdio.h>
#include "add.h"
int accum = START_VAL;
int sum(int x, int y)
{
int t = x + y;
accum += t;
return t;
}
Perintah eksekusi