EduMIPS64 ואמולטור MIPS מעבדי

Microprocessor without מעין ראשי תיבות של MIPSארכיטקטורת Interlocked Pipeline Stages תקן של מחשבי הוא סוג שלRISC.

התקן פותח בהתחלה באוניברסיטת סטנפורד ואחר כך בחברה מסחרית(MIPS Technologies מעבד יכול להיקרא מעבד .)MIPSבאישור

החברה בתנאי שיעמוד בתקן ויקבל אישר לכך מהחברה. המעבד נמצא . מערכות משובצות הן בעקרון מערכותמערכות משובצותבשימוש ב

שהמעבד הוא רק אחד המכשירים במערכת, כמו בציוד רפואי אוראוטורים )מחשבי ביניים( של מערכות תקשורת.

ביט64 ביט. התקן הורחב ל-32 הראשונים היו מעבדים MIPSמעבדי ה- יותר מאוחר.

יתרונות: 2 יש MIPSל- X86בהשוואה ל-

– הוא חלק מגישה מודרנית לארכיטקטורה שלRISCהוא מעבד -.CISC הוא בגישה המיושנת של X86מעבדים בעוד שה-

, משום שאין לו מחויבות לתאימות אחורהX86הוא פשוט יותר מה-- למעבדים מיושנים ואינו יוצא מתוך הנחה שהוא מעבד של מערכת

הפעלה כללית. התקן משאיר מספר נושאים פתוח.

הנפיצות היחסית של המעבד הזה במסגרת מערכות משובצות היא הוא קל יותר למימוש מערכת פרטנית יחסית למשלMIPSשמעבד

במסגרת של מעבד חלש יחסית כמו בטלפון נייד.

יצרה מחשבי תחנת עבודהSilicon Graphics( חברת 2006בעבר )עד .MIPSושרתים עם מעבד

משמשת בהרבה קורסים בהוראת מחשבים ממספרMIPSארכיטקטורת סיבות:

הגישה מודרנית למימוש מעבדיםRISC הוא מעבד X86להבדיל מ--חדשים

המבנה שלו פשוט יחסית- . ישנו תוכנת הדמיהX86קל יחסית לדמות אותו על מעבד -

EDUMIPS64.שההתקנה שלו הוא עניין של מה בכך

.MIPS לדמות תכנות ב-EDUMIPS64אנחנו נשתמש במערכת

EDUMIPS64 של ה- MIPS ארכיטקטורת

להלן רשימת האוגרים של המעבד:

מקור:

בנוסף יש למעבד אוגרים מיוחדים.

המשמשים יעדים לפעולות כפל וחילוק.hi,loשניים מהם הם

אוגרים כלליים אבל השימוש שלהם אינו אחיד.32למעבד יש

. 0אוגר האפס משמש כקבוע )שהשימוש בו נפוץ(

חלק מהאוגרים שמורים למטרות מיוחסות:

(.k2 )27(, אוגר k1 )26(, אוגר at )1 אוגר

חלק מהאוגרים יש תפקיד מוגדר:

( משמשים לדיווח תוצאות,v0-v1 )2-3 אוגרים

( משמשים להעברת פרמטריםa0-a3 )4-7 אוגרים

( יש תפקידים מוגדרים.gp, sp, ra )29-31 אוגרים

משמש לשמירה לעל כתובת חזרה בהסתעפות לשגרה ו-raלמשל האוגר sp.כמצביע למחסנית

-s0( כאשר t0-t7, s0-s7, t8-t9 )8-25 האוגרים הכלליים הם איפה אוגרים s7 נועדו לשמש משתני אוגר ואילו t0-t9.אוגרי חישובי טיוטה בלבד

אבל לאfloating point אוגרים למספרים ממשיים 32בנוסף לאלו יש גם נעסוק באלו כרגע.

נראה שרוב האוגרים שיש להם "תפקידים המיוחדים", "שמות מיוחדים" זה )במסגרת הזו לפחות( בחזקת מסורת מאשר נובע מן החומרה )זה

...). אחד שזה כן מתבטא בחומרהbp,sp, למשל x86האחרון כן נכון ב-.ra (r31)הוא $

רשימה של פקודות המכונה החשובות:

(:ALUפקודות אריתמטיות לוגיות )

AND rd,rs,rt ; rd = rs & rt

ADD rd,rs,rt ; rd = rs + rt, 32 bit, signed

ADDU rd,rs,rt ; rd = rs + rt, 32 bit, unsigned

DADD rd,rs,rt ; rd = rs + rt, 64 bit signed

DADDU rd,rs,rt ; rd = rs + rt, 64 bit, unsigned

DDIV rs,rt ; lo = rs/rt, hi = rs % rt, 64 bit, signed

DDIVU rs,rt ; lo = rs/rt, hi = rs % rt, 64 bit, unsigned

DIV rs,rt ; lo = rs/rt, hi = rs % rt, 32 bit, signed

DIVU rs,rt ; lo = rs/rt, hi = rs % rt, 32 bit, unsigned

DMULT rs,rt ; lo = rs*rt bits 0…63, hi = rs * rt bits 64…127, 64 bit, signed

DMULTU rs,rt ; lo = rs*rt bits 0…63, hi = rs * rt bits 64…127, 64 bit, unsigned

DSLL rd,rt,sa ; rd = rt << sa, 64 bit

DSLLV rd,rt,rs ; rd = rt << rs, 64 bit

DSRA rd,rt,sa ; rd = rt >> sa, arithmetic, 64 bit

DSRAV rd,rt,rs ; rd = rt >> rs, arithmetic, 64 bit

DSUB rd,rs,rt ; rd = rs - rt, 64 bit signed

DSUBU rd,rs,rt ; rd = rs - rt, 64 bit, unsigned

MFLO rd ; rd = lo

MFHI rd ; rd = hi

MOVN rd,rs,rt ; rd = rs if rt ≠0

MOVZ rd,rs,rt ; rd = rs if rt == 0

MULT rs,rt ; lo = rs*rt bits 0…31, hi = rs * rt bits 32…63, 32 bit, signed

MULTU rs,rt ; lo = rs*rt bits 0…31, hi = rs * rt bits 32…63, 32 bit, unsigned

OR rd,rs,rt ; rd | rs

SLL rd,rt,sa ; rd = rt << sa, 32 bit

SLLV rd,rt,rs ; rd = rt << rs, 32 bit

SRL rd,rt,sa ; rd = rt >> sa, 32 bit

SRLV rd,rt,rs ; rd = rt >> rs, 32 bit

SLL rd,rt,sa ; rd = rt << sa, 32 bit

SLLV rd,rt,rs ; rd = rt << rs, 32 bit

SRA rd,rt,i ; rd = rt >> i, arithmetic, 32 bit

SRAV rd,rt,rs ; rd = rt >> rs, arithmetic, 32 bit

SRL rd,rt,i ; rd = rt >> I, , 32 bit

SRLV rd,rt,rs ; rd = rt >> rs, 32 bit

SUB rd,rs,rt ; rd = rs - rt, 32 bit signed

SUBU rd,rs,rt ; rd = rs - rt, 32 bit, unsigned

SLT rd,rs,rt ; rd = 1 if rs < rt, 32 bit signed

SLTU rd,rs,rt ; rd = 1 if rs < rt, 32 bit unsigned

XOR rd,rs,rt ; rd = rs xor rt

פקודות עם קבועים:

ADDI rd,rs,imm ; rd = rs + imm, 32 bit signed

ADDIU rd,rs,imm ; rd = rs + imm, 32 bit unsigned

ANDI rd,rs,imm ; rd = rs & imm, 32 bit unsigned

DADDI rd,rs,imm ; rd = rs + imm, 64 bit signed

DADDIU rd,rs,imm ; rd = rs + imm, 64 bit unsigned

LUI rt, imm ; rt[16..31] = imm, rt[32..63] = sign(imm)

ORI rt, imm ; rt = rt | imm

SLTI rd,rs,imm ; rd = 1 if rs < imm, 32 bit signed

SLTIU rd,rs,imm ; rd = 1 if rs < imm, 32 bit unsigned

XORI rt,rs,imm ; rt = rs xor imm

פקודות טעינה ושמירה בזיכרון:

תמיד אוגר כלליbase תמיד קבוע, offsetערך

LB rt,offset(base) ; load 8 bit

LBU rt,offset(base) ; load 8 bit, unsigned

LD rt,offset(base) ; load 64 bit

LDU rt,offset(base) ; load 64 bit, unsigned

LH rt,offset(base) ; load 16 bit

LHU rt,offset(base) ; load 16 bit, unsigned

LW rt,offset(base) ; load 32 bit

LWU rt,offset(base) ; load 32 bit, unsigned

SB rt,offset(base) ; store 8 bit

SD rt,offset(base) ; store 64 bit

SH rt,offset(base) ; store 16 bit

SW rt,offset(base) ; store 32 bit

פקודות הסתעפות:

JALR rs ; jump to |rs|, $ra = return address

JR rs; jump to |rs|

B offset ; jump to offset

BEQ rs,rt,offset ; jump to offset if rs == rt

BEQZ rs, offset ; jump to offset if rs == 0

BGEZ rs, offset ; jump to offset if rs > 0

BNE rs,rt,offset ; jump to offset if rs ≠ rt

BNEZ rs,offset ; jump to offset if rs ≠ 0

J target ; jump to target

JAL target; jump to target, $ra = return address

קריאות מערכת:

.r1, תשובות מוחזרות ב-r14פרמטרים אם ישנן מוצבעים ע"י

SYSCALL 0 ; halt(). no parameters, halts the simulator

SYSCALL 1; open(). 2 parameters. Parameter 1: char path[](zero terminated), Parameter 2: doubleword flags; Options for flags: O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_APPEND, O_TRUNC, returns file descriptor(integer)

SYSCALL 2; close(). 1 parameter. Parameter: file descriptor.

SYSCALL 3; read(). 3 parameters. Parameter 1: file descriptor, Parameter 2: Memory destination address, 3: Max number of bytes to read.

יפתח חלון קלט מהמקלדת.0 , אם הפרמטר הראשון הוא Syscall 3ב- , ומספר הבתים שנקראו בפועל יוחזרnewlineבפועל הקריאה תהיה עד

.r1ב-

SYSCALL 4: write(). 3 parameters. Parameter 1: file descriptor, Parameter 2: Memory source address, 3: number of bytes to write.

יפתח חלון פלט.3 או 2 , אם הפרמטר הראשון הוא Syscall 3ב-

SYSCALL 5: printf(). Variable length parameters. Parameter 1: format string. Followed by a parameter for every %d or %i (integer) or %s (string) in the format string.

הסתעפות לפרוצדורות

ואם לא ע"יjalהסתעפות לפרוצדורות נעשית כאן בדרך כלל ע"י הפקודה jalr הפקודות הללו שומרות בתוך האוגר .r31$ או בשמו האחר ra.

.jr $ra בדרך כלל jrהסתעפות חזרה נעשה ע"י הפקודה

המחסנית

לא שומר בהסתעפויות לפרוצדורות כתובות חזרהmipsמאחר וה- אלא בתוך אוגר, זה בסדר בתנאי שהרוטינהx86במחסנית כמן ב-

הנקראת לא קוראת בעצמה לרוטינה אחרת. במידה וכן יש לשמור את ולשחזר אותו לפני ההסתעפות חזרה בפקודה. בסימולטורraתוכן ה-$

sp (r29)הזה בדרך כלל מקצים שטח למחסנית, מביאים את האוגר $ מקצים מקום עלraלהצביע לסופו, כאשר יש צורך לשמר אוגר כמו ה-$

המחסנית ומשמרים את האוגר, מאוחר יותר כשצריך משחזרים אותו.עקרונית זה נראה ככה:

daddi $sp,$sp,-8sd $ra,0($sp)

............

ld $ra,0($sp)daddi $sp,$sp,8jr $ra

תוכניות דוגמא:

:printfהתוכנית הבאה ממחישה שימוש ב-

; printf.asm.dataformat_str: .asciiz "%dth of %s:\n%s version %i.%i%d is being tested!"s1: .asciiz "December"s2: .asciiz "printf.asm"printf_param: .space 8th_param: .word64 0s1_addr: .space 8s2_addr: .space 8.word64 11

.word64 222

.word64 3333test:.codedaddi r5, r0, format_strsd r5, printf_param(r0)addi r6,r0,26sd r6,th_param(r0)daddi r2, r0, s1daddi r3, r0, s2sd r2, s1_addr(r0)sd r3, s2_addr(r0)daddi r14, r0, printf_paramsyscall 5syscall 0

פלט ריצה:

26th of December:

printf.asm version 11.2223333 is being tested!

התוכניות הבאות כוללות קוד הממיר המרה של מחרוזת של מספרלמספר שלם בינארי והמרה של מספר בינארי למחרוזת.

האלגוריתמים שממומשים בקטעי הקוד הללו מבוססים על המימושים ב-C:הבאים

void convert_binary_to_string(int x, char str[]){ int rem, i, n, x1; char *cptr;

x1 = x; n=0; while(x1 > 0)

{ n++; x1 = x1 / 10; }// while i = n-1; cptr = &str[n]; *cptr = '\0'; cptr--; while(n > 0) { rem = x % 10; x = x / 10; *cptr = (rem + '0'); printf("c = %c\n", *cptr); cptr--; n--; } // while

} //convert_binary_to_string

int convert_string_to_binary(char str[], int n){ int i, x;

x = 0; if (n == 0) return 0;

for(i=0; i < n; i++) { x = x * 10; x = x +(str[i] - '0'); } // for

return x;} // convert_string_to_binary

מספרים שלמים מהמשתמש ומדפיסה את2התוכנית הבאה קוראת מכפלתם על המסך:

.dataNum: prompt_msg1: .asciiz "Enter First number"prompt_msg2: .asciiz "Enter Second number"params_sys1: .word64 0param2: .word64 0param3:.word64 0x10len1:.word64 0x10len2:.word64 0x10len3:.word64 0x10Number1_text: .space 32result_msg1: .asciiz " * "Number2_text: .space 32result_msg2: .asciiz " = "Number3_text: .space 32One: .word64 0x1Two: .word64 0x2 Three: .word64 0x3Ten: .word 0xA

ZeroCode: .word64 0x30 ; Ascii '0' .textread1: ; r14 points to pramaters for syscallsd r0,params_sys1(r0) ; read from keyboarddaddi r14, r0, params_sys1 ; r14 = &params_sys1 daddi r8, r0,Number1_text ; r8 = Number1_text

sd r8,param2(r0) ; Read first numbersyscall 3sd r1,len1(r0) ; Save first number lengthread2: daddi r14, r0, params_sys1daddi r8, r0,Number2_textsd r8,param2(r0)syscall 3 ; Read second numbersd r1,len2(r0) ; Save first number lengthld r10,len1(r0) ; n = r10 = length of Number1_txtld r13,one(r0) ; r13 = constant 1ld r20,Ten(r0) ; r20 = constant 10movz r11,r0,r0 ; x1 = r11 = 0movz r17,r0,r0 ; ; i = r17 = 0ld r19,ZeroCode(r0) ; r19 = '0'For1: beq r10,r0,EndFor1 ; if (n == 0) break; dmultu r11,r20 ; lo = x1 * 10 mflo r11 ; x1 = r11 = lo = r11 * 10 movz r16,r0,r0 ; r16 = 0 lbu r16,Number1_text(r17) ; r16 = Number1_text[i] dsub r16,r16,r19 ; r16 = Number1_text[i] - '0' dadd r11,r11,r16 ;x1 = x1 + Number1_text[i] - '0' dsub r10,r10,r13 ; n-- dadd r17,r17,r13 ; i++ b For1EndFor1:ld r10,len2(r0) ; n =r10 = length of Number2_txtmovz r12,r0,r0 ; x2 = r12 = 0movz r17,r0,r0 ; i = r17 = 0For2: beq r10,r0,EndFor2 ; if (n == 0) break; dmultu r12,r20 ; x2 * 10 mflo r12 ; x2 = x2 * 10 movz r16,r0,r0 ; r16 = 0 lbu r16,Number2_text(r17) ; r16 = Number1_text[i] dsub r16,r16,r19 ; r16 = Number2_text[i] - '0' dadd r12,r12,r16 ; x2 = x2 + Number2_text[i] - '0' dsub r10,r10,r13 ; n-- dadd r17,r17,r13 ; i++

b For2EndFor2: dmultu r12,r11; lo = x1 * x2 mflo r11 ; r11 = x1 * x2movz r12,r11,r0 ; r12 = x1 * x2movz r17,r0,r0 ; While1: ; find toString(x1 * x2) length; Printed string has to 8 byte alligned beq r11,r0,EndWhile1 ; r11 == 0 break ddiv r11,r20 ; lo = r11 /10 mflo r11 ; r11 = r11 / 10 dadd r17,r17,r13 ;r17++ b While1 EndWhile1: sd r17,len3(r0) ; len3 = toString(r11) length

movz r11,r12,r0 ; r11 = x1 * x2While2: ; Store char until r10==0; Starting fro offset r17 beq r11,r0,EndWhile2 ; if (r11 == ) break ddiv r11,r20; lo = r11/10, hi = r111 % 10 mflo r11 ; r11 = r11 / 10 mfhi r10 ; r10 = r11 %10 dadd r10,r10,r19 ; r10 = r10 + '0' sb r10,Number3_text(r17) ; Number3_text[i] = r10 dsub r17,r17,r13 ; r17-- b While2 EndWhile2: ; Set up SYSCALL 4 write to screenld r22,two(r0) ; Handler 2sd r22, params_sys1(r0) ; First paramdaddi r22, r0, Number1_text ; r22 = offset Number1_textsd r22,param2(r0) ; Second param; string addressld r22,len1(r0) ; Third paramsd r22, param3(r0); number of bytes to print

syscall 4daddi r22, r0, result_msg1 ;r22 = offset result_msg1 sd r22,param2(r0) ; Second param; string addressld r22,Three(r0) ; Third paramsd r22, param3(r0)

syscall 4daddi r22, r0, Number2_textsd r22,param2(r0) ; Second param; string addressld r22,len2(r0) ; Third paramsd r22, param3(r0); number of bytes to printsyscall 4daddi r22, r0, result_msg2sd r22,param2(r0) ; Second param; string addressld r22,Three(r0) ; Third paramsd r22, param3(r0); number of bytes to printsyscall 4daddi r22, r0, Number3_textsd r22,param2(r0) ; Second param; string addressld r22,len3(r0) ; Third param dadd r22,r22,r13 ;r22++sd r22, param3(r0) ; number of bytes to printsyscall 4

end:syscall 0

התוכנית הבאה עושה אותו דבר, אך היא מחולקת לשגרות שניתןלהשתמש בהם שוב:

; mult2.asm - multiply two numbers from keyboard; Use functions.dataNum: prompt_msg1: .asciiz "Enter First number"prompt_msg2: .asciiz "Enter Second number"params_sys1: .word64 0param2: .word64 0param3:.word64 0x10len1:.word64 0x10

len2:.word64 0x10len3:.word64 0x10Number1_text: .space 32result_msg1: .asciiz " * "Number2_text: .space 32result_msg2: .asciiz " = "Number3_text: .space 32One: .word64 0x1Two: .word64 0x2 Three: .word64 0x3Ten: .word 0xAC31: .word 0x1F

ZeroCode: .word64 0x30 ; Ascii '0' .textmain: ; r14 points to pramaters for syscalldaddi r8, r0,Number1_text ; r8 = Number1_textdaddi r14, r0, params_sys1 ; r14 = &params_sys1daddi r9,r0,32 jal read_keyboard_inputsd r1,len1(r0) ; Save first number lengthread2: daddi r14, r0, params_sys1daddi r8, r0,Number2_textdaddi r9,r0,32 jal read_keyboard_input;sd r1,len2(r0) ; Save first number lengthld r10,len1(r0) ; n = r10 = length of Number1_textdaddi r17,r0,Number1_textjal convert_string_to_binary;

movz r12,r11,r0 ; r12 = r11 = x1;daddi r17,r0,Number2_textld r10,len2(r0) ; n =r10 = length of Number2_textjal convert_string_to_binary; dmultu r12,r11; lo = x1 * x2 mflo r11 ; r11 = x1 * x2;daddi r17,r0,Number3_text ; r17 = &Number3_text jal convert_binary_to_stringsd r18,len3(r0) ; len3 = toString(r11) length;; Set up SYSCALL 4 write to screendaddi r8, r0, Number1_text ; r9 = offset Number1_textld r9,len1(r0) ; Third paramjal print_string;daddi r8, r0, result_msg1 ;r22 = offset result_msg1 ld r9,Three(r0) ; Third paramjal print_string;daddi r8, r0, Number2_textld r9,len2(r0) ; Third paramjal print_string;daddi r8, r0, result_msg2ld r9,Three(r0) ; Third paramjal print_string;daddi r8, r0, Number3_textld r9,len3(r0) ; Third param jal print_string

end:syscall 0

read_keyboard_input:; function, expects r14 =&parameter address, r8 = &Destination string

; r9 = max destination size; returns computed number in r11;sd r0,0(r14) ; read from keyboardsd r8,8(r14) ; Destinatiom addresssd r9,16(r14) ; Destination sizesyscall 3jr $ra

convert_string_to_binary:; function, expects r10 =string length, r17 = &Source string; returns computed number in r11daddi r13,r0,1 ; r13 = constant 1daddi r20,r0,10 ; r20 = constant 10movz r11,r0,r0 ; x1 = r11 = 0ld r19,ZeroCode(r0) ; r19 = '0'For1: beq r10,r0,EndFor1 ; if (n == 0) break; dmultu r11,r20 ; lo = x * 10 mflo r11 ; x = r11 = lo = r11 * 10 movz r16,r0,r0 ; r16 = 0 lbu r16,0(r17) ; r16 = text[i] dsub r16,r16,r19 ; r16 = text[i] - '0' dadd r11,r11,r16 ;x = x + text[i] - '0' dsub r10,r10,r13 ; n-- dadd r17,r17,r13 ; i++ b For1EndFor1:jr $ra

convert_binary_to_string:; function, expects r11 =source number, r17 = &destination string; returns length in r18;movz r18,r0,r0movz r12,r11,r0 ; r12 = xWhile1: ; find toString(x) length; Printed string has to 8 byte alligned beq r11,r0,EndWhile1 ; r11 == 0 break ddiv r11,r20 ; lo = r11 /10

mflo r11 ; r11 = r11 / 10 dadd r18,r18,r13 ;r18++ b While1 EndWhile1:

dadd r17,r17,r18 ; r17 = &text+len dadd r18,r18,r13 ;r18++ movz r11,r12,r0 ; r11 = x1 * x2While2: ; Store char until r10==0; Starting fro offset r17 beq r11,r0,EndWhile2 ; if (r11 == 0) break ddiv r11,r20; lo = r11/10, hi = r111 % 10 mflo r11 ; r11 = r11 / 10 mfhi r10 ; r10 = r11 %10 daddi r10,r10,48 ; r10 = r10 + '0' sb r10,0(r17) ; text[i] = r10 dsub r17,r17,r13 ; r17-- b While2 EndWhile2: jr $ra;;print_string:; function, expects r14 =&parameter address, r8 = &Source string; r9 = source size; daddi r23,r0,2sd r23,0(r14) ; Write to output screensd r8,8(r14) ; Source addresssd r9,16(r14) ; Source sizesyscall 4jr $ra

התוכנית הבאה חוסכת חלק ניכר מהקוד, בזכות ההדפסה שנעשית ע"יprintf:)(

; mult2b.asm - multiply two numbers from keyboard; Use functions

.dataNum: prompt_msg1: .asciiz "Enter First number"prompt_msg2: .asciiz "Enter Second number"params_sys1: .word64 0param2: .word64 0param3:.word64 0x10len1:.word64 0x10len2:.word64 0x10len3:.word64 0x10Number1_text: .space 32result_msg1: .asciiz " * "Number2_text: .space 32result_msg2: .asciiz " = "result_msg: .asciiz "%s * %s = %i".word64 0printf_param:.word64 0x1:.word64 0x2:.word64 0x3:.word64 0

One: .word64 0x1Two: .word64 0x2 Three: .word64 0x3Ten: .word 0xA

ZeroCode: .word64 0x30 ; Ascii '0' .textmain: ; r14 points to pramaters for syscalldaddi r8, r0,Number1_text ; r8 = Number1_textdaddi r14, r0, params_sys1 ; r14 = &params_sys1daddi r9,r0,32 jal read_keyboard_inputsd r1,len1(r0) ; Save first number lengthread2: daddi r14, r0, params_sys1daddi r8, r0,Number2_textdaddi r9,r0,32 jal read_keyboard_input;sd r1,len2(r0) ; Save first number lengthld r10,len1(r0) ; n = r10 = length of Number1_textdaddi r17,r0,Number1_textjal convert_string_to_binary;movz r12,r11,r0 ; r12 = r11 = x1;daddi r17,r0,Number2_textld r10,len2(r0) ; n =r10 = length of Number2_textjal convert_string_to_binary; dmultu r12,r11; lo = x1 * x2 mflo r11 ; r11 = x1 * x2 sd r11,x3(r0); daddi r13,r0,result_msg sd r13,printf_param(r0)daddi r13,r0,Number1_text sd r13,x1(r0) daddi r13,r0,Number2_text sd r13,x2(r0) daddi r14,r0,printf_param syscall 5

end:syscall 0

read_keyboard_input:; function, expects r14 =&parameter address, r8 = &Destination string; r9 = max destination size; returns computed number in r11;sd r0,0(r14) ; read from keyboardsd r8,8(r14) ; Destinatiom addresssd r9,16(r14) ; Destination sizesyscall 3jr $ra

convert_string_to_binary:; function, expects r10 =string length, r17 = &Source string; returns computed number in r11daddi r13,r0,1 ; r13 = constant 1daddi r20,r0,10 ; r20 = constant 10movz r11,r0,r0 ; x1 = r11 = 0ld r19,ZeroCode(r0) ; r19 = '0'For1: beq r10,r0,EndFor1 ; if (n == 0) break; dmultu r11,r20 ; lo = x * 10 mflo r11 ; x = r11 = lo = r11 * 10 movz r16,r0,r0 ; r16 = 0 lbu r16,0(r17) ; r16 = text[i] dsub r16,r16,r19 ; r16 = text[i] - '0' dadd r11,r11,r16 ;x = x + text[i] - '0' dsub r10,r10,r13 ; n-- dadd r17,r17,r13 ; i++ b For1EndFor1:jr $ra

התוכנית הבאה מעלה מספר נקלט בריבוע. מאחר ויש כאו שגרההקוראת לשגרה, יש שימוש במחסנית:

; sqrp1.asm - ; Use functions.dataNum: prompt_msg1: .asciiz "Enter number"params_sys1: .word64 0param2: .word64 0param3:.word64 0x10len1:.word64 0x10len2:.word64 0x10Number1_text: .space 32result_msg1: .asciiz " ** 2 = "Number2_text: .space 32

ZeroCode: .word64 0x30 ; Ascii '0' MyStack: .word64 0,0,0

.textmain: ; r14 points to pramaters for syscalldaddi r8,r0, Number1_text ; r8 = Number1_textdaddi r14,r0, params_sys1 ; r14 = &params_sys1daddi r9,r0,32 daddi $sp,r0,MyStackdaddi $sp,$sp,24jal read_keyboard_inputsd r1,len1(r0) ; Save first number lengthjal compute_sqr_x_from_text_to_text

; Set up SYSCALL 4 write to screendaddi r8, r0, Number1_text ; r9 = offset Number1_textld r9,len1(r0) ; Third paramjal print_string

;daddi r8, r0, result_msg1 ;r22 = offset result_msg1 daddi r9,r9,8 ; Third paramjal print_string;daddi r8, r0, Number2_textld r9,len2(r0) ; Third paramjal print_string

end:syscall 0

read_keyboard_input:; function, expects r14 =&parameter address, r8 = &Destination string; r9 = max destination size; returns computed number in r11;sd r0,0(r14) ; read from keyboardsd r8,8(r14) ; Destinatiom addresssd r9,16(r14) ; Destination sizesyscall 3jr $ra

convert_string_to_binary:; function, expects r10 =string length, r17 = &Source string; returns computed number in r11daddi r13,r0,1 ; r13 = constant 1daddi r20,r0,10 ; r20 = constant 10movz r11,r0,r0 ; x1 = r11 = 0ld r19,ZeroCode(r0) ; r19 = '0'For1: beq r10,r0,EndFor1 ; if (n == 0) break; dmultu r11,r20 ; lo = x * 10 mflo r11 ; x = r11 = lo = r11 * 10 movz r16,r0,r0 ; r16 = 0 lbu r16,0(r17) ; r16 = text[i] dsub r16,r16,r19 ; r16 = text[i] - '0' dadd r11,r11,r16 ;x = x + text[i] - '0' dsub r10,r10,r13 ; n--

dadd r17,r17,r13 ; i++ b For1EndFor1:jr $ra

convert_binary_to_string:; function, expects r11 =source number, r17 = &destination string; returns length in r18;movz r18,r0,r0movz r12,r11,r0 ; r12 = xWhile1: ; find toString(x) length; Printed string has to 8 byte alligned beq r11,r0,EndWhile1 ; r11 == 0 break ddiv r11,r20 ; lo = r11 /10 mflo r11 ; r11 = r11 / 10 dadd r18,r18,r13 ;r18++ b While1 EndWhile1:

dadd r17,r17,r18 ; r17 = &text+len dadd r18,r18,r13 ;r18++ movz r11,r12,r0 ; r11 = x1 * x2While2: ; Store char until r10==0; Starting fro offset r17 beq r11,r0,EndWhile2 ; if (r11 == 0) break ddiv r11,r20; lo = r11/10, hi = r111 % 10 mflo r11 ; r11 = r11 / 10 mfhi r10 ; r10 = r11 %10 dadd r10,r10,r19 ; r10 = r10 + '0' sb r10,0(r17) ; text[i] = r10 dsub r17,r17,r13 ; r17-- b While2 EndWhile2: jr $ra;;print_string:; function, expects r14 =&parameter address, r8 = &Source string; r9 = source size

; daddi r23,r0,2sd r23,0(r14) ; Write to output screensd r8,8(r14) ; Source addresssd r9,16(r14) ; Source sizesyscall 4jr $ra;;compute_sqr_x_from_text_to_text:; function, expects r8 =&numbertext, r8 = &Source string; r9 = text size; Store return address in stackdaddi $sp,$sp,-8sd $ra,0($sp)

ld r10,len1(r0) ; n = r10 = length of Number1_textdaddi r17,r0,Number1_textjal convert_string_to_binary; dmultu r11,r11; lo = x * x mflo r11 ; r11 = x1 * x2;daddi r17,r0,Number2_text ; r17 = &Number2_text jal convert_binary_to_stringsd r18,len2(r0) ; len2 = toString(r11) length;; Retrieve return addressld $ra,0($sp)daddi $sp,$sp,8jr $rajr $ra

הגרסאות הבאות של התוכניות מביאות בחשבון אפשרות. מספרים שללייםשל

// itoa3.c

#include <stdio.h> #include <stdlib.h> #include <string.h>

void convert_binary_to_string(int x, char str[]){ int rem, i, n, x1, sign, start; char *cptr;

start = 0; sign = 1; if(x < 0) { sign = -1; x = -x; start = 1; } // if x1 = x; n=0; while(x1 > 0) { n++; x1 = x1 / 10; }// while

if (sign == -1) n++; i = n-1; cptr = &str[n]; *cptr = '\0'; cptr--;

while(n > start) { rem = x % 10; x = x / 10; *cptr = (rem + '0'); cptr--; n--; } // while if (sign == -1) *cptr = '-';

} //convert_binary_to_string

int convert_string_to_binary(char str[], int n){ int i, x, sign;

x = 0; if (n == 0) return 0;

sign = 1; i = 0; if (str[0] == '-') { sign = -1; i = 1; } // if else if (str[0] == '+') i = 1;

for(; i < n; i++) { x = x * 10; x = x +(str[i] - '0'); } // for

return (sign*x);} // convert_string_to_binary

int main(int argc, char *argv[]){ int f,g, h; char str[80];if (argc < 3) { fprintf(stderr, "usage:convert_binary_to_string int\n"); exit(0); } // if

f = convert_string_to_binary(argv[1], strlen(argv[1]));g = convert_string_to_binary(argv[2], strlen(argv[2]));h = f*g;convert_binary_to_string(h, str);printf("%s * %s = %s\n",argv[1], argv[2], str);return 0;

} // main

:mipsתוכנית ; mult3.asm - multiply two numbers from keyboard; Use functions.dataNum:

prompt_msg1: .asciiz "Enter First number"prompt_msg2: .asciiz "Enter Second number"params_sys1: .word64 0param2: .word64 0param3:.word64 0x10len1:.word64 0x10len2:.word64 0x10len3:.word64 0x10Number1_text: .space 32result_msg1: .asciiz " * "Number2_text: .space 32result_msg2: .asciiz " = "Number3_text: .space 32One: .word64 0x1Two: .word64 0x2 Three: .word64 0x3Ten: .word 0xAC31: .word 0x1F

ZeroCode: .word64 0x30 ; Ascii '0' .textmain:

; r14 points to pramaters for syscalldaddi r8, r0,Number1_text ; r8 = Number1_textdaddi r14, r0, params_sys1 ; r14 = &params_sys1daddi r9,r0,32 jal read_keyboard_inputsd r1,len1(r0) ; Save first number lengthread2: daddi r14, r0, params_sys1daddi r8, r0,Number2_textdaddi r9,r0,32 jal read_keyboard_input;sd r1,len2(r0) ; Save first number lengthld r10,len1(r0) ; n = r10 = length of Number1_textdaddi r17,r0,Number1_textjal convert_string_to_binary;movz r12,r11,r0 ; r12 = r11 = x1;daddi r17,r0,Number2_textld r10,len2(r0) ; n =r10 = length of Number2_textjal convert_string_to_binary; dmultu r12,r11; lo = x1 * x2 mflo r11 ; r11 = x1 * x2;daddi r17,r0,Number3_text ; r17 = &Number3_text jal convert_binary_to_stringsd r18,len3(r0) ; len3 = toString(r11) length;; Set up SYSCALL 4 write to screendaddi r8, r0, Number1_text ; r9 = offset Number1_textld r9,len1(r0) ; Third param

jal print_string;daddi r8, r0, result_msg1 ;r22 = offset result_msg1 ld r9,Three(r0) ; Third paramjal print_string;daddi r8, r0, Number2_textld r9,len2(r0) ; Third paramjal print_string;daddi r8, r0, result_msg2ld r9,Three(r0) ; Third paramjal print_string;daddi r8, r0, Number3_textld r9,len3(r0) ; Third param jal print_string

end:syscall 0

read_keyboard_input:; function, expects r14 =&parameter address, r8 = &Destination string; r9 = max destination size; returns computed number in r11;sd r0,0(r14) ; read from keyboardsd r8,8(r14) ; Destinatiom addresssd r9,16(r14) ; Destination sizesyscall 3jr $ra

convert_string_to_binary:; function, expects r10 =string length, r17 = &Source string; returns computed number in r11

addi r24,r0,1; r24 = signaddi r25,r0,45; r25 = '-'movz r26,r0,r0lb r26,0(r17)bne r26,r25,NonNeg1addi r17,r17,1addi r24,r0,-1addi r10,r10,-1NonNeg1:addi r25,r0,43; r25 = '+'bne r26,r24,NotPlus1addi r17,r17,1addi r10,r10,-1NotPlus1:daddi r13,r0,1 ; r13 = constant 1daddi r20,r0,10 ; r20 = constant 10movz r11,r0,r0 ; x1 = r11 = 0ld r19,ZeroCode(r0) ; r19 = '0'For1: beq r10,r0,EndFor1 ; if (n == 0) break; dmultu r11,r20 ; lo = x * 10 mflo r11 ; x = r11 = lo = r11 * 10 movz r16,r0,r0 ; r16 = 0 lb r16,0(r17) ; r16 = text[i] dsub r16,r16,r19 ; r16 = text[i] - '0' dadd r11,r11,r16 ;x = x + text[i] - '0' dsub r10,r10,r13 ; n-- dadd r17,r17,r13 ; i++

b For1EndFor1:dmult r11,r24mflo r11jr $ra

convert_binary_to_string:; function, expects r11 =source number, r17 = &destination string; returns length in r18;addi r25,r0,0; r24 = startaddi r24,r0,1; r24 = signaddi r25,r0,45; r25 = '-'

bgez r11,NonNeg2beqz r11,NonNeg2addi r24,r0,-1; r24 = signdsub r11,r0,r11 ; r11 = |r11|sb r25,0(r17);addi r17,r17,1;addi r18,r0,1NonNeg2:

movz r12,r11,r0 ; r12 = xaddi r20,r0,10movz r18,r0,r0While1: ; find toString(x) length; Printed string has to 8 byte alligned beq r11,r0,EndWhile1 ; r11 == 0 break ddiv r11,r20 ; lo = r11 /10 mflo r11 ; r11 = r11 / 10 dadd r18,r18,r13 ;r18++

b While1 EndWhile1:

dadd r17,r17,r18 ; r17 = &text+len dadd r18,r18,r13 ;r18++ movz r11,r12,r0 ; r11 = x1 * x2While2: ; Store char until r10==0; Starting fro offset r17 beq r11,r0,EndWhile2 ; if (r11 == 0) break ddiv r11,r20; lo = r11/10, hi = r111 % 10 mflo r11 ; r11 = r11 / 10 mfhi r10 ; r10 = r11 %10 daddi r10,r10,48 ; r10 = r10 + '0' sb r10,0(r17) ; text[i] = r10 dsub r17,r17,r13 ; r17-- b While2 EndWhile2: bne r24,r13,NoNeg3addi r18,r18,1NoNeg3:jr $ra;;print_string:; function, expects r14 =&parameter address, r8 = &Source string; r9 = source size; daddi r23,r0,2sd r23,0(r14) ; Write to output screensd r8,8(r14) ; Source addresssd r9,16(r14) ; Source size

syscall 4jr $ra

מספר פלטים:123456 * -81 = -9999936-54321 * -987654 = 53650352934612731 * -654321 = -4009227606511876 * 432 = 810432