EL3111_2_13213060

(1)

Abstrak— Pada modul 1I ini dilakukan 13 tugas percobaan yang berkaitan dengan pointer, structure, array, dan operasi dalam level bit. Software yang digunakan selama praktikum yaitu GNU C Compiler (GCC), CodeBlock, Notepad++, dan HexEdit. Percobaan yang dilakukan antara lain membuat fungsi XOR, fungsi ekstraksi Byte, fungsi masking Byte, membuat fungsi untuk membalik urutan Byte, fungsi pengurangan Byte, fungsi shift register, membuat program enkripsi sederhana, menggunakan pointer dalam Assembly, membuat fungsi untuk membalik urutan, membuat matriks nama, mebuat matriks nama dengan pointer, melakukan perkalian matriks, dan melakukan penjumlahan biner dengan Array. Melalui percobaan ini diharapkan praktikan dapat memahami representasi informasi dalam level bit didalam memori serta mampu mengolahnya dengan menggunakan operator bitwise, mampu memahami fungsi pointer dan dapat menggunakannya untuk mengolah data di memory. Selain itu, dengan adanya praktikum ini diharapkan praktikan dapat memahami penggunaan array dan structure beserta representasinya pada memori.

Kata Kunci— Pointer, Array, Structure, Bitwise. I. PENDAHULUAN

alam Bahasa C dikenal terdapat beberapa fitur yang dapat mempermudah dalam pembuatan program, diantaranya pointer, array dan structure. Pointer (variable penunjuk) adalah suatu variable yang berisi alamat memori dari suatu variable lain. Alamat ini merupakan lokasi dari objek lain di dalam memori. Dalam penggunaan pointer terdapat 2 buah operator yang digunakan, yaitu & (address of/operator alamat) dan * (value pointed by). Array adalah sekumpulan variable yang memiliki tipe data yagn sama dan dinyatakan dengan nama yang sama. Array memungkinkan kita dapat menyimpan data maupun referensi objek dalam jumlah banyak dan terindeks. . Pointer dan array sendiri sangat erat kaitannya karena sesungguhnya array secara internal akan diterjemahkan dalam bentuk pointer. Structure atau biasa disingkat struct merupakan suatu struktur data yang menggabungkan beberapa data dengan berbagai tipe data yang memiliki ukuran yang berbeda kemudian dikelompokan dalam satu deklarasi yang unik dan saling berkaitan. Struct secara logic membuat suatu tipe data

baru (user defined) yang dapat dipergunakan untuk menampung informasi (data) yang bersifat majemuk. Pada Bahasa C terdapat 2 jenis operasi yang digunakan pada level bit, yaitu locical operation dan bitwise operation. Operasi bitwise adalah operasi matematika yang berproses pada level bit/digit dari sebuah bilangan bulat (integer). Sedangkan operasi logical adalah operasi yang hasil akhirnya berupa pernyataan True (1) atau False (0). Jika berbicara hal seperti system kompresi data dan keefektifan suatu program operasi bitwise sangatlah penting. Contohnya jika kita biasa menggunakan 13 bit untuk data A, dan 5 bit untuk data B maka jumlah yang diperlukan adalah 18 bit. Dengan prinsip yang ada pada bitwise, tempat/slot yang digunakan hanya 13 bit karena data A dan dataB dibuat saling berbadi dan menggunakna tempat yang sama. Bitwise dapat memanipulasi satuan terkecil yang dapat digunakan untuk memperkecil memori yang digunakan sehingga program dapat berjalan lebih cepat.

Pada praktikum ini tujuan yang ingin dicapai antara lain : 1. Praktikan memahami representasi informasi dalam

level bit yang disimpan pada memory.

2. Praktikan mampu menggunakan

operator-operator

bitwise

dalam bahasa C untuk mengolah

informasi yang tersimpan dalam

memory

.

3. Praktikan memahami fungsi

pointer

dan mampu

menggunakan

pointer

untuk

melakukan

pengolahan data di dalam

memory

.

4. Praktikan

memahami

array

beserta

representasinya dalam

memory

dan pengolahan

informasinya dalam bahasa C.

5. Praktikan

memahami

structure

beserta

representasinya dalam

memory

dan pengolahannya

dalam bahasa C.

.

II. LANDASAN TEORETIS Tipe Data

Percobaan II

Pointer, Structure, Array, dan Operasi

dalam Level Bit

Rosana Dewi Amelinda (13213060)

Asisten : Syaiful Andy (13212050)

Tanggal Percobaan : 13/10/2015 EL3111 Praktikum Arsitektur Sistem Komputer

Laboratorium Sinyal dan Sistem – Sekolah Teknik Elektro dan Informatika Institut Teknologi Bandung

(2)

Tipe data merupakan representasi data yang disimpan dalam memory. Tipe data menentukan operasi yang dapat dilakukan pada suatu data bertipe tertentu, rentang nilai yang mungkin dimiliki oleh data bertipe tertentu, arti dari data, dan cara menyimpan data tersebut dalam memory. Terdapat beberapa tipe data yang telah tersedia dalam bahasa C. Tipe data yang tersedia ini disebut simple data type.

Masing-masing tipe data memiliki ukuran yang berbeda-beda untuk disimpan di dalam memory. Dalam bahasa C, kita dapat menggunakan sintaks sizeof untuk mengetahui besar tipe data tersebut di dalam memory. Contohnya, untuk mengetahui ukuran tipe data integer, kita cukup menggunakan perintah sizeof (int) untuk mengetahui ukurannya. Kita juga dapat melihat rentang nilai yang direpresentasikan oleh masing-masing tipe data.

Tipe Data Ukuran Rentang Nilai

Char 1 Byte -128 – 127

Unsigned Chart 1 Byte 0 – 255 Signed Chart 1 Byte -128 – 127

Short 2 Byte -32768 – 32768

Unsigned Short 2 Byte 0 – 65535 Signed Short 2 Byte -32768 – 32768

Int 4 Byte -2147483648 –

2147483647 Unsigned Int 4 Byte 0 – 4294967295

Signed Int 4 Byte -2147483648 –

2147483647

Long 4 Byte -2147483648 –

2147483647 Unsign Long 4 Byte 0 – 4294967295

Signed Long 4 Byte -2147483648 –

2147483647

Long Long 8 Byte -9223372036854775808 – 9223372036854775807 Unsigned Long Long 8 Byte 0 -- 18446744073709551615 Signed Long Long 8 Byte -9223372036854775808 – 9223372036854775807 Float 4 Byte ? Double 8 Byte ?

Data pada table diatas dapat diketahui dengan program sederhana sebagai berikut.

#include <stdio.h> #include <limits.h>

int main(void) {

int zero = 0;

printf("Char Byte Size: %d\n",

sizeof(char));

printf("Unsigned Char Byte Size:

%d\n", sizeof(unsigned char));

printf("Signed Char Byte Size:

%d\n", sizeof(signed char));

printf("Short Byte Size: %d\n",

sizeof(short));

printf("Unsigned Short Byte Size:

%d\n", sizeof(unsigned short));

printf("Signed Short Byte Size:

%d\n", sizeof(signed short));

printf("Int Byte Size: %d\n",

sizeof(int)); printf("Unsigned Int

Byte Size: %d\n", sizeof(unsigned

int));

printf("Signed Int Byte Size: %d\n",

sizeof(signed int));

printf("Long Byte Size: %d\n",

sizeof(long));

printf("Unsigned Long Byte Size:

%d\n", sizeof(unsigned long));

printf("Signed Long Byte Size:

%d\n", sizeof(signed long));

printf("Long Long Byte Size: %d\n",

sizeof(long long));

printf("Unsigned Long Long Byte

Size: %d\n", sizeof(unsigned long

long));

printf("Signed Long Long Byte Size:

%d\n", sizeof(signed long long));

printf("Float Byte Size: %d\n",

sizeof(float));

printf("Double Byte Size: %d\n",

sizeof(double));

printf("Char Byte Range: %d - %d\n", CHAR_MIN, CHAR_MAX);

printf("Unsigned Char Byte Size: %d

- %d\n", zero, UCHAR_MAX);

printf("Signed Char Byte Size: %d -

%d\n", SCHAR_MIN, SCHAR_MAX);

printf("Short Byte Size: %d - %d\n", SHRT_MIN, SHRT_MAX);

printf("Unsigned Short Byte Size: %d

- %d\n", zero, USHRT_MAX);

printf("Signed Short Byte Size: %d -

%d\n", SHRT_MIN, SHRT_MAX);

printf("Int Byte Size: %d - %d\n", INT_MIN, INT_MAX);

printf("Unsigned Int Byte Size: %d -

%d\n", zero, UINT_MAX);

printf("Signed Int Byte Size: %d -

%d\n", INT_MIN, INT_MAX);

printf("Long Byte Size: %d - %d\n", LONG_MIN, LONG_MAX);

(3)

printf("Unsigned Long Byte Size: %d

- %d\n", zero, ULONG_MAX);

printf("Signed Long Byte Size: %d -

%d\n", LONG_MIN, LONG_MAX);

printf("Long Long Byte Size: %d -

%d\n", LLONG_MIN, LLONG_MAX);

printf("Unsigned Long Long Byte

Size: %d - %d\n", zero, ULLONG_MAX);

printf("Signed Long Long Byte Size:

%d - %d\n", LLONG_MIN, LLONG_MAX);

return 0;

}

Dengan adanya perbedaan ukuran masing-masing tipe data, diperlukan sebuah mekanisme alignmentpada memoryagar setiap data tersusun dengan baik di dalam memorydan dapat diproses oleh mikroprosesor.Dengan alignment, data-data variabel disimpan dalam lokasi memoryyang memiliki address offset yang berupa kelipatan dari ukuran word. Hal ini akan menambah performance karena data disusun sesuai cara mikroprosesor menggunakan memory. Operator Bitwise dalam Bahasa C

Bahasa C mendukung pengolahan informasi dalam level bit menggunakan operator bitwise. Berbeda dengan operator level byte, operator bitwiseakan mengoperasikan data untuk setiap bit. Sedangkan operator level byte, data akan diolah dalam bentuk 1 byte (1 byte = 8bit). Operator bitwisedapat digunakan pada berbagai tipe data seperti char, int, short, long, atau unsigned. Operator-operator bitwise dalam bahasa C didefinisikan sebagai berikut

.

Simbol

Operator

&

Bitwise AND

|

Bitwise inclusive OR

^

Bitwise exclusive OR

<<

Left Shift

>>

Right Shift

~

Bitwise NOT (one’s complement)

(unary)

Bahasa C juga memiliki operator logika AND, inclusive OR, dan NOT. Operator ini sering tertukar dengan operator bitwise. Operator logika tersebut diberikan sebagai berikut. Pada operasi logika, setiap argumen bukan nol merepresentasikan TRUE, sedangkanargumen nol merepresentasikan FALSE. Ekspresi logika akan mengembalikan nilai 1 untuk TRUE dan nilai 0 untuk FALSE.

Simbol Operator

&& Logical AND

| | Logical OR

! Logical NOT

Khusus untuk operator Right Shift, terdapat dua jenis operator Right Shift, yaitu Logical Right Shift dan Arithmetic Right Shift. Logical Right Shift akan mengisi bit MSB dengan nilai 0 sementara Arithmetic Right Shiftakan mengisi bit MSB sesuai dengan tanda (sign) variabel tersebut menurut aturan two’s complement. Untuk Left Shift, tidak ada perbedaan antara Logical Left Shiftdan Arithmetic Left Shift. Pada umumnya, seluruh mesin dapat mendukung dua jenis operator Right Shiftdan Left Shift ini.

Structure

Structure (struct) merupakan complex data type yang mendefinisikan daftar variabel yang akan ditempatkan dalam blok memory menggunakan satu nama. Dengan demikian, setiap variabel berbeda pada structure dapat diakses menggunakan sebuah single pointer atau dengan menggunakan nama structure itu sendiri. Pada structure, masing-masing variabel disimpan dalam blok memory yang kontigu yang biasanya memiliki delimiter berupa panjang word. Kita juga dapat menggunakan sintaks sizeof untuk memeriksa ukuran structureyang kita definisikan. Perlu diingat bahwa bahasa C tidak mengizinkan kita melakukan deklarasi rekursif terhadap structure (sebuah structure tidak boleh berisi structure bertipe yang sama dengan structure tersebut). Kita dapat menggunakan pointer untuk melakukannya. Beberapa mesin juga membutuhkan alignment data pada memory secara spesifik sehingga ukuran structure dapat berbeda karena compiler secara otomatis melakukan alignment data-data pada structure, contohnya dengan padding.

Array

Array merupakan kumpulan lokasi penyimpanan data yang kontigu (berurutan) dengan tipe data yang sama. Setiap lokasi penyimpanan dalam sebuah arraydisebut elemen array. Array dialokasikan secara sekaligus dalam memory sesuai dengan ukurannya. Karena letak elemen yang berurutan, akses elemen array pada memory relatif lebih mudah dan cepat dibandingkan dengan struktur data Linked-List. Setiap elemen dalam array dapat diakses menggunakan indeks yang biasanya berupa bilangan bulat skalar bukan negatif. Dalam bahasa C, elemen pertama dalam array diberi indeks 0. Representasi array dalam memory dengan deklarasi int nim[8]adalah sebagai berikut (asumsikan address elemen ke-0 adalah 0x4000 dengan nilai elemen pertama adalah 1, nilai elemen kedua adalah 3, nilai elemen ketiga adalah 2, nilai elemen keempat adalah 1, nilai elemen kelima adalah 1, nilai elemen keenam adalah 0, nilai elemen ketujuh adalah 0 dan nilai elemen edelapan adalah 7).

Nilai 1 3 2 1

Alamat 0x4000 0x4004 0x4008 0x400C Indeks nim[0] nim[1] nim[2] nim[3]

(4)

Alamat 0x4010 0x4014 0x4018 0x401C Indeks nim[4] nim[5] nim[6] nim[7] Bahasa C mendukung deklarasi array secara statis maupun secara dinamis. Array statis memiliki ukuran yang tidak bisa diubah-ubah sedangkan arraydinamis memiliki ukuran yang dapat ditentukan saat program sedang berjalan.Array dinamis dapat dideklarasikan dengan contoh int pusheen[]. Dengan demikian pusheen merupakan array yang memiliki elemen bertipe integer namun dengan banyak elemen yang belum didefinisikan. Untuk melakukan alokasi terhadap array pusheen, kita dapat menggunakan perintah malloc atau calloc dalam bahasa C. Untuk mengubah ukuran array dinamis yang telah dialokasikan, kita dapat menggunakan perintah realloc. Untuk melakukan dealokasi array dinamis, kita dapat menggunakan perintah free. Perhatikan bahwa pada beberapa kasus, perintah realloc dapat menyebabkan program tidak efisien contohnya saat array diubah ukurannya menjadi lebih besar dan sistem harus melakukan pemindahan elemen-elemen array ke posisi memory yang baru agar perbesaran ukuran array dapat dilakukan.

Array juga dapat memiliki elemenarrayberupa array. Dengan demikian, kita dapat mendefinisikan array n-dimensi. Contohnya, sebuah matriks merupakan array dengan dua dimensi. Array tersebut memiliki elemen arrayberupa array, contohnya int pusheen[][5] atau int pusheen[4][5]. Namun, karena memory komputer bersifat linear, komputer akan menyimpan arrayn-dimensi dalam bentuk linear juga. Hal ini menyebabkan kita harus memperhatikan urutan indeks untuk mengakses setiap elemen arrayn-dimensi karena hal ini akan berpengaruh terhadap performance dari program yang kita buat terlebih data array yang diolah cukup besar, contohnya seberapa baikkah program yang kita buat dalam memanfaatkan cache memory (cache-friendly).

Pointer

Pointer merupakan variabel yang menyimpan alamat memory. Dengan kata lain, pointer memiliki nilai alamat memory untuk melakukan referensi terhadap suatu objek yang tersimpan dalam memory komputer. Dengan menggunakan pointer, kita dapat memiliki akses terhadap memory secara langsung.Untuk setiap tipe data T, terdapat pointer ke T. Deklarasi pointer dalam bahasa C dapat dilakukan dengan mudah, contohnya int *ptr yang merupakan pointer yang melakukan referensi terhadap objek bertipe integer.

Pointer juga dapat digunakan untuk menunjukkan structure berdasarkan alamatnya di memory. Hal ini sangat berguna untuk melakukan passing structure ke atau dari sebuah fungsi hanya dengan memberikan alamat structure tersebut di memory. Pointer ini juga dapat di-dereferensi seperti halnya pointerlain dalam bahasa C, yaitu menggunakan operator dereference (*). Selain itu, juga terdapat operator yang sangat berguna yaitu struct_name -> member untuk melakukan dereferensi pointer-to-struct lalu mengakses nilai dari anggota structure tersebut. Operator tersebut memiliki ekuivalensi dengan (*struct_name).member. Sebetulnya, sebuah fungsi dapat langsung mengembalikan sebuah structure walaupun hal ini terkadang tidak efisien saat dijalankan.

Dalam array, indeks biasanya didefinisikan sebagai perhitungan matematika terhadap alamat pointer. Dengan demikian penulisan array[i] memiliki ekuivalensi dengan *(array + i). Perhitungan matematika terhadap pointer untuk mengakses setiap elemen array dapat dilakukan karena array memiliki elemen yang tersusun secara kontigu (berurutan tanpa jeda).

III. HASIL DAN ANALISIS A. Tugas I : Fungsi XOR

Pada tugas pertama ini, diminta untuk membuat sebuah fungsi yang berperilaku sama seperti operator bitwise XOR (^). Operator yang boleh digunakan dalam realisasi program hanya lah operator bitwise AND (&) dan operator bitwise NOT(~). Berikut true table untuk fungsi XOR :

A B A^B

0 0 0

0 1 1

1 0 1

1 1 0

Kemudian dibuat program dengan algoritma sebagai berikut : x XOR y = ~((~(~x&y))&(~(x&~y))) True table dari fungsi diatas yaitu :

x y C = ~x&y D = x&~y E = ~C&~D ~E 0 0 0 0 1 0 0 1 1 0 0 1 1 0 0 1 0 1 1 1 0 0 1 0

Terlihat bahwa true table dari formula yang digunakan memberikan hasil yang sama dengan true table pada fungsi XOR. Sehingga dapat dipastikan bahwa formula tersebut benar. Kemudian dilakukan implementasi kedalam program dan berikut hasil kompilasi yang telah dilakukan :

B. Tugas 2 : Fungsi Ekstraksi Byte

Pada tugas 2 ini, dibuat sebuah fungsi yang dapat melakukan ekstraksi byte ke-n dari suatu data X yang memiliki ukuran tertentu. Urutan byte pada data V diberi nomor 0 untuk LSB hingga 2 untuk MSB. Apabila dilakukan perintah

:: getByte(0x12345678,1);

maka hasil ekstraksi byte yang diperoleh haruslah 0x56. Kemudian dibuat program seperti pada Lampiran dan dijalankan sehingga eksekusi program sebagai berikut :

(5)

Pada program yang telah dibuat terlihat bahwa proses ekstraksi dilakukan dengan memanfaatkan operator bitwise pada setiap bit. Operator bit shift akan menggeser sejauh n byte sehingga byte yang akan diambil berada pada posisi LSB. Kemudian dilakukab manipulasi dengan operasi AND (&) 0x FF sehingga byte-byte selain yang berada pada LSB akan menjadi 0 dan ekstraksi file pun berhasil dilakukan.

C. Tugas 3 : Fungsi Masking Byte

Pada tugas 3, dibuat sebuah program yang dapat melakukan suatu mask dengan aturan seluruh bit mulai dari batas atas hingga batas bawah diset menjadi 1 sedangkan bit lainnya di set menjadi 0. Apabila dilakukan perintah

:: printf("0x%x\n",bitMask(5,3));

Hasil yang diperoleh haruslah 0x38. Dibuatlah sebuah program yang dapat melakukan fungsi masking tersebut. Dengan menggunakan code program seperti yang terdapat pada lampiran, maka hasil eksekusi program adalah sebagai berikut

:

Operator fungsi pada program diatas pertama-tama membuat suatu bit bernilai 1, kemudian melakukan shift kiri sebanyak 31 kali, lalu melakukan shift kanan sebanyak selisih antara batas atas dan batas bawah (aritmatic right shift). Dan terakhir yaitu melakukan right shift sebanyak 31-batas atas pada byte (logic right shift).

D. Tugas 4: Fungsi Membalik Ukuran Byte

Pada tugas 4 ini dibuat sebuah program yang dapat membalik ukuran byte dari suatu data X dengan menukar byte ke-0 dengan byte ke-3 dan byte ke-2 dengan byte ke-1. Urutan byte pada data berurutan mulai dari byte ke-0 pada LSB dan byte ke-3 pada MSB. Apabila dilakukan perintah

:: reverseByte(0x10203040);

Hasil yang diperoleh haruslah 0x04030201. Kemudian dibuatlah fungsi pada program yang dapat melakukan perintah tersebut. Berikut hasil eksekusi program :

Cara kerja fungsi yang digunakan pada program diatas yaitu pertama-tama dilakukan pemisahan setiap byte dengan melakukan operasi AND antara bilangan dengan 0xFF. Kemudian dilakukan penukaran posisi byte ke 3 di shift menjadi byte ke 0 dan sebaliknya, serta penukaran posisi byte ke-2 menjadi byte ke 1 dan sebaliknya. Setelah dilakukan pernukaran/pembalikan tersebut selanjutnya dilakukan return nilai hasil penjumlahan keempat byte tersebut.

E. Tugas 5: Fungsi Pengurangan Byte

Pada tugas 5 ini , dibuat sebuah program yang memuat fungsi untuk menghitung hasil pengurangan antara byte data pertama dikurangi dengan byte kedua. System bilangan negative yang digunakan yaitu system two’s complement. Operator bitwise yang boleh digunakan yaitu hanya operator penjumlahan (+)

dan invers (~). Apabila dilakukan perintah :: minBytes (0x15, 0x07);

Hasil yang diperoleh haruslah 0x0e. Kemudian dibuatlah sebuah program yang dapat melakukan fungsi pengurangan tersebut, berikut hasil eksekusi program :

Berdasarka source kode yang digunakan seperti tertera pada lampiran, algoritma pengurangan yang digunakan yaitu pertama dilakukan shift kiri lalu shift kanan pada bilangan pertama dan kedua. Lalu bilagagn kedua (y) diubah menjadi “– y” dengan operasi “~y+1”. Selanjutnya dilakukan operasi pengurangan bilangan pertama dengan bilangan kedua dengan operator penjumlahan. Terakhir yaitu dilakukan operator AND anrara hasi pengurangan dengan 0xFF.

F. Tugas 6 : Fungsi Shift Register

Pada tugas 6 ini dibuat fungsi yang dapat merepresentasikan sebuah shift register pada rangkaian system digital. Diasumsikan bahwa jumlah bit sebanyak 32 dan seitap nilai yang dimasukan kedalam shift register secara bergantian adalah 5 bit. Shift register awal bernilai 0x00000000. Kemudian apabila diberi input 0x04, maka shift register menjadi 0x00000004. Lalu diberi input lagi 0x13, maka shift register menjadi 0x00000013. Dibuat program untuk merealisasikan fungsi shift register sebagai berikut ;

Pada fungsi shift register diatas, jelas terlihat bahwa fungsi tersebut menggeser nilai awal sebanyak 5 bit ke kiri kemudian selanjutnya melakukan operasi OR terhadap input nilai yang diberikan. Contoh proses shift register diatas : nilai awal 0, kemudian diberi input 0x04 (0…0100) sehingga nilai global_var menjadi 0…0100 seperti terlihat pada hasil kompilasi baris kedua. Apabila diberi input lagi senilai 0x13, maka nilai global_var akan dishift sebanyak 5 bit kekiri (0…010000000) kemudain di “OR” kan dengan nilai input (0…00010011) sehinnga akan mengahsilkan nilai hexadecimal yaitu 0x000000093.

G. Tugas 7 : Program Enkripsi Sederhana

Pada tugas 7 ini dibuat sebuah program yang dapat melakukan proses enkripsi sederhana. Program ini berfungsi untuk menyamarkan 9 digit angka yang dimasukan dari keyboard user. Enkripsi dilakukan dengan menggunakan operasi XOR untuk setiap 8 bit dari 32 bit input dengan sebuah angka decimal 8 bit. Lalu dibuat pula program dekripsinya. Misal diberikan bilangan input decimal 123456789 (dalam biner 00000111 01011011 11001101 00010101) dan bilangan decimal untuk

(6)

input enkripsi sebesar 85. Maka hasil bilangan output setelah melalui proses enkripsi adalah 1376688192.

Simulasinya sebagai berikut :

Input decimal Input enkripsi Hasil enkripsi

123456789 85 1376688192

00000111 01010101 01010010

01011011 00001110

11001101 10011000

00010101 01000000

Maka dibuatlah program yang dapat melakukan fungsi enkripsi tersebut, berikut eksekusi programnya :

Cara kerja program tersebut yaitu fungsi enkripsi dilakukan byte per-byte. Untuk byte pertama yaitu hasil dari variable angka yang di XOR dengan variable decimal kemudian dilakukan operasi AND dengan 0xFF dan diperoleh lah hasil untuk byte pertama. Untuk byte kedua, terlebih dahulu dilakukan shift right sebanyak 8 byte kemudian di XOR dengan variable decimal dan selanjutnya di lakukan shift left sebanyak 8 byte. Terakhir yaitu dilakukan operasi AND dengan 0xFF. Sedangkan untuk byte ketiga dan keempat, operasinya yang dilakukan sama dengan yang dilakukan pada byte kedua namun dilakukan shift sebanyak 16 byte pada byte ke-tiga dan 24 byte untuk byte ke-empat. Setelah diperoleh nilai untuk setiap byte hasil, kemudian dilakukan return dari hasil pernjumlahan byte tersebut. Algoritma yang sama diterapkan pula pada proses dekripsi. Berikut hasil eksekusinya :

H. Tugas 8 : Pointer dalam Assembly

Pada tuga 8, dicopy source code yang ada pada modul lalu dilakukan kompilasi program tersebut kemudian diamati file assembly yang dihasilkan .Dibandingkan penggunaan memory dengan menggunakan pointer melalui file assembly tersebut. File coba1.s merupakan hasil dari kode dengan tipe interger, sedangkan dile coba2.s merupakan hasil dari kode dengan tipe double. Kedua file terlampir.

Dari awal dapat dilihat bahwa penggunaan memory sudah berbeda. Pada tipe data integer terdapat subl $16, %esp sedangkan pada tipe data double subl $32, %esp. Hal ini disebabkan karena tipe data yang digunakan berbeda. Integer merupakan tipe data 32 bit sehingga deklarasi 4 integer akan memakai 16 byte stack memory. Sedangkan tipe data double merupakan tipe data 64 bit sehingga 4 variable double akan memakai 32 byte stack memory.

I. Tugas 9 : Fungsi Membalik Urutan Array

Pada tugas 9 ini dibuat suatu program yang dapat menerima karakter yang diberikan oleh user, menyimpan karakter-karakter tersebut pada sebuah array of character, lalu menampilkannya di layar dengan susunan terbalik. Jika user memasukan kata HELLO maka akan dicetak menjadi OLLEH. Berikut hasil eksekusi program :

Pada program reverse.c yang dibuat (terlampir) pertama-tama dilakukan looping untuk merima input dari user sebanyak 10 character yang selanjutnya akan disimpan kedalam array mulai dari karakter pertama hingga karakter ke sepuluh. Kemudian karater tersebut ditampilkan dengan urutan terbalik, yaitu dari karakter ke 10 hingga karakter ke 0.

J. Tugas 10 : Matriks Nama

Pada tugas 10, dibuat program yang dapat menerima input yang diberikan berupa nama orang yang dimasukan karakter perkarakter kemudian menyimpannya ke dalam array of nama_orang. Program selanjutnya akan menampilkan isi dari array of array of character pada layar sesuai urutan yang benar. Berikut hasil eksekusi program yang dijalankan :

Pada program tersebut pertama-tama dideklarasikan array of char dua dimensi char nama[5][100];. Kemudian akses untuk pengisisian char dan penulisan char dilakukan seperti menggunakan array pada umumnya, yaitu scanf("%c", & nama[i][j]); untuk read dan printf("%c", nama[i][j]) ; untuk write.

K. Tugas 11 : Matriks Nama dengan Pointer

Pada tugas 11 ini, dibuat program yang menggunakan memory secara lebih optimal dibandingkan dengan sebelumnya (Tugas 10). Karena digunakan array statis, maka panjang array dibuat sebanyak 10 kolom dan maksimal 31 baris. Berikut hasil eksekusi yang dijalankan :

(7)

Pada bagian deklarasi variable digunakan char *nama[10]. Hal ini berarti kita dapa mendeklarasikan sederet array yang berupa pointer to array of char. Optimasi memory yang dilakukan yaitu ketika awal program hanya dialokasikan memory yang cukup menampung maksimum 10 char, kemudian setiap input nama barulah dialokasikan memory untuk menampung nama sebanyak 10 char. Hal ini menyebabkan memory yang dialokasikan bergantung dengan jumlah inputan.

L. Tugas 12 : Perkalian Matriks

Pada tugas 12 ini, dibuat sebuah program yang dapat melakukan perkalian dua buah matriks. Keluaran dari fungsi merupakan matriks hasil perkalian. Deklarasi fungsi yang digunakan yaitu struct Matriks mulMatriks (struct Matriks A, struct Matriks B). Berikut hasil eksekusi program :

Cara kerja program yaitu pertama dilakukan validasi syarat perkalian matriks yang memungkinkan untuk dilakukan operasi perkaluan matriks, yaitu jumlah kolom matriks pertama haruslah sama dengan jumlah baris matriks kedua. Apabila syarat tidak terpenuhi maka user akan diminta memasukan jumlah baris dan kolom kedua matriks sampai syarat perkalian matriks terpenuhi. Kemudian kedua matriks diisi nilainya dengan menggunakan looping. Kemudian dilakukan perkalian matriks dengan memanggil fungsi perkalian (mullMatriks). Pada saat pemanggilan fungsi, hanya dilempar vatiable nama matriks. Hal ini dilakukan karena variable nama matriks sudah menunjukan alamat matriks, bukan nilainya. Sehingga apabila diubah didalam funsgi maka variable local pada main akan ikut berubah.

M. Tugas 13: Penjumlahan Biner dengan Array

Pada tugas 13, dibuat sebuah program yang dapat melakukan simulasi operasi penjumlahan pada level bit dengan

representasi two’s complement menggunakan array. Array yang digunakan terdiri dari 8 bit dan hanya boleh diisi dengan angka 1 dan 0. Contohnya, misalkan penjumlahan antara 7 dan 8. Angka 7 akan dimasukan kedalam array berurutan untuk setiap bit menjadi 00000111 dan angka 8 akan dimasukan ke dalam array berurutan untuk setiap bit menjadi 00001000. Kemudian hasil penjumlahannya adalah 00001111. Hasil pejumlahan ini kemudian diubah menjadi bilangan decimal dengan membaca isi array tersebut. Berikut hasil eksekusi progam :

Kode program terlampir. Proses yang digunakan pada program yaitu pertama-tama dibuat representasi bit dalam array dari input yang diberikan . Hal ini dilakukan dengan memanfaatkan fungsi getBit(x,i) . Kemudian dilakukan simulasi penjumlahan dengan aturan two’s complement. Selanjutnya array berisi bit hasil penjumlahan diubah kembali menjadi bilangan biner dengan menggunakan fungsi int bitDes (int *A). Untuk prose pengurangan, hal yang sama dilakukan seperti pada proses pengurangan namun dengna mengubah bilangan biner kedua menjadi –y (= ~y+1) terlebih dahulu kemudian dijumlahkan dengan bilangan pertama. Analisis pertanyaan :

Representasi tipe data float dan double dalam memory yaitu float merupakan tipe data floating point ukuran 32 bit (4 bytes) sedangkan double merupakan tipe data floating point ukuran 64 bit (8 bytes)

Urutan penulisan structure menentukan ukuran structure karen pada computer 32-bit, work size sebanyak 4 byte yang berarti memory akan diproses per-4-byte.

Perbedaan array dan structure yaitu array merupakan kumpulan lokasi penyimpanan data yang kontinu (berurutan) dengan tipe data yang sama. Sedangakan structure merupakan complex data type yang mendefinisikan daftar variable yang akan ditempatkan dalam blok memory menggunakan satu nama.

Array statis memiliki ukuran yang tidak dapat diubah-ubah sedangkan array dinamik memiliki ukuran yang dapat ditentukan saat program sedang berjalan.

Setiap elemen dalam array dapat diakses menggunakan indeks yang biasanya berupa bilangan bulat scalar atau negative. Dalam Bahasa C, elemn pertama dalam array diberi indeks 0. Representasi array dalam memory dengan deklarasi int nim [8].

Array juga dapat memiliki elemen array berupa array sehingga dapat didefinisikan array n-dimensi. Namun karena memory computer bersifat linier, maka computer akan menyimpan array n-dimensi dalam bentuk linier juga. Hal ini mengakibatkan urutan indeks harus diperhatikan juga untuk mengakses setiap elemen array n-dimensi karena hal ini akan berpengaruh pada performance dari program yang akan dibuat, terutama apabila data array yang diolah cukup besar

(8)

Operasi-operasi yang dapat dilakukan pada operasi level bit (bitwise) dalam Bahasa C antara lain operasi AND (&), inclusive OR ( | ), exclusive OR( ^ ), left shift (<<), right shift (>>), dan NOT (~).

Pada system bilangan two’s complemen, operasi pengurangan dilakukan dengan cara menjumlahkan bilamgan pertama dengan nilai negative dari bilangan kedua. Missal bilangan pertama adalah x, dan bilangan kedua adalah y. maka operasi pengurangan yaitu x + (-y). Dengan –y diperoleh dari ~y+1.

Pointer merupakan variabel yang menyimpan alamat memory. Dengan kata lain, pointer memiliki nilai alamat memory untuk melakukan referensi terhadap suatu objek yang tersimpan dalam memory komputer. Dengan menggunakan pointer, kita dapat memiliki akses terhadap memory secara langsung. Pointer juga dapat digunakan untuk menunjuk structure berdasarkan alamanya di memory. Selain itu pointer juga dapat di-dereferensi seperti halnya pointer lain dalam Bahasa C.

Perkalian matriks yang dipilih yaitu dengan prototype struct Matriks mulMatriks (struct Matriks A, struct Matriks B). Prototype fungsi tersebut dipilih karena matriks hasil perkalian dalam fungsi sesuai dengna dimensi matriks perkalian tersebut (array dinamis). Selain itu, jumlah parameter fungsi tidak banyak karena matriks disimpan dalam suatu struct sehingga penggunaan memori dapat diminimalisasi.

IV. SIMPULAN

 Suatu informasi disimpan dalam memory dengan representasi sesuai dengan tipe datanya. Ukutan tipe data berbeda-beda disebabkan adanya address offset dalam memori sehingga digunakan padding untuk mengisi blok kosong.

 Operator bitwise dapat digunakan untuk pengolahan data secara langsung dalam level bit pada memory. Operasi

bitwise ini relative lebih cepat dibandingkan dengan fungsi bawaan atau fungsi buatan yang bekerja pada high level.

 Pointer digunakan sebagai penunjuk suatu alamat dengan data tertentu. Pointer dapat digunakan sebagai pengubah nilai suatu variable local fungsi dari fungsi lain. Selain itu dapat digunakan pula untuk optimalisasi penggunaan memory (karena mirip dengan array dinamik)

 Array adalah suatu data dengan tipe data tertentu yang tersusun secara berurutan dengan alamat yang berurutan pula. Array berdimensi satu, dua, atau tiga.Untuk array berdimensi dua dalam bentuk table, namun representasinya pada memory tetap sebaris namun bersusun menurut baris dan kolom.

 Structure dapat digunakan untuk membentuk suatu tipe data bentukan agar lebih mudah digunakan dalam program. Selain itu dalam penyusunan variable pada structure, perlu memperhatikan ukuran dari masing-masing variable dan urutan deklarasinya agar diperoleh penggunaan memori yang optimal dengan padding seminimal mungkin.

REFERENSI

[1] Bryant, Randal E. dan David R. O’Hallaron. Computer System: A Programmer’s Perspective.Prentice Hall. USA.2011

[2] Tim Asisten Praktikum.Modul Praktikum EL3111 Arsitektur Sistem Komputer. Laboratorium Sinyal dan Sistem Sekolah Teknik Elektro dan Informasika Institut Teknologi Bandung. Bandung. 2015.

[3] https://prezi.com/ogyjqwjwr8vg/pointer-pada-bahasa-c/, 14 Oktober 2015, 10:10 [4] https://id.wikibooks.org/wiki/Pemrograman_C/Opera si_Bitwise, 14 Oktober 2015, 25 [5] http://gentongkosong.blogspot.co.id/2011/12/violitta-yesmaya-skom-lecturer-17-posts.html, 14 Oktober 2015, 10:18

(9)

Lampiran

1. Tugas 1

a. fungsiXor.c

// Praktikum EL3111 Arsitektur Sistem Komputer // Modul : 2 // Percobaan : 1 // Tanggal : 13 Oktober 2015 // Kelompok : 30 // Rombongan : C

// Nama (NIM) 1 : Rosana Dewi Amelinda (13213060)

// Nama (NIM) 2 : Audinata Ibrahim Sitaba (13213061)

// Nama File : fungsiXor.c

// Deskripsi : sebuah fungsi yang memiliki perilaku yang sama dengan operator XOR

#include<stdio.h>

int fungsiXor (int x, int y); int fungsiXor (int x, int y) {

int result;

result = ~((~(~x&y))&(~(x&~y)));

return result;

}

a. fungsiXor.h

// Nama File : fungsiXor.h

// Deskripsi : header fungsi XOR

#ifndef FUNGSIXOR #define FUNGSIXOR

int fungsiXor (int x, int y);

#endif

b. main.c

// Praktikum EL3111 Arsitektur

Sistem Komputer // Modul : 2 // Percobaan : 1 // Tanggal : 13 Oktober 2015 // Kelompok : 30 // Rombongan : C

// Nama File : fungsiXor.h

// Deskripsi : main program fungsi XOR

#include<stdio.h> #include "fungsiXor.h"

int main (void) {

//Deklarasi variabel

int a,b ;

printf("Masukan bilangan integer

pertama : ");

scanf("%d",&a);

printf("Masukan bilangan integer kedua : ");

scanf("%d",&b);

printf("Hasil operasi XOR : %d",fungsiXor(a,b)); return 0; } 2. Tugas 2 a. getByte.c

// Nama File : getByte.c

// Deskripsi : Fungsi yang dapat melakukan ekstraksi byte ke-n dari suatu data X yang memiliki ukuran tertentu. urutan byte pada data X diberi nomor 0 untuk LSB hingga 3 untuk MSB.

#include<stdio.h> #include "getByte.h"

int getByte (int x, int n) {

switch (n) {

case 0 : return ((unsigned) (x &

0x000000FF)) >> 0;

(10)

0x00FF0000)) >> 16;

0xFF000000)) >> 24; }

}

b. getByte.h

// Nama File : getByte.h // Deskripsi : header sebagai

penghubung fungsi (getByte.c) dengan main program (main.c)

#ifndef GETBYTE #define GETBYTE

int getByte(int x,int n);

#endif

c. main.c

// Nama File : main.c

// Deskripsi : main program untuk menjalankan fungsi ekstraksi byte

#include <stdio.h> #include "getByte.h"

int main(void) {

int x; int result; int n;

printf("Masukan data yang akan di

ekstraksi : 0x");

scanf ("%x",&x);

printf("Ekstraksi dilakukan pada

data ke-: ");

scanf("%d",&n);

printf("Hasil ekstraksi data : 0x%x", getByte(x,n)); return 0; } 3. Tugas 3 a. bitMask.c

// Nama File : bitMask.c // Deskripsi : fungsi yang

menghasilkan suatu mask dengan aturan seluruh bit diantara batas atas

(highbit) dan batas bawah (lowbit) diset menjadi 1 sedangkan bit diluar highbit dan lowbit diset menjadi 0. // Asumsi yang digunakan adalah 0<= batas bawah <=31 dan 0<= batas atas <= 31.

#include <stdio.h> #include "bitMask.h"

int bitMask (int highbit, int lowbit) {

int range = highbit-lowbit; //Banyak bit yang akan di mask adalah range+1

unsigned masking; if (range<1)

return 0; // masking dilakukan

untuk seluruh bit

else {

masking = (1<<31)>>range;

//dilakukan pengesetan suatu bilangan dengan bit ke 31-(31-range) bernilai 1

return masking>>(31-highbit);

} }

b. bitMask.h

// Praktikum EL3111 Arsitektur Sistem Komputer

// Modul : 2 // Percobaan : 3

// Tanggal : 13 Oktober 2015 // Kelompok : 30

(11)

// Rombongan : C

// Nama File : bitMask.h // Deskripsi : header sebagai

penghubung fungsi (bitMask.c) dengan main program (main.c)

#ifndef BITMASK #define BITMASK

int bitMask(int highbit,int lowbit);

#endif

c. main.c

// Deskripsi : main program untuk masking bit

#include <stdio.h> #include "bitMask.h"

int main(void) {

int x,y;

printf("Masukan batas atas bit yang

akan dimasking : ");

scanf ("%d",&x);

printf("Masukan batas bawah bit yang

akan dimasking : ");

scanf("%d",&y);

printf("Hasil masking bit : 0x%x", bitMask(x,y)); return 0; } 4. Tugas 4 a. reverseByte.c

// Nama File : reverseBytes.c // Deskripsi : fungsi yang dapat membalik urutan byte dari suatu data X dengan menukar byte ke-0 dengan byte ke-3 dan byte ke-2 dengan byte ke-1. Urutan byte pada data berurutan dari byte ke-0 pada LSB dan byte ke-3 pada MSB.

#include <stdio.h>

#include "reverseBytes.h"

int reverseBytes (int x) {

unsigned Byte3 = (x & 0xFF000000);

//byte ke-3 dari x tetap, byte lainnya diset 0

unsigned Byte2 = (x & 0x00FF0000);

unsigned Byte1 = (x & 0x0000FF00);

unsigned Byte0 = (x & 0x000000FF);

Byte3 = Byte3 >> 24; //Byte3 ini menjadi byte ke-0 atau di shift kanan sebanyak 6 byte

Byte2 = Byte2 >> 8; //Byte2 ini menjadi byte ke-1 atau di shift kanan sebanyak 2 byte

Byte1 = Byte1 << 8; //Byte1 ini menjadi byte ke-2 atau di shift kiri sebanyak 2 byte

Byte0 = Byte0 << 24; //Byte0 ini menjadi byte ke-3 atau di shift kiri sebanyak 6 byte

return (Byte0 + Byte1 + Byte2 +

Byte3); }

b. fungsiXor.h

(12)

// Nama File : reverseBytes.h // Deskripsi : header sebagai penghubung fungsi (reverseBytes.c) dengan main program (main.c)

#ifndef REVERSEBYTES #define REVERSEBYTES

int reverseBytes(int x);

#endif

c. main.c

// Deskripsi : main program untuk melakukan reverse bytes

#include <stdio.h>

#include "reverseBytes.h"

int main(void) {

int x;

printf("Masukan data yang akan di

reverse urutannya : 0x");

scanf ("%x",&x);

printf("Hasil reverse urutan byte :

0x%x", reverseBytes(x));

return 0;

} 5. Tugas 5

a. fungsiXor.c

// Nama File : minBytes.c

// Deskripsi : fungsi yang dapat menghitung hasil pengurangan antara byte data pertama dikurangi dengan byte data kedua.

#include <stdio.h> #include "minBytes.h"

int minBytes(int x, int y) { x = (x<<24)>>24; y = (y<<24)>>24; y = ~y+1; // untuk mengubah y menjadi -y x = x+y; // melakan pengurangan, x = x-y karena y = -y x = x&0x000000FF; return x; } b. fungsiXor.h

// Nama File : minBytes.h // Deskripsi : header sebagai

penghubung fungsi (minBytes.c) dengan main program (main.c)

#ifndef MINBYTES #define MINBYTES

int minBytes(int x, int y);

#endif

c. main.c

(13)

// Deskripsi : main program untuk melakukan pengurangan byte

#include <stdio.h> #include "minBytes.h"

int main(void) {

// Deklarasi variabel

int x,y;

//Meminta masukan input dari user

printf("Masukan bilangan pertama

(hex max 2 angka) : 0x");

scanf ("%x",&x);

printf("Masukan bilangan kedua (hex

max 2 angka) : 0x");

scanf ("%x",&y);

//Menampilkan hasil

printf("Hasil pengurangan : 0x0%x", minBytes(x,y));

} 6. Tugas 6

a. shiftRegister.c

// Nama File : shiftRegister.c // Deskripsi : fungsi yang merepresentasikan sebuah shift register pada rangkaian sistem digital.

// Asumsi yang digunakan yaitu jumlah bit sebanyak 32 bit dan setiap nilai dimasukan ke dalam shift register secara bergantian adalah 5 bit

#include<stdio.h>

#include "shiftRegister.h"

int global_var = 0;

int shiftRegister (int x) {

global_var = (global_var << 5) | x;

return global_var;

}

b. shiftRegister.h

// Praktikum EL3111 Arsitektur Sistem // Praktikum EL3111 Arsitektur Sistem Komputer // Modul : 2 // Percobaan : 6 // Tanggal : 13 Oktober 2015 // Kelompok : 30 // Rombongan : C

// Nama File : minBytes.h // Deskripsi : header sebagai

penghubung fungsi (shiftRegister.c) dengan main program (main.c)

#ifndef SHIFTREGISTER #define SHIFTREGISTER

int shiftRegister(int x);

#endif

c. main.c

// Deskripsi : main program untuk fungsi shift register

#include <stdio.h>

#include "shiftRegister.h"

int main (void) {

int x;

//Meminta masukan input dari user

printf("Masukan input : 0x"); scanf("%x",&x);

//Menampilkan hasil shift register

printf("Hasil shift register yaitu :

0x%.8x", shiftRegister(x));

return 0;

}

(14)

a. enkripsi.c

// Nama File : enkripsi.c

// Deskripsi : fungsi yang melakukan enkripsi sederhana yang berfungsi menyamarkan 9 digit angka yang dimasukan menggunakan keyboard oleh user

#include <stdio.h> #include "enkripsi.h"

int enkripsi (int angka, int desimal) {

int byte_0, byte_1, byte_2, byte_3; byte_0 = (angka^desimal)&0x000000FF; byte_1 = (((angka>>8)^desimal)<<8) &0x0000FF00;

byte_2 = (((angka>>16)^desimal)<<16) &0x00FF0000;

byte_3 = (((angka>>24)^desimal)<<24) &0xFF000000;

return

(byte_0+byte_1+byte_2+byte_3); }

// angka = angka yang akan di enkripsi

// desimal = pengenkripsi (8 bit)

b. main_enkripsi.c

// Nama File : main_enkripsi.c

// Deskripsi : main program enkripsi

#include <stdio.h> #include "enkripsi.h"

int main ()

{

// deklarasi variabel

int desimal, bilangan_pengenkripsi;

//Meminta input masukan dari user

printf("Masukan bilangan desimal

yang akan di enkripsi (9 digit) : ");

scanf("%d", &desimal);

untuk input enkripsi : ");

scanf("%d", &bilangan_pengenkripsi); bilangan_pengenkripsi =

bilangan_pengenkripsi & 0x000000FF;

// untuk memastikan bilangan desimal untuk input enkripsi sebanyak

maksimum 8 bit, jika lebih maka akan dipotong

// Menampilkan hasil proses enkripsi

printf("\n Hasil proses enkripsi :

%d\n",enkripsi(desimal,bilangan_penge

nkripsi));

return 0;

}

c. dekripsi.c

// Nama File : dekripsi.c

// Deskripsi : fungsi yang melakukan dekripsi sederhana

#include <stdio.h> #include "dekripsi.h"

int dekripsi(int angka, int desimal) {

int byte_0, byte_1, byte_2, byte_3; byte_0 = (angka^desimal)&0x000000FF; byte_1 = (((angka>>8)^desimal)<<8) &0x0000FF00;

byte_2 = (((angka>>16)^desimal)<<16) &0x00FF0000;

byte_3 = (((angka>>24)^desimal)<<24) &0xFF000000;

return

(byte_0+byte_1+byte_2+byte_3); }

(15)

d. main_dekripsi.c

// Nama File : main_dekripsi.c

// Deskripsi : main program dekripsi

#include <stdio.h> #include "dekripsi.h"

int main () {

// deklarasi variabel

int desimal, bilangan_pendekripsi;

//Meminta input masukan dari user

yang akan di dekripsi (9 digit) : ");

scanf("%d", &desimal);

untuk input dekripsi : ");

scanf("%d", &bilangan_pendekripsi); bilangan_pendekripsi =

bilangan_pendekripsi & 0x000000FF; // untuk memastikan bilangan desimal untuk input dekripsi sebanyak

maksimum 8 bit, jika lebih maka akan dipotong

// Menampilkan hasil proses dekripsi

printf("\n Hasil proses dekripsi :

%d\n",dekripsi(desimal,bilangan_pende

kripsi)); return 0; } 8. Tugas 8 a. coba.c

// Nama File : coba.c

// Deskripsi : program untuk lebih memahami penggunaan pointer dengan mengamati bahasa Assembly-nya

void coba(int* x, int* y, int* z) { // Kamus int a; int b; int c; int d; /** double a; double b; double c; double d; **/ // Algoritma a = *x; b = *y; c = *z; d = a+b; *y = d; *z = b; *x = c; }

int main (void) {

return(0);

}

b. coba1.s (variable int) .file "coba.c" .text

.globl _coba

.def _coba; .scl 2; .type 32; .endef _coba: LFB0: .cfi_startproc pushl %ebp .cfi_def_cfa_offset 8 .cfi_offset 5, -8 movl %esp, %ebp

.cfi_def_cfa_register 5 subl $16, %esp

movl 8(%ebp), %eax movl (%eax), %eax movl %eax, -4(%ebp) movl 12(%ebp), %eax movl (%eax), %eax movl %eax, -8(%ebp) movl 16(%ebp), %eax movl (%eax), %eax movl %eax, -12(%ebp) movl -8(%ebp), %eax movl -4(%ebp), %edx addl %edx, %eax movl %eax, -16(%ebp)

(16)

movl 12(%ebp), %eax movl -16(%ebp), %edx movl %edx, (%eax) movl 16(%ebp), %eax movl -8(%ebp), %edx movl %edx, (%eax) movl 8(%ebp), %eax movl -12(%ebp), %edx movl %edx, (%eax) leave .cfi_restore 5 .cfi_def_cfa 4, 4 ret .cfi_endproc LFE0:

.def ___main; .scl 2; .type 32; .endef

.globl _main

.def _main; .scl 2; .type 32; .endef _main: LFB1: .cfi_startproc pushl %ebp .cfi_def_cfa_offset 8 .cfi_offset 5, -8 movl %esp, %ebp

.cfi_def_cfa_register 5 andl $-16, %esp call ___main movl $0, %eax leave .cfi_restore 5 .cfi_def_cfa 4, 4 ret .cfi_endproc LFE1:

c. coba2.s (variable double) .file "coba.c" .text

.globl _coba

.def _coba; .scl 2; .type 32; .endef _coba: LFB0: .cfi_startproc pushl %ebp .cfi_def_cfa_offset 8 .cfi_offset 5, -8 movl %esp, %ebp

.cfi_def_cfa_register 5 subl $40, %esp

movl 8(%ebp), %eax movl (%eax), %eax movl %eax, -36(%ebp) fildl -36(%ebp)

fstpl -8(%ebp)

movl 12(%ebp), %eax movl (%eax), %eax movl %eax, -36(%ebp)

fildl -36(%ebp) fstpl -16(%ebp) movl 16(%ebp), %eax movl (%eax), %eax movl %eax, -36(%ebp) fildl -36(%ebp) fstpl -24(%ebp) fldl -8(%ebp) faddl -16(%ebp) fstpl -32(%ebp) fldl -32(%ebp) fnstcw -38(%ebp) movw -38(%ebp), %ax movb $12, %ah

movw %ax, -40(%ebp) fldcw -40(%ebp) fistpl -36(%ebp) fldcw -38(%ebp)

movl -36(%ebp), %edx movl 12(%ebp), %eax movl %edx, (%eax) fldl -16(%ebp) fldcw -40(%ebp) fistpl -36(%ebp) fldcw -38(%ebp)

movl -36(%ebp), %edx movl 16(%ebp), %eax movl %edx, (%eax) fldl -24(%ebp) fldcw -40(%ebp) fistpl -36(%ebp) fldcw -38(%ebp)

movl -36(%ebp), %edx movl 8(%ebp), %eax movl %edx, (%eax) leave .cfi_restore 5 .cfi_def_cfa 4, 4 ret .cfi_endproc LFE0:

.def ___main; .scl 2; .type 32; .endef

.globl _main

.def _main; .scl 2; .type 32; .endef _main: LFB1: .cfi_startproc pushl %ebp .cfi_def_cfa_offset 8 .cfi_offset 5, -8 movl %esp, %ebp

.cfi_def_cfa_register 5 andl $-16, %esp call ___main movl $0, %eax leave .cfi_restore 5 .cfi_def_cfa 4, 4 ret

(17)

.cfi_endproc LFE1:

9. Tugas 9 a. reverse.c

// Nama File : reverse.c

// Deskripsi : Program yang dapat menerima beberapa karakter yang diberikan oleh user, menyimpan karakter-karakter tersebut pada sebuah array of character, lalu menampilkannnya dengan susunan yang terbalik # include <stdio.h> int main () { //Deklarasi variabel char teks[100]; int i, length;

//Meminta masukan panjang kata pada user

printf("Masukkan panjang kata \n"); scanf("%d",&length);

//Meminta masukan kata pada user

printf("Masukkan input kata \n");

//Menyimpan setiap karakter yang

diberikan kedalam array

for (i=0;i<(length+1);i++) {

scanf("%c",&teks[i]); }

//Menampilkan hasil karakter yang telah dibalik urutannya

printf("Karakter yang sudah dibalik

urutannya : \n"); for (i=(length);i>-1;i--) { printf("%c",teks[i]); } return(0); } 10. Tugas 10 a. Arraynama.c

// Nama File : Arraynama.c

// Deskripsi : program yang dapat menerima input yang diberikan berupa nama orang yang dimasukan karakter perkarakter kemudian menyimpan data orang tersebut dalam array of

nama_orang. Progam ini dapat

menampilkan isi dari array of array of character pada layar sesuai dengan urutan yang benar

#include <stdio.h>

int main (void) {

char nama[5][100]; int x,y,i,j;

char inp,junk,out;

//Algoritma

printf("Meminta masukan 2 nama

dalam karakter \n");

//Meminta masukan nama pertama

printf("Masukan panjang nama 1 = \n");

scanf("%d",&x);

printf("Masukan nama pertama = \n"); scanf("%c", & junk);

//Menyimpan setiap karakter nama

pertama kedalam array

for (i=0;i<x;i++) {

scanf("%c", & nama[0][i]); scanf("%c", & junk);

}

//Meminta masukan nama kedua

printf("panjang nama 2 = \n"); scanf("%d",&y);

printf("Masukan nama kedua = \n"); scanf("%c", & junk);

//Menyimpan setiap karakter nama

(18)

for (i=0;i<y;i++) {

scanf("%c", & nama[1][i]); scanf("%c", & junk);

}

//Menampilkan output kedua nama

//Menampilkan nama pertama

printf("Output nama \n"); for (i=0;i<x;i++) { out = nama[0][i]; printf("%c",out); } printf("\n");

//Menampilkan nama kedua

for (i=0;i<y;i++) { out = nama[1][i]; printf("%c",out); } return(0); } 11. Tugas 11 a. pointer_nama.c

// Nama File : poiter_nama.c

// Deskripsi : Program array of nama seperti pada Tugas 10 namun terdapat modifikasi pada struktur data. Pada tugas ini direalisasikan array of array of character diganti dengan array of pointer to array of array of character. #include<stdio.h> #define MAX 10 #define SIZE 31 int main () { //Deklarasi variabel

char *nama[MAX],input[MAX][SIZE]; int n,x,y;

//Meminta masukan nama dari user sebanyak maksimal 10 enter

printf("Masukkan nama kata per kata

(maksimal 10 enter) : \n"); for(n=0;n<MAX;n++) { gets(input[n]); nama[n]=input[n]; if(!strcmp(nama[n],"exit")) {

break; // Program akan berhenti membaca input saat masukan sudah

mencapai 10 kata/

} }

printf("\n=======Output========\n");

// Menampilkan output nama

for(x=0;x<n;x++) { printf("%s ",nama[x] ); } return (0); } 12. Tugas 12 a. mulMatriks.c

// Nama File : mulMatriks.c // Deskripsi : fungsi yang dapat melakukan perkalian dua buah matriks

#include <stdio.h> #include <stdlib.h> #include "mulMatriks.h"

//membuat tipe bentukan Matriks

struct Matriks { int jumlahBaris; int jumlahKolom; int** nilai; };

//Fungsi perkalian matriks

struct Matriks mulMatriks (struct Matriks A, struct Matriks B)

{

(19)

int i,j,k,l; struct Matriks x; x.jumlahKolom = B.jumlahKolom; x.jumlahBaris = A.jumlahBaris; x.nilai = (int**)

calloc(x.jumlahBaris,sizeof(int*)); for (i=0;i<x.jumlahBaris;i++) {

x.nilai[i] = (int*)

calloc(x.jumlahKolom, sizeof(int)); } for (k=0;k<A.jumlahKolom;k++) { for (i=0;i<A.jumlahBaris;i++) { l = A.nilai[i][k]; for (j=0;j<x.jumlahKolom;j++) { x.nilai[i][j] += l*B.nilai[k][j]; } } } return x; } b. mulMatriks.h

// Nama File : mulMatriks.h

// Deskripsi : header yang berperan untuk menghubungkan fungsi

(mulMatriks.c) dengan main program

#ifndef MULMATRIKS #define MULMATRIKS

extern struct Matriks mulMatriks (struct Matriks A, struct Matriks B);

#endif

c. main.c

// Deskripsi : main program untuk perkalian Matriks #include <stdio.h> #include <stdlib.h> #include "mulMatriks.h" struct Matriks { int jumlahBaris; int jumlahKolom; int** nilai; };

int main (void) {

struct Matriks A,B,C; int i, j;

//Meminta masukan matriks pertama

printf("Masukan jumlah Baris Matriks A : ");

scanf("%d", &A.jumlahBaris);

printf("Masukan jumlah Kolom Matriks A : ");

scanf("%d", &A.jumlahKolom); A.nilai =

malloc(A.jumlahBaris*sizeof(int*));

//Pengisian matriks A

for(i=0;i<=A.jumlahBaris;i++) {

A.nilai[i] =

malloc(A.jumlahKolom*sizeof(int)); }

for(i=0;i<=A.jumlahBaris-1;i++) {

for (j=0;j<=A.jumlahKolom-1;j++) {

printf("Masukan elemen ke %d,%d :",i+1,j+1);

scanf("%d",&A.nilai[i][j]); }

}

//Meminta masukan matriks kedua

printf("Masukan jumlah Baris Matriks B: ");

scanf("%d", &B.jumlahBaris);

printf("Masukan jumlah Kolom Matriks B : ");

scanf("%d", &B.jumlahKolom);

//Pengisian matriks B

for(i=0;i<=B.jumlahBaris;i++) {