[02]_[13211059]

MODUL 2: REPRESENTASI DAN MANIPULASI LEVEL BIT

Praktikan: Aji Suryo Wibowo (13211059)  Asisten: Ria Ratna Sari (13210064) Waktu Percobaan: Senin, 4 November 2013 EL3111 – Praktikum Arsitektur Sistem Komputer Sekolah Teknik Elektro dan Informatika  – ITB

 Abstrak Pada praktikum kali ini, dilakukan percobaan untuk melihat representasi dan melakukan manipulasi suatu program pada level bit. Percobaan pertama adalah membuat fungsi bitXor(x, y) yang dilanjutkan dengan percobaan kedua yaitu membuat fungsi oddBits(void) dan evenBits(void). Percobaan selanjutnya adalah membuat fungsi getByte(x, n), kemudian percobaan berikutnya ialah membuat fungsi bitMask(highbit, lowbit). Percobaan kelima dan seterusnya adalah membuat fungsi reverseBytes(x); fungsi tmax(void); fungsi minBytes(x, y); fungsi shiftRegister(x); fungsi enkripsi; dan fungsi dekripsi. Kata kunci: representasi, manipulasi, bit, fungsi.

1. Data Praktikum 1.1 Fungsi 1

Pada fungsi ini, dibuat program bernama fungsi1.c sebagai program fungsi dan program main_fungsi1.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi1.exe. Input program berupa integer x dan y: x = 4 dan y = 5. Output program (integer): bitXor(x, y) = 1.

Gambar 2.1 Screenshot fungsi1.exe 1.2 Fungsi 2

Pada fungsi ini, dibuat program bernama fungsi2.c sebagai program fungsi dan program main_fungsi2.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi2.exe. Input program tidak ada. Output program (integer dalam representasi hex):

oddBits(void) = 0xaaaaaaaa; evenBits(void) = 0x55555555.

Gambar 2.2 Screenshot fungsi2.exe 1.3 Fungsi 3

Pada fungsi ini, dibuat program bernama fungsi3.c sebagai program fungsi dan program main_fungsi3.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi3.exe. Input program berupa integer x (dalam representasi hex) dan integer n (dalam (dal am rentang 0; 1; 2; 3): x = 0x12345678 dan n = 1. Output program (integer dalam representasi hex): getByte(x, n) = 0x56.

Gambar 2.3 Screenshot fungsi3.exe 1.4 Fungsi 4

Pada fungsi ini, dibuat program bernama fungsi4.c sebagai program fungsi dan program main_fungsi4.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi4.exe. Input program berupa integer highbit (dalam rentang 0 sampai dengan 31) dan integer lowbit (dalam rentang 0 sampai dengan 31): highbit = 5 dan lowbit = 3. Output program (integer dalam representasi hex): bitMask(highbit, lowbit) = 0x38.

minBytes(x, y) = 0x0E.

Gambar 2.4 Screenshot fungsi4.exe Dapat dilihat bahwa jika lowbit > highbit maka akan muncul nilai 0x0 karena semua bit di-0-kan. 1.5 Fungsi 5

Pada fungsi ini, dibuat program bernama fungsi5.c sebagai program fungsi dan program main_fungsi5.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi5.exe. Input program berupa integer x (dalam representasi hex): x = 0x01020304. Output program (integer dalam representasi hex): reverseBytes(x) = 0x4030201.

Gambar 2.7 Screenshot fungsi7.exe 1.8 Fungsi 8

Pada fungsi ini, dibuat program bernama fungsi8.c sebagai program fungsi dan program main_fungsi8.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi8.exe. Input program berupa integer x (dalam representasi hex), register awal diset 0x00000000, dan input sebelumnya akan mempengaruhi, serta setiap nilai masukan adalah 5 bit: x (pertama) = 0x04; x (kedua) = 0x13; x (ketiga) = 0x14. Output program (integer dalam representasi hex): shiftRegister(x) (pertama) = 0x00000004; shiftRegister(x) (kedua) = 0x00000093; shiftRegister(x) (ketiga) = 0x00001274.

Gambar 2.5 Screenshot fungsi5.exe 1.6 Fungsi 6

Pada fungsi ini, dibuat program bernama fungsi6.c sebagai program fungsi dan program main_fungsi6.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi6.exe. Input program tidak ada. Output program (integer): tmax(void) = 2147483647.

Gambar 2.6 Screenshot fungsi6.exe 1.7 Fungsi 7

Pada fungsi ini, dibuat program bernama fungsi7.c sebagai program fungsi dan program main_fungsi7.c sebagai main program. Program fungsi dan program main dikompilasi dengan perintah dari compiler GCC sehingga diperoleh fungsi7.exe. Input program berupa integer x (dalam representasi hex) dan integer y (dalam representasi hex) dengan asumsi 2 hex maksimal: x = 0x15 dan y = 0x07. Output program (integer dalam representasi hex):

Gambar 2.8 Screenshot fungsi8.exe 1.9 Fungsi Enkripsi

Pada fungsi ini, dibuat program bernama enkripsi.c sebagai program fungsi dan program main_enkripsi.c sebagai main program, selain itu dibuat pula program makefile untuk melakukan kompilasi melalui fitur mingw32-make pada compiler GCC. Program dikompilasi melalui fitur mingw32-make sehingga menghasilkan enkripsi.exe. Input program berupa integer angka dan integer desimal: angka = 123456789 dan desimal = 85.

Output program (integer): enkripsi(angka, desimal) = 1376688192.

Untuk kasus fungsi oddBits, jika integer 32 bit diset 1 untuk bit ganjil dan 0 untuk bit lainnya, maka akan terbentuk: 1010 1010 1010 1010 1010 1010 1010 1010 2 = 0xaaaaaaaa. Sementara untuk kasus fungsi evenBits, jika int eger 32 bit diset 1 untuk bit genap dan 0 untuk bit lainnya, maka akan terbentuk: 0101 0101 0101 0101 0101 0101 0101 0101 2 = 0x55555555.

Gambar 2.9 Screenshot enkripsi.exe 1.10 Fungsi Dekripsi

Pada fungsi ini, dibuat program bernama dekripsi.c sebagai program fungsi dan program main_dekripsi.c sebagai main program, selain itu dibuat pula program makefile untuk melakukan kompilasi melalui fitur mingw32-make pada compiler GCC. Program dikompilasi melalui fitur mingw32-make sehingga menghasilkan dekripsi.exe. Input program berupa integer angka dan integer desimal: angka = 1376688192 dan desimal = 85. Output program (integer): dekripsi(angka, desimal) = 123456789.

2.3

Spesifikasi dari program adalah mengekstrak byte n dari word data x. Urutan byte dalam word diberi nomor dari 0 (LSB) hingga 3 (MSB). Skrip diset supaya mengambil byte yang dikehendaki sesuai dengan input n. Saat n bernilai 0 yang berarti mengambil LSB maka input x akan di-and-kan dengan 0x000000FF yang akan menghasilkan LSB (nilai yang di-and-kan dengan 0 akan mengembalikan nilai 0). Setelah di-and-kan, nilai keluaran akan dijadikan unsigned integer. Peng-unsigned-an ini ditujukan supaya shift yang dilakukan berupa shift logikal. Hal yang sama berlaku saat input n bernilai 1. Saat input n bernilai 1, maka input x akan di-and-kan dengan 0x0000FF00 yang akan menghasilkan nilai byte pertama dan LSB yang bernilai 0. Setelah itu dilakukan shift logikal (setelah dilakukan operasi unsigned) untuk menghilangkan LSB yang bernilai 0. Untuk pengambilan byte kedua dan MSB pun dapat dijelaskan dengan penjelasan yang sama. Untuk mempermudah penjelasan, akan diberikan contoh, input x diset 0x12345678. Representasi dalam bentuk biner adalah 0001 0010 0011 0100 0101 0110 0111 1000. Saat input n adalah 0, maka input x akan di-and-kan dengan 0x000000FF yang dapat direpresentasikan dengan 0000 0000 0000 0000 0000 0000 1111 1111, ini akan menghasilkan 0000 0000 0000 0000 0000 0000 0111 1000 kemudian hasil ini di-shift logikal sebanyak 0 sehingga tetap menghasilkan nilai di atas yang direpresentasikan dalam hex berupa 0x78 yang merupakan LSB (byte kenol) dari x. Satu contoh lagi saat input n bernilai 3 atau ingin mengambil MSB dari input x, maka representasi x dalam biner akan di-and-kan dengan 0xFF000000 (dalam biner 1111 1111 0000 0000 0000 0000 0000 0000) sehingga hasil and-nya dalam biner adalah 0001 0010 0000 0000 0000 0000 0000 0000 (dalam hex adalah 0x12000000). Hasil ini akan diunsigned-kan kemudian di-shift kanan (logikal) sebanyak 24 bit, sehingga menjadi 0000 0000 0000 0000 0000 0000 0001 0010 atau dalam hex menjadi 0x12.

Gambar 2.10 Screenshot dekripsi.exe 2.  Analisis 2.1

Percobaan 1

Dari spesifikasi yang diminta oleh program yang hanya memperbolehkan penggunaan operator ~ (not) dan operator & (and) pada program, maka fungsi xor dapat dibuat dengan persamaan, x^y = (x|y) & (~x|~y) maupun x^y = (x&~y) | (~x&y). Dengan menggunakan hukum de‟ Morgan, kedua representasi x^y tersebut dapat ditulis ulang kembali menjadi x^y = (~(x&y)) & (~(~x&~y)) dan x^y = ~((~(x& ~y)) & (~(~x &y))). Dari kedua hasil yang mengembalikan nilai yang sama tersebut, dipilih hasil yang pertama karena perepresentasian dan penulisan yang lebih mudah. Dapat dilihat jika representasi 4 10  dalam biner adalah 01002  sementara 5 10  adalah 01012, jika 410^510  maka akan menghasilkan biner 0001 2  atau dalam desimal bernilai 110. 2.2

Percobaan 3

Percobaan 2

Spesifikasi yang diminta oleh program hanya menampilkan nilai dalam representasi hex dari seluruh nilai bit pada integer 32 bit jika diset 1 untuk bit bernilai ganjil dan 0 untuk bit lainnya (pada oddBits); dan jika diset 1 untuk bit bernilai genap dan 0 untuk bit lainnya (pada evenBits). 2.4

Percobaan 4

Spesifikasi program adalah melakukan pengesetan bit antara highbit dan lowbit diset menjadi 1 dan bit sisanya diset 0 sementara jika lowbit bernilai lebih besar dari highbit maka semua nilai bit diset 0. Asumsi, input highbit dan lowbit tidak melebihi 31 dan tidak kurang dari 0. Proses pe-masking-an akan dijelaskan sebagai berikut. Pertama di-assign sebuah variabel bertipe integer bernama jarak yang menampung selisih nilai highbit dan lowbit. Variabel jarak ini berguna untuk mempersiapkan banyaknya bit yang akan dimasking (sebanyak jarak+1). Kemudian disiapkan pula variabel masking bertipe unsigned agar shift kanan yang nanti dilakukan bertipe logikal. Kemudian pada body program, digunakan persyaratan, saat nilai lowbit lebih besar dari nilai highbit maka akan dikembalikan nilai 0, kemudian saat nilai highbit lebih besar dari lowbit maka program akan mengeshift kiri sebanyak 31 bit nilai 1. Kemudian nilai 1 yang telah dishift kiri tersebut dishift kanan sebanyak jarak. Shift kanan yang dilakukan ini bersifat aritmatik karena operasi masih berjalan pada nilai integer, sehingga akan diperoleh nilai 1 sebanyak jarak+1 bit. Nilai hasil shift ini kemudian ditampung pada variabel masking. Karena variabel masking bertipe unsigned, maka shift kanan yang dilakukan pada masking merupakan shift logikal. Program akan mengembalikan masking yang dishift logikal kanan sejauh 31-highbit. Untuk mempermudah akan diberikan penjelasan berupa contoh. Input highbit dan lowbit berturutturut adalah 5 dan 3, maka variabel jarak akan menampung nilai 2. Proses dilanjutkan dengan pengecekan, karena highbit lebih besar dari lowbit maka program akan melakukan pengeshiftan ke kiri nilai 1 sebanyak 31 bit yang menghasilkan 1000 0000 0000 0000 0000 0000 0000 0000. Kemudian, dilakukan shift kanan aritmetik sebanyak jarak yaitu 2 bit menjadi 1110 0000 0000 0000 0000 0000 0000 0000. Sekarang nilai yang keluar tersebut ditampung dalam variabel masking yang bertipe unsigned yang kemudian dishift logikal kanan sejauh (31-highbit) yaitu 26 bit sehingga menjadi, 0000 0000 0000 0000 0000 0000 0011 1000 yang bernilai 0x38 dalam representasi hexnya. 2.5

Percobaan 5

Spesifikasi yang diminta program adalah mengembalikan input word dalam urutan byte yang terbalik (LSB menjadi MSB, byte pertama menjadi byte kedua, byte kedua menjadi byte pertama, MSB menjadi LSB). Prinsip dari program ini hampir sama dengan program pada percobaan 3. Proses pertama yang dilakukan adalah mengambil komponen byte dari LSB sampai MSB. Pengambilan dilakukan dengan

meng-and-kan dengan kombinasi hex 0 dan F. Untuk mengambil komponen MSB (byte ketiga), digunakan variabel Byte3 yang bertipe unsigned kemudian diisi dengan hasil peng-and-an input x dengan 0xFF000000. Kemudian untuk mengambil byte kedua, digunakan variabel Byte2 bertipe unsigned dan diisi dengan hasil peng-and-an x dengan 0x00FF0000. Untuk mengambil byte pertama, digunakan variabel Byte1 bertipe unsigned yang diisi dengan hasil input x di-and-kan dengan 0x0000FF00. Terakhir, untuk mengambil byte kenol (LSB) digunakan variabel Byte0 bertipe unsigned yang diisi dengan hasil input x yang diand-kan dengan 0x000000FF. Pmberian nilai unsigned pada setiap variabel yang digunakan bertujuan untuk menjadikan shift yang digunakan menjadi logikal. Setelah itu, hasil pengambilan byte tadi akan diposisikan pada hasil yang akan dikeluarkan. Byte3 akan diset menjadi LSB output, proses ini menggunakan shift kanan sebanyak 24 bit. Byte 2 akan diset menjadi byte pertama output dengan melakukan shift kanan sebanyak 8 bit. Byte1 akan diset menjadi byte kedua output dengan melakukan shift kiri sebanyak 8 bit. Terakhit Byte0 akan dijadikan MSB output dengan melakukan shift kiri sebanyak 24 bit. Hasil masing-masing shift akan dijumlahkan sehingga keluar output dengan urutan tiap byte-nya terbalik. Untuk mempermudah penjelasan akan diberikan contoh. Input x dimasukkan nilai 0x01020304 sehingga dalam representasi binernya adalah 0000 0001 0000 0010 0000 0011 0000 0100. Akan diambil MSB dari input, sehingga input x di-andkan dengan 0xFF000000 (dalam biner 1111 1111 0000 0000 0000 0000 0000 0000) sehingga akan menghasilkan MSBnya yaitu 0x01000000. Hal yang sama dilakukan untuk mengambil byte yang dikehendaki (dari byte kedua sampai byte kenol atau LSB) sehingga berturut-turut akan menghasilkan 0x020000; 0x0300; 0x04. Setelah diperoleh nilai dari tiap byte yang disimpan dalam  variabel Byte3, Byte2, Byte1, dan Byte0 yang bertipe unsigned maka dilakukan penge-shiftan untuk memposisikan byte yang diambil ke posisinya agar sesuai dengan output yang dikehendaki. Byte3 akan dijadikan LSB output dengan melakukan shift kanan logikal sebanyak 24 bit sehingga diperoleh 0x01. Byte2 akan dijadikan byte pertama output dengan menge-shift sebanyak 8 bit sehingga diperoleh 0x0200. Byte1 akan dijadikan byte kedua output dengan melakukan shift kiri sebanyak 8 bit sehingga diperoleh 0x030000. Terakhir, Byte0 akan dijadikan MSB output dengan melakukan shift kiri sejauh 24 bit sehingga diperoleh 0x04000000. Keseluruhan hasil

yang diperoleh ini kemudian dijumlahkan sehingga diperoleh 0x04030201 yang menjadi output program. 2.6

Percobaan 6

Spesifikasi program hanya meminta output berupa nilai terbesar yang mungkin dihasilkan dalam mode two‟s complement untuk integer 32 bit tanpa meminta input apapun (void). Fungsi mengembalikan nilai dalam representasi hex, akan tetapi main program mengembalikannya dalam format integer. Nilai maksimal two‟s complement yang diperoleh untuk integer 32 bit adalah 0111 1111 1111 1111 1111 1111 1111 1111 atau dalam format hex menjadi 0x7FFFFFFF. 2.7

Percobaan 7

Spesifikasi program mensyaratkan untuk menggunakan representasi two‟s complement. Selain itu program yang dibuat dilarang menggunakan operasi  –   hanya diperolehkan menggunakan operasi + dan ~. Pembatasan input x maupun y agar tetap bernilai 1 byte dilakukan pada main program. Sementara itu, dungsi yang dibuat pertama kali akan memastikan bahwa input yang dimasukkan jika bernilai negatif maka akan tetap bernilai negatif. Karena masukan yang akan diolah dibatasi hanya 1 byte sementara integer yang digunakan adalah integer 4 byte maka dengan melakukan shift kiri sebanyak 24 bit kemudian dilakukan shift kanan aritmatik sebanyak 24 bit akan dijamin input tetap bernilai negatif dalam representasi 4 byte (dengan pembatasan input 1 byte). Kemudian, setelah dipastikan input negatif tetap bernilai negatif, dilakukan peng-assign-an nilai y sehingga menjadi  –y dengan persamaan two‟s complement bahwa  – y = ~y + 1. Setelah itu, dilakukan peng-assign-an nilai x dengan nilai x  –  y sehingga output program akan mengembalikan nilai x. 2.8

Percobaan 8

Spesifikasi program akan memasukkan data berdasarkan fungsi shift pada sistem digital. Jumlah bit diasumsikan 32 bit dan setiap nilai yang dimasukkan adalah 5 bit. Nilai awal register adalah 0x00000000 dan input sebelumnya berpengaruh pada nilai sekarang. Program akan mengeser nilai variabel reg yang bertipe integer yang merupakan register program dengan nilai 0x00000000. Variabel reg di sini merupakan variabel global agar saat pemanggilan fungsi shiftRegister maka input sebelumnya akan berpengaruh pada nilai sekarang. Pada body program, sebelumnya akan dilakukan shift kiri sebanyak 5 bit sesuai spesifikasi kepada  variabel reg. Kemudian variabel reg yang sudah

dishift kiri tersebut di-or-kan dengan input x dan hasilnya disimpan pada variabel reg. Output akan mengembalikan nilai reg. 2.9

Percobaan Enkripsi

Spesifikasi dari program adalah melakukan penyamaran 9 digit angka dengan melakukan operasi xor dengan setiap 8 bit dari 32 bit dengan sebuah angka desimal 8 bit. Pada program ini dibuat program makefile untuk melakukan kompilasi dan pembentukan file executable. Pertama, yang dilakukan oleh program adalah membuat empat variabel bertipe integer yaitu Byte3, Byte2, Byte1, Byte0. Variabel tersebut digunakan untuk memecah input angka menjadi masing-masing 8 bit yang kemudian diproses sesuai dengan byte yang berkorelasi. Byte0 akan menampung nilai hasil peng-xor-an input angka dengan desimal yang kemudian di-and-kan dengan 0x000000FF yang menghasilkan LSB output. Sementara untuk byte lainnya, haruslah dilakukan shift kanan terlebih dahulu sebanyak bit yang berkorelasi agar byte yang bersangkutan dapat menjadi LSB. Peng-LSB-an byte ini bertujuan untuk menyetarakan kedudukan angka dengan desimal, karena desimal pada dasarnya adalah selalu “LSB”  karena hanya bernilai 8 bit. Setelah dilakukan xor dengan desimal, maka posisi byte tadi harus dikembalikan ke letaknya semula dengan melakukan shift kiri sebanyak shift kanan yang dilakukan, baru setelah itu dilakukan peng-and-an dengan nilai yang sesuai untuk pengambilan byte tertentu (0x0000FF00 untuk byte pertama/Byte1, 0x00FF0000 untuk byte kedua/Byte2, dan 0xFF000000 untuk byte ketiga/MSB/Byte3). Untuk lebih jelasnya akan diberikan contoh. Digunakan input 123456789 dalam representasi desimal sehingga dalam representasi binernya adalah 00000111 01011011 11001101 00010101. Sementara, input desimal adalah 85 yang direpresentasikan dalam biner 01010101. Langkah pertama adalah menampung hasil xor LSB dengan input desimal yang menghasilkan 00000111 01011011 11001101 01000000. Kemudian hanya diambil nilai LSBnya yang akan ditampung pada  variabel Byte0 dengan meng-and-kan dengan 0xFF yang representasi binernya 00000000 00000000 00000000 11111111 sehingga akan diperoleh bit 01000000 yang merupakan LSB output (0x40 dalam hex). Kemudian untuk variabel Byte1, input angka akan digeser sejauh 8 bit ke kanan kemudian di-xor dengan desimal sehingga akan menghasilkan nilai 00000000 00000111 01011011 10010110. Setelah diperoleh nilai tersebut, posisi integer dikembalikan dengan melakukan shift kiri sejauh 8 bit juga sehingga akan diperoleh hasil 00000111 01011011 10010110 00000000, kemudian hasil

tersebut di-and-kan dengan 0xFF00 (dalam biner 00000000 00000000 11111111 00000000) yang akan menghasilkan 10011000 00000000 (0x9800 dalam hex). Dengan cara yang hampir sama, untuk Byte2 dan Byte3 berturut-turut diperoleh 00001110 00000000 00000000 (0x0E0000 dalam hex) dan 01010010 00000000 00000000 00000000 (0x52000000 dalam hex). Program akan mengembalikan jumlah dari keseluruhan variabel sehingga diperoleh 0x520E9840 dalam representasi hex atau dalam bentuk desimal 1376688192. Nilai desimal yang dikeluarkan pada screenshot dikarenakan oleh pada main program, output direpresentasikan dalam bentuk desimal (%d). 2.10 Percobaan Dekripsi

3.

Spesifikasi dari program adalah melakukan pembalikan penyamaran 9 digit angka atau dengan kata lain program untuk mengembalikan nilai output program enkripsi (sebagai input program dekripsi) sehingga output program dekripsi yang diperoleh sama dengan input dari program enkripsi. Pada program ini juga digunakan makefile untuk melakukan kompilasi dan pembentukan file executable. Penjelasan untuk program ini bisa dikatakan sama dengan penjelasan pada program enkripsi karena dalam representasi biner, jika a xor b sama dengan c, maka c xor b akan sama dengan a. Hal ini sama saja dengan input angka di-xor (dienkripsi) dengan input desimal menghasilkan output terenkripsi, maka output terenkripsi (sebagai input program dekripsi) di-xor (didekripsi) dengan input desimal akan menghasilkan input angka (sebagai output program dekripsi). Kesimpulan a) Kesimpulan percobaan 1 Fungsi bitXor merupakan fungsi yang melakukan manipulasi pada level bit akan tetapi hasil yang dikeluarkan direpresentasikan dalam bentuk desimal, hal ini ditunjukkan oleh penggunaan operasi and dan not pada program. b) Kesimpulan percobaan 2 Pada program kedua, integer dapat ditampilkan dalam format desimal maupun heksadesimal, akan tetapi operasi yang dilakukan tetap pada level bit (binary). c) Kesimpulan percobaan 3 Pada program ketiga, meskipun input dan output menggunakan representasi heksadesimal, perhitungan yang dilakukan oleh komputer tetaplah menggunakan perhitungan pada level bit yang ditunjukkan oleh penggunaan operasi shift dan and. d) Kesimpulan percobaan 4

4.

Pada program keempat ini, meskipun program menerima input integer desimal dan menghasilkan output integer heksadesimal, manipulasi yang dilakukan komputer tetaplah pada level bit yang ditunjukkan oleh penggunaan operasi shift. e) Kesimpulan percobaan 5 Pada program kelima, meskipun input program adalah integer heksadesimal dan outputnya pun integer heksadesimal, manipulasi yang dilakukan mesin tetaplah manipulasi pada level bit yang ditunjukkan dengan penggunaan operasi shift dan and. f) Kesimpulan percobaan 6 Pada program keenam ini, nilai yang direpresentasikan fungsi adalah heksadesimal, sementara nilai yang ditampilkan main program adalah desimal, meskipun begitu, representasi yang ada di mesin tetap pada level bit. g) Kesimpulan percobaan 7 Pada program ketujuh ini, meskipun input merupakan heksadesimal begitupun dengan outputnya, tetap saja manipulasi yang dilakukan oleh mesin merupakan manipulasi pada level bit yang ditunjukkan oleh pengunaan operasi and, not, dan shift. h) Kesimpulan percobaan 8 Pada program kedelapan ini, meskipun input adalah integer heksadesimal begitupun dengan outputnya, tetap manipulasi yang dilakukan mesin berada pada level bit. Hal ini ditunjukkan oleh penggunaan operasi shift dan or pada program. i) Kesimpulan percobaan enkripsi Pada program enkrispi ini, jelas program meminta input dalam bentuk integer desimal, outputnya pun bertipe integer desimal, namun dapat dilihat jika perhitungan yang dilakukan mesin berada pada level bit. Hal ini ditunjukkan dengan penggunaan operasi shift, xor, dan and. j) Kesimpulan percobaan dekripsi Pada program enkrispi ini, jelas program meminta input dalam bentuk integer desimal, outputnya pun bertipe integer desimal, namun dapat dilihat jika perhitungan yang dilakukan mesin berada pada level bit. Hal ini ditunjukkan dengan penggunaan operasi shift, xor, dan and. Daftar Pustaka [1] Haryono, Andri dkk.  Modul Praktikum EL3110  –  Arsitektur Komputer –  I . Teknik Elektro ITB, 2013. [2] Bryant, Randal E. dan David R. O‟Hallaron. Computer Systems: A Programmer’s Perspective, 2 nd   Edition.Prentice Hall, 2011.

LAMPIRAN MODUL 2: REPRESENTASI DAN MANIPULASI LEVEL BIT

Praktikan: Fiqih Tri Fathulah Rusfa (13211060)  Asisten: Ria Ratna Sari (13210064) Waktu Percobaan: 4 November 2013 EL3111 – Arsitektur Sistem Komputer Sekolah Teknik Elektro dan Informatika  – ITB

 Abstrak Pada praktikum Representasi dan Manipulasi Level Bit ini dilakukan pembuatan 10 buah fungsi beserta mainnya dan dilakukan kompilasi pada setiap fungsi. Fungsi yang dibuat merupakan fungsi yang memanfaatkan representasi dan manipulasi informasi pada level bit. Secara umum representasi informasi pada level bit pada praktikum ini digunakan representasi dalam bentuk desimal dan heksa desimal, dari tipe yang digunakan berupa signed (two‟s comlement) dan unsigned integer. Masing-masing fungsi dapat menggunakan manipulasi berupa operasi bit, operasi logika, shift logika dan shift secara aritmatik. Secara umum, dapat dibuat semua fungsi dengan menggunakan representasi dan manipulasi level bit dan didapat hasil uji coba program yang sesuai dengan yang diharapkan. Kata kunci: representasi, manipulasi, bit, logika

1. Data Praktikum 1.1 Fungsi 1   : bitXor(x,y)

fungsi1.c Dihasilkan file dan file main_fungsi1.c. Dengan mengetikkan $ gcc –O2 –o fungsi1 fungsi1.c main_fungsi1.c Pada command line didapat hasil program fungsi1.exe Ketika fungsi1.exe dijalankan dengan Data masukan dari keyboard ialah x = 4 dan y = 5 didapat keluaran bitXor(x,y)= 1 berikut hasil print screen -nya

Gambar 2-1 Print Screen  Keluaran Command Prompt untuk fungsi1

1.2 Fungsi 2 : oddBits(void) & evenBits(void)

Dihasilkan file dan file fungsi2.c main_fungsi2.c. Dengan mengetikkan $ gcc –O2 –o fungsi2 fungsi2.c main_fungsi2.c Pada command line didapat hasil program fungsi2.exe Ketika fungsi2.exe dijalankan dengan  Tidak ada masukan dari keyboard didapat keluaran 1 word oddBits dalam Hex = 0xaaaaaaaa 1 word evenBits dalam Hex = 0x55555555 berikut hasil print screen -nya

Gambar 2-2 Print Screen  Keluaran Command Prompt untuk fungsi2

1.3 Fungsi 3 : getByte(x,n)

fungsi3.c Dihasilkan file dan file main_fungsi3.c. Dengan mengetikkan $ gcc –O2 –o fungsi3 fungsi3.c main_fungsi3.c Pada command line didapat hasil program fungsi3.exe Ketika fungsi3.exe dijalankan dengan Data masukan dari keyboard ialah x = 0x12345678  dan n = 1 didapat keluaran getByte(x,n)= 0x56 berikut hasil print screen -nya

Gambar 2-3 Print Screen  Keluaran Command Prompt untuk fungsi3

: bitMask(highbit,lowbit) 1.4 Fungsi 4  

Dihasilkan file dan file fungsi4.c main_fungsi4.c. Dengan mengetikkan $ gcc –O2 –o fungsi4 fungsi4.c main_fungsi4.c Pada command line didapat hasil program fungsi4.exe Ketika fungsi4.exe dijalankan dengan Data masukan dari keyboard ialah highbit = 5 dan lowbit = 3 didapat keluaran bitMask(highbit,lowbit)= 0x38 berikut hasil print screen -nya

Ketika fungsi6.exe dijalankan dengan  Tidak ada data masukan dari keyboard . Keluaran : tmax()= 2147483647 berikut hasil print screen -nya

Gambar 2-6 Print Screen  Keluaran Command Prompt untuk fungsi6

1.7 Fungsi 7   : minBytes(x,y)

Dihasilkan file dan file fungsi7.c main_fungsi7.c. Dengan mengetikkan $ gcc –O2 –o fungsi7 fungsi7.c main_fungsi7.c Pada command line didapat hasil program fungsi7.exe Ketika fungsi7.exe dijalankan dengan Data masukan dari keyboard : x = 0x15 dan y = 0x07 Keluaran : minBytes(x,y)= 0xe berikut hasil print screen -nya

Gambar 2-4 Print Screen  Keluaran Command Prompt untuk fungsi4

1.5 Fungsi 5 : reverseBytes(x)

Dihasilkan file dan file fungsi5.c main_fungsi5.c. Dengan mengetikkan $ gcc –O2 –o fungsi5 fungsi5.c main_fungsi5.c Pada command line didapat hasil program fungsi5.exe Ketika fungsi5.exe dijalankan dengan Data masukan dari keyboard ialah x = 0x01020304 didapat keluaran reverseBytes(x)= 0x4030201 berikut hasil print screen -nya

Gambar 2-5 Print Screen  Keluaran Command Prompt untuk fungsi5 1.6 Fungsi 6 : tmax(void)

Dihasilkan file dan file fungsi6.c main_fungsi6.c. Dengan mengetikkan $ gcc –O2 –o fungsi6 fungsi6.c main_fungsi6.c Pada command line didapat hasil program fungsi6.exe

Gambar 2-7 Print Screen  Keluaran Command Prompt untuk fungsi7

1.8 Fungsi 8 : shiftRegister(x)

as Dihasilkan file fungsi8.c dan file main_fungsi8.c. Dengan mengetikkan $ gcc –O2 –o fungsi8 fungsi8.c main_fungsi8.c Pada command line didapat hasil program fungsi8.exe Ketika fungsi8.exe dijalankan dengan Data masukan dari keyboard : X1 = 0x4 X2 = 0x13 X3 = 0x14 Keluaran : ShiftRegister(x1)= 0x4 ShiftRegister(x2)= 0x93 ShiftRegister(x3)= 0x1274 berikut hasil print screen -nya

Gambar 2-10 Print Screen  Keluaran Command Prompt untuk dekripsi

2.  Analisis 2.1 Fungsi 1   : bitXor(x,y)

kita tahu berdasarkan tabel kebenaran ada dua bentuk lain dari x^y Gambar 2-8 Print Screen  Keluaran Command Prompt untuk fungsi7

1.9 Tugas a) Fungsi enkripsi

enkripsi.c, Dihasilkan file main_enkripsi.c, makefile Dengan mengetikkan $ mingw32-make Pada command line didapat hasil program enkripsi.exe, file  enkripsi.o, dan main_enkripsi.o Ketika enkripsi.exe dijalankan dengan Data masukan dari keyboard : angka = 123456789 dan  desimal = 85 Keluaran : enkripsi(angka,desimal)= 1376688192 berikut hasil print screen -nya

Gambar 2-9 Print Screen  Keluaran Command Prompt untuk enkripsi

b)

Fungsi dekripsi

dekripsi.c, Dihasilkan file main_dekripsi.c, makefile Dengan mengetikkan $ mingw32-make Pada command line didapat hasil program dekripsi.exe, file  dekripsi.o, dan main_dekripsi.o Ketika dekripsi.exe dijalankan dengan Data masukan dari keyboard : angka = 1376688192 dan  desimal = 85 Keluaran : dekripsi(angka,desimal)= 123456789 berikut hasil print screen -nya

1. x^y = (x|y)&(~x | ~y) dengan menggunakan prinsip demorgan pada (x|y) dan (~x | ~y), maka (x|y) = ~(~x & ~y) (~x | ~y) = ~(x&y) x^y = (~(x&y)) & (~(~x & ~y)) 2. x^y = (x& ~y) | (~x &y) dengan menggunakan prinsip demorgan didapat x^y = ~((~(x& ~y)) & (~(~x &y))) Hasil manipulasi 1 lebih sederhana dibandingkan 2 maka dipilih fungsi yang pertama. Berdasarkan data percobaan diperoleh hasil fungsi ini sesuai dengan fungsi xor yang diinginkan. 2.2 Fungsi 2 : oddBits(void) & evenBits(void)

Pada program ini tidak ada input tapi memiliki output output yakni integer 32 bit dengan bit ke 0(LSB) dan bit ke 31(MSB) Untuk oddbit akan dihasilkan bilangan integer 32 bit dengan bit ganjil diset 1 sehingga, hasilnya = 1010 1010 1010 1010 1010 1010 1010 1010 = 0xAAAAAAAA. Untuk evenbit akan dihasilkan bilangan integer 32 bit dengan bit genap diset 1 sehingga, hasilnya = 0101 0101 0101 0101 0101 0101 0101 0101 = 0x55555555. Diperoleh data percobaan sesuai dengan yang diinginkan. 2.3 Fungsi 3 : getByte(x,n)

Program ini inputnya merupakan word data x : integer 32 bit dan integer n yang menunjukkan byte ke berapa yang akan diambil, masukan n ialah 0,1,2,3, untuk pengecekan masukan dilakukan pada program main. Pada program main jika input n bukan 0, 1, 2, atau 3 maka program akan meminta user mengulang masukan n sampai n = 0,1,2, atau 3. Hal ini terlihat pada hasil  print screen  gambar 2-3. Dan program ini memiliki output integer 1 byte ke n dari masukan x.

Pada fungsi3.c terlihat untuk bisa menghasilkan output yang diinginkan pertama dilakukan pemisahan byte yang akan diambil dengan mengeset byte lainnya menjadi 0 (dilakukan dengan operasi bit 'and'), kemudian dilakukan shift kanan logikal sehingga didapat byte yang ingin diambil menjadi byte LSB. Dilakukan shif logikal agar didapat byte yang tetap sama ketika dishift ke kanan (byte didepannya dijaga tetap 0). Untuk dapat melakukan shift logikal ini maka dilakukan casting nilai menjadi unsigned sebelum dilakukan shifting ke kanan. Input x dan output program ini dalam heksa didapatkan dengan menggunakan %x, sehingga integer direpresentasikan dalam heksa. Output data percobaan gambar 2-3 sesuai dengan yang diharapkan. : bitMask(highbit,lowbit) 2.4 Fungsi 4  

Program ini memiliki input integer highbit dan lowbit dengan asumsi nilainya diantara 0-31 (dengan asumsi ini maka tidak perlu dilakukan pengecekan masukan nilai untuk highbit maupun lowbit). Output dari program ini ialah bilangan integer 32 bit dengan ketentuan untuk bit ke lowbit sampai bit ke highbit akan di set menjadi 1 dan jika ternyata highbit lowbit pertama dihitung banyaknya bit yang akan diset 1 = highbit-lowbit+1, setelah itu dibuat bilangan yang mempunyai (highbit-lowbit+1) bit yang bernilai 1 dengan cara menshift 1 kekiri sebanyak 31 sehingga 1 sekarang menjadi MSB. Kemudian bilangan ini di shift kanan sebanyak (highbit-lowbit), karena 1 adalah bialngan integer (two‟s complement) maka hasinya adalah bilangan dengan bit ke 31 sampai (31(highbit-lowbit)) bernilai 1 sesuai dengan operasi shif kanan secara aritmatik. Terakhir dilakukan shift kanan secara logik, agar jumlah bit yang bernilai 1 tetap sebanyak 31-highbit (bit didepannya 0) sehingga sekarang didapat bit ke highbit sampai lowbit bernilai 1. Karena tadi untuk shift kanan sebanyak 31-highbit akan dilakukan secara logik maka pada programpun digunakan tipe unsigned pada variabel masking (variabel yang akan dilakukan shiftkanan sebanyak 31-highbit tadi). 2.5 Fungsi 5 : reverseBytes(x)

Pada program ini inputnya adalah integer x 32 bit= 4 byte (0(LSB) s.d. 3 (MSB)) dan outputnya integer 32 bit dengan urutan byte x direverse dengan ketentuan byte 3 menjadi byte 0, byte 2 menjadi byte 1. Untuk mendapatkan output yang demikian pada file fungsi5.c dilakukan, pertama setiap byte dari x dipisahkan dari byte lainnya dengan cara mengeset

byte lainnya dengan 0 (dilakukan dengan operasi bit 'and') kemudian dilakukan pertukaran byte dengan cara melakukan shifting kekiri atau kekanannsesuai dengan pertukaran byte yang diinginkan. Dan terakhir setiap byte pun disatukan dengan cara dijumlahkan. Digunakan tipe unsigned untuk pemisahan byte dikarenakan akan dilakukan shift secara kanan agar dalam pengshiftan tetap didapatkan hanya 8 bit saja yang bernilai maka haruslah dilakukan shift kanan secara logikal. Input dan output ditampilkan dalam bentuk hex dengan cara menggunakan %x sehingga representasi datanya dalam bentuk heksadesimal. Output yang didapat pada gambar 2-5 sesuai dengan yang diinginkan. 2.6 Fungsi 6 : tmax(void)

Pada program ini tidak ada input. Output program ini ialah mengahsilkan nilai two's complement integer terbesar Caranya terlihat pada file fungsi6.c  karena kita tahu integer itu 32 bit maka nilai two's complement terbesar adalah bilangan positif 32 terbesar yakni : 011111111 11111111 1111111 1111111  Jika dalam hex = 0x7F FF FF FF. Output program ini direpresentasikan dalam desimal sehingga digunakan %d pada representasi hasil output fungsi ini. 2.7 Fungsi 7   : minBytes(x,y)

Program ini memiliki input integer x dan y 1 byte. Untuk memastikan input 1 byte dilakukan pembatasan input pada program main nya x = x & 0x000000FF; y = y & 0x000000FF; Byte ke 3, 2, 1 diset 0 jika lebih dari 2 byte maka akan diambil byte LSB saja. Ini terbukti dari hasil pada gambar 2-7 jika input x=0x115  maka akan terbaca sebagai x=0x15 . Output program ini ialah integer x-y sejumlah 1 byte namun hanya diperbolehkan menggunakan operasi + dan ~.  Agar didapat output yang sesuai maka pada fungsi1.c dilakukan kmanipulasi y menjadi -y dengan cara operasi bit karena tidak boleh menggunakan operasi - . Kita tahu untuk two's complement : -y = ~y + 1 Dengan sifat itu kitapun dapat menghasilkan operasi x-y  Agar didapat hasil yang cuma 8 bit maka pada syntax terakhr hasilnya harus di 'and' dengan 0x000000FF Penggeseran 24 pada input x dan y dimaksudkan untuk memastikan masukan 1 byte negatif tetap terbaca negatif untuk 4 byte karena masukkan kita bilngan 1 byte sedangkan integer itu 4 byte maka haruslah bilangan 1 byte tsb digeser ke kiri sebanyak

24 dan kemudian dikembalikan lagi menjadi byte LSB dengan menggeser ke kanan sebanyak 24. Ini bertujuan jika MSB untuk 8 bitnya 1 (negatif) maka untuk 32 bit pun juga harus 1 (tetap negatif) Pada gambar 2-7 terlihat dihasilkan output yang sesuai dengan yang diinginkan. 2.8 Fungsi 8

Pada program ini inputnya meruapakan bilangan 5 bit, bilangan ini kemudian akan dishiftkan ke nilai reg pada fungsi shiftregister. Karena nilai reg sekarang bergantung pada nilai reg sebelumnya maka pertama dilakukan shift kekiri sebanyak 5 selanjutnya baru dilakukan operasi bit „atau‟ dari reg tadi dengan input 5 bit. Sehingga sekarang didapat input 5 bit menjadi 5 bit LSB dari nilai r eg yang telah dishift kiri 5. Pada fungsi8.c variabel reg dibuat sebagai varable global agar ketika fungsi shiftregister dipanggil nilai variabel reg pun juga akan ikut berubah, ini penting karena pada pemanggilan fungsi shiftregister akan dilakukan pengulangan pemanggilan sesuai keinginan user dan input reg sebelumnya akan berpengaruh pada nilai hasil shiftregister sekarang.  Agar dapat dilakukan shiftregister secara berulang maka digunakan loop do while dengan meinta user memasukkan char lanjut jika dimasukkan char „y‟ atau „Y‟ maka akan dilakukan shifregister lagi. Jika dimasukkan char lanjut = „n‟ atau „N‟  maka program akan dihentikan. Jika dimasukkan input char lanjut selain yang di atas maka program akan meminta user memasukkan ulang input char lanjut. Pada gambar 2-8 terlihat dihasilkan hasil yang sesuai dengan yang diinginkan. 2.9 Tugas a) Fungsi enkripsi

Program ini memiliki input berupa angka (yang mau dienkripsi(9 digit/ 32 bit)) dan desimal ( pengenkripsi 8 bit). Output dari program ini ialah hasil xor setiap byte angka dengan desimal dan dikembalikan dalam bentuk bilangan integer 32 bit.  Agar didapat output yang demikian maka pertama angka yang akan dienkripsi dipecah menjadi 4 byte dan untuk setiap byte komponen byte lainnya di set 0. Kemudian setiap byte tadi akan di xor dengan desimal (8 bit). Untuk byte 0 dapat langsung di xor sedangkan untuk byte 1,2,3 harus dishift kanan menjadi byte LSB baru dixor, hal ini dikarenakan desimal merupakan 8 bit yakni byte LSB dari integer 4 byte. Karena tadi digeser maka agar posisi byte kembali ke posisi semula maka dishift kiri sebanyak shift kanan tadidan

terakhir setiap byte tadi digabungkan kembali menjadi bilangan 4 byte. Pada gambar 2-9 terlihat dihasilkan output yang sesuai dengan yang diharapkan. b)

Fungsi dekripsi

Program ini memiliki input angka (yang mau didekripsikan (9 digit/ 32 bit)) dan desimal (pendekripsi (8 bit)). Desimal ini juga menjadi pengenkripsi yang membuat hasil enkripsi seperti angka yang mau didekripsikan. Hasil dekripsi ini nantinya akan dibandingkan dengan hasil enkripsi tadi. Output dari program ini ialah hasil xor setiap byte angka dengan desimal dan dikembalikan dalam bentuk bilangan integer 32 bit. Ini sesuai dengan metode pengenkripsi : yangdienkripsi ^ pengenkripsi = hasilenkripsi Sekarang kita akan mengubah hasilenkripsi menjadi yang dienkripsi berdasarkan tabel kebenaran didapat yangdienkripsi = hasilenkripsi ^ pengenkripsi atau sama saja dengan : hasildekripsi = yangdidekripsi ^ pendekripsi. Oleh karena itu digunakan metode yang sama dengan enkripsi tadi.  Terlihat hasil pada gambar 2-10 dengan masukan angka = hasil enkripsi fungsi enkripsi dan desimal dekripsi yang sama dengan desimal pengenkripsinya didapat hasil dekripsi yang sesuai dengan angka yang dienkripsikan. Ini menunjukkan program yang dibuat sesuai dengan yang diinginkan.

3. Kesimpulan a) Kita dapat membuat fungsi dengan menggunakan representasi dan manipulasi informasi pada level bit. Fungsi tsb seperti bitXor, oddBits, evenBits, getByte, bitMask, reverseBytes, tmax, minBytes, shiftRegister, enkripsi, dan dekripsi. b) Representasi informasi pada level bit dapat berupa desimal menggunakan %d, atau berupa heksadesimal menggunakn %x. Selain itu, tipe bilangan bit yang dapat digunakan antara lain unsigned dan signed (two‟s complement). Tipe integer merupakan bilangan 32 bit. c) Manipulasi informasi pada level bit dapat menggunakan operasi bit, operasi logika, shift aritmatik dan shift logika. d) Operasi bit berupa „and‟  „&‟, „atau‟  „|‟, „inverse‟  „~‟, „tambah‟ „+‟,‟ kurang‟  „-„, „xor‟  „^‟. Operasi bit ini akan menghitung operasi untuk setiap bit dari argumen, sehingga hasilnya merupakan argumen dengan setiap bitnya merupakan hasil operasi. Operasi xor

e)

f)

dapat dibentuk dengan opeasi & dan ~. Operasi kurang dapat dibentuk dengan operasi + dan ~. Operasi logika berupa „and‟  „&&‟, „atau‟  „||‟, „inverse‟  „!‟. Operasi logika ini mengoperasikan argumen sebagai satu kesatuan. Setiap argumen yang bukan 0 merepresentasikan True (1), sementara argumen nol merepresentasikan False (0). Hasil operasi ii akan dikembalikan komputer dalam bentuk 1 untuk True dan 0 untuk false. Operasi ini sangat berguna untuk program yang mengandung kondisional. Shift dapat dilkukan ke kiri atau ke kanan. Shift logik dan aritmatik berbeda pada saat melakukan shift kanan. Untuk shift logik kanan sisi paling kirinya akan diisi nol. Shift ini berlaku untuk tipe argumen unsigned. Shift aritmatik ke kanan akan mengisi sisi paling kirinya sesuai dengan MSB argumen yang akan dishift. Shift ini dilakukan pada tipe argumen signed (two‟s complement).

4. Daftar Pustaka [1] Andri Haryono dkk. Modul Praktikum EL3110 –   Arsitektur Komputer –  I . Teknik Elektro ITB, 2013. [2] Bryant, Randal E. dan David R. O‟Hallaron. Computer Systems: A Programmer’s Perspective, 2 nd   Edition.Prentice Hall, 2011.

LAMPIRAN  A.

Kode fungsi1.c int bitXor(int x, int y) { return (~(x&y) & ~(~x&~y)); }

B.

Kode main_fungsi1.c #include int main() { int x, y; printf ("\n--Fungsi 1--\n"); printf ("\nInput nilai x dan y"); printf ("\nx = "); scanf("%d",&x); printf ("y = "); scanf("%d",&y); printf ("\nx ^ y = %d\n", bitXor(x,y)); return 0; }

C.

Kode fungsi2.c int oddBits(void) { return (0xAAAAAAAA); } int evenBits (void) { return (0x55555555);

D.

Kode main_fungsi2.c #include int main() { printf ("\n--Fungsi 2--\n"); printf ("\n1 word OddBits dalam Hex = 0x%x", oddBits()); printf ("\n1 word EvenBits dalam Hex = 0x%x\n\n", evenBits()); }

E.

F.

Kode fungsi3.c int getByte (int x, switch (n) { case 0 : case 1 : case 2 : case 3 : } } Kode main_fungsi3.c #include

int n) { return return return return

((unsigned) ((unsigned) ((unsigned) ((unsigned)

(x (x (x (x

& & & &

0x000000FF)) 0x0000FF00)) 0x00FF0000)) 0xFF000000))

>> >> >> >>

0; 8; 16; 24;

int main () { int x,n; printf ("\n--Fungsi 3--\n"); printf ("\nInput nilai x(dalam Heksa) dan n"); printf ("\nx (dalam heksa) = 0x"); scanf ("%x", &x); do { printf ("n (0, 1, 2, atau 3) = "); scanf ("%d", &n); } while ((n<0)||(n>3)); printf ("\nByte yang diperoleh = 0x%x\n",getByte(x, n));

return 0; }

G.

H.

I.

J.

Kode fungsi4.c int bitMask (int highbit, int lowbit) { int jarak = highbit-lowbit; //banyaknya bit yang akan dimask = jarak+1 unsigned masking; if (highbit>jarak; //menset suatu bilangan dengan bit ke 31 //sampai bit ke (31-jarak) bernilai 1 return masking>>(31-highbit); } } Kode main_fungsi4.c #include int main() { int x, y; printf ("\n--Fungsi 4--\n"); printf ("\nInput nilai highbit dan lowbit (0 s.d. 31)"); printf ("\nhighbit = "); scanf("%d",&x); printf ("lowbit = "); scanf("%d",&y); printf ("\nhasil bitMask (%d, %d) = 0x%x\n", x, y, bitMask(x,y)); return 0; } Kode fungsi5.c int reverseBytes(int x) { unsigned Byte3=(x&0xFF000000);//byte ke-3 dari x tetap,byte lainnya diset0 unsigned Byte2=(x&0x00FF0000);//byte ke-2 dari x tetap,byte lainnya diset0 unsigned Byte1=(x&0x0000FF00);//byte ke-1 dari x tetap,byte lainnya diset0 unsigned Byte0=(x&0x000000FF);//byte ke-0 dari x tetap,byte lainnya diset0 Byte3 = Byte3 >> 24; //Byte3 ini menjadi byte ke-0 Byte2 = Byte2 >> 8; //Byte2 ini menjadi byte ke-1 Byte1 = Byte1 << 8; //Byte1 ini menjadi byte ke-2 Byte0 = Byte0 << 24; //Byte0 ini menjadi byte ke-3 return (Byte0 + Byte1 + Byte2 + Byte3); } Kode main_fungsi5.c #include int main() { int x; printf ("\n--Fungsi 5--\n"); printf ("\nInput nilai x dalam heksa desimal"); printf ("\nx (heksa) = 0x"); scanf("%x",&x); printf ("\nHasil reverseBytes(0x%x) = 0x%x\n", x, reverseBytes(x)); return 0; }

K.

L.

Kode fungsi6.c int tmax(void) { return 0x7FFFFFFF; } Kode main_fungsi6.c #include

int main printf printf return }

() { ("\n--Fungsi 6---"); ("\ntmax = %d\n",tmax()); 0;

M. Kode fungsi7.c int minBytes (int x, int y) { x = (x<<24)>>24; y = (y<<24)>>24; y = ~y+1; //membuat y = -y x = x+y; //x = x-y karena y = -y x = x&0x000000FF; return x; }

N.

Kode main_fungsi7.c #include int main () { int x, y; //variabel lokal printf ("\n--Fungsi 7--\n"); printf ("\nInput nilai x dan y (1 byte = 2 hex), dipotong"); printf ("\nx (max 2 hex) = 0x"); scanf("%x",&x); printf ("y (max 2 hex) = 0x"); scanf("%x",&y); //memastikan input 1 byte, jika lebih akan dipotong x = x & 0x000000FF; y = y & 0x000000FF; printf ("\nminBytes(0x%x,0x%x) minBytes(x,y)); return 0; }

O.

=

0x%x

-

0x%x

=

jika

0x%x\n",

x,

lebih

y,

Kode fungsi8.c int reg = 0x00000000; int shiftRegister (int x) { reg = ((reg<<5)|x); return reg; }

P.

Kode main_fungsi8.c #include #include int main() { //variabel lokal int x; //menampung masukan 5 bit yang akan menshif register char lanjut; //menampung masukan untuk lanjut atau tidak melakukan shifregister printf ("\n--Fungsi 8--\n"); do {

akan

x,

y,

printf ("\nInput 5 bit, x (Hex 0x00 s.d 0x1F) = 0x"); scanf("%x",&x); while (getchar()!='\n'); //agar "enter" tidak dianggap sebagai //input, ini penting karena akan diminta input sebuah character nantinya printf ("\nHasil ShiftRegister(0x%x) = 0x%x\n", x, shiftRegister(x)); //menanyakan apakah ingin lanjut melakukan shifregister terhadap //register yang telah dishift //dilakukan pengecekan juga apakan input character lanjut == 'y' //atau == 'n' do { printf ("\nApakah ingin melakukan ShiftRegister lagi? [y / n] :"); scanf ("%c",&lanjut); while (getchar()!='\n'); //jika input lanjut tidak sesuai diberikan pemberitahuan //kepada user if (!((lanjut=='y')||(lanjut=='Y')||(lanjut=='n')||(lanjut=='N'))) printf ("input salah!, hanya boleh mengetikkan 'y', 'Y', 'n', atau 'N'"); } while (!((lanjut=='y')||(lanjut=='Y')||(lanjut=='n')||(lanjut=='N'))); //akan terus diulang sampai input sesuai } while ((lanjut=='y')||(lanjut=='Y')); //jika lanjut =='y' atau 'Y' maka //akan kembali meminta input, jika tidak program diselesaikan return 0; }

Q. Kode enkripsi.c int enkripsi (int angka, int desimal) { int Byte0, Byte1, Byte2, Byte3; Byte0 = (angka^desimal)&0x000000FF; Byte1 = (((angka>>8)^desimal)<<8)&0x0000FF00; Byte2 = (((angka>>16)^desimal)<<16)&0x00FF0000; Byte3 = (((angka>>24)^desimal)<<24)&0xFF000000; return (Byte0+Byte1+Byte2+Byte3); } R. Kode main_enkripsi.c #include int main () { int yangdienkripsi, pengenkripsi; printf ("\n--Fungsi Enkripsi--\n"); printf ("\nInput angka yang akan dienkripsi (9 digit) dan desimal (8 bit) pengenkripsi"); printf ("\nAngka yang akan dienkripsi (9 digit) = "); scanf ("%d", &yangdienkripsi); printf ("Desimal pengekripsi (8 bit dari -128 s.d. 127) = "); scanf ("%d", &pengenkripsi); pengenkripsi = pengenkripsi & 0x000000FF; //memastikan pengenkripsi //maksimum 8 bit, jika lebih akan dipotong

printf ("\nHasil pengenkripsi)); return 0; }

S.

T.

U.

Enkripsi

=

%d\n",

enkripsi

(yangdienkripsi,

Kode makefile untuk enkripsi all: enkripsi enkripsi: main_enkripsi.o enkripsi.o gcc main_enkripsi.o enkripsi.o -o enkripsi main_enkripsi.o: main_enkripsi.c gcc -c main_enkripsi.c enkripsi.o: enkripsi.c gcc -c enkripsi.c Kode dekripsi.c int dekripsi (int angka, int desimal) { int Byte0, Byte1, Byte2, Byte3; Byte0 = (angka^desimal)&0x000000FF; Byte1 = (((angka>>8)^desimal)<<8)&0x0000FF00; Byte2 = (((angka>>16)^desimal)<<16)&0x00FF0000; Byte3 = (((angka>>24)^desimal)<<24)&0xFF000000; return (Byte0+Byte1+Byte2+Byte3); } Kode main_dekripsi.c #include int main () { int yangdidekripsi, pendekripsi; printf ("\n--Fungsi Dekripsi--\n"); printf ("\nInput angka yang akan didekripsi (9 digit) dan desimal (8 bit) pendekripsi"); printf ("\nAngka yang akan didekripsi (9 digit) = "); scanf ("%d", &yangdidekripsi); printf ("Desimal pendekripsi (8 bit dari -128 s.d. 127) = "); scanf ("%d", &pendekripsi); pendekripsi = pendekripsi & 0x000000FF; //memastikan pendekripsi maksimum //8 bit, jika lebih akan dipotong printf ("\nHasil pendekripsi)); return 0; }

 V.

Dekripsi

=

%d\n",

Kode makefile untuk dekripsi all: dekripsi dekripsi: main_dekripsi.o dekripsi.o gcc main_dekripsi.o dekripsi.o -o dekripsi main_dekripsi.o: main_dekripsi.c gcc -c main_dekripsi.c dekripsi.o: dekripsi.c gcc -c dekripsi.c

dekripsi

(yangdidekripsi,