mips ट्यूटोरियल
मिलों के साथ शुरुआत करना

टिप्पणियों

स्थापना या सेटअप

मिल स्थापित करने या स्थापित करने पर विस्तृत निर्देश।

खिड़कियों के लिए QtSpim

1. यहाँ से QtSpim को डाउनलोड करें 32.6 MB
2. इसे आसान स्थापना स्थापित करें
3. अपनी पहली असेंबली फ़ाइल (.s) बनाएं या नमूना C का उपयोग करें : \ Program Files (x86) \ QtSpim \ hellworld.s
4. डेस्कटॉप शॉर्टकट या C: \ Program Files (x86) \ QtSpim \ QtSpim.exe से प्रोग्राम चलाएँ

कार्यक्रम के लिए दो विंडो हैं जिनमें से एक में QtSpim का लेबल दिया गया है, यहां आप जिस प्रोग्राम को निष्पादित कर रहे हैं, उसे (लेबल का पाठ), मेमोरी (लेबल का डेटा), रजिस्टरों के मान (फ्लोटिंग पॉइंट के लिए लेबल एफपी रजिस्टर और पूर्णांक के लिए रेग) और सिम्युलेटर के लिए नियंत्रण

अन्य विंडो लेबल कंसोल वह जगह है जहां आप आउटपुट देखेंगे और यदि कोई हो तो अपने प्रोग्राम के इनपुट में प्रवेश करें

5. फ़ाइल का उपयोग करके फ़ाइल लोड करें -> फ़ाइल लोड करें
6. अंतिम परिणाम को देखने के लिए आप क्लिक रन (f5) का उपयोग कर सकते हैं या चरण दर चरण (p10) पर जा सकते हैं ताकि प्रोग्राम और डिबगिंग की स्थिति देखी जा सके।

MARS MIPS सिम्युलेटर

MARS MIPS सिम्युलेटर मिसिसिपी स्टेट यूनिवर्सिटी ( src ) में पीट सैंडरसन और केनेथ वोल्मार द्वारा विकसित MIPS प्रोसेसर के लिए एक असेंबली भाषा संपादक, कोडांतरक, सिम्युलेटर और डिबगर है।

आपको यहां मुफ्त में MARS मिलते हैं । 4.5 संस्करण को स्थापित करने के लिए, आपको यहां से अपने सिस्टम के लिए उपयुक्त जावा एसडीके की आवश्यकता हो सकती है

कोडांतरण से पहले, इस सिम्युलेटर का वातावरण सरलीकृत रूप से तीन खंडों में विभाजित किया जा सकता है: ऊपरी बाएँ पर संपादक जहां सभी कोड लिखे जा रहे हैं, संपादक के नीचे संकलक / आउटपुट और "सीपीयू" का प्रतिनिधित्व करने वाले रजिस्टर की सूची हमारे कार्यक्रम के लिए।

कोडांतरण के बाद (केवल F3 दबाकर) पर्यावरण में परिवर्तन होता है, जिसमें दो नए खंडों को संपादक का स्थान मिलता है: पाठ खंड

i) असेंबली कोड की प्रत्येक पंक्ति को "मूल" कॉलम (कॉलम में "हम एक सेकंड में बात करेंगे)

ii) "कोड" कॉलम में प्रत्येक निर्देश के लिए मशीन कोड,

और डेटा सेगमेंट जहां हम एक प्रोसेसर की मेमोरी के छोटे एंडियन ऑर्डर के प्रतिनिधित्व को देख सकते हैं।

कोडांतरण के बाद, हम अपने कोड को या तो एक साथ (F5) या स्टेप बाय स्टेप (F7) पर निष्पादित कर सकते हैं, साथ ही निष्पादन को कई चरणों में पीछे की ओर (F8) पर रीवाइंड कर सकते हैं।

अब, ऊपर का उदाहरण कोड देखते हैं और प्रत्येक पंक्ति को समझाते हैं:

.text
.globl main
main:            #main function

li    $v0, 11    #11=system code for printing a character, $v0=register that gets the system code for printing as value
la    $a0, 'a'   #'a'=our example character, $a0=register that accepts the character for printing
syscall          #Call to the System to execute our instructions and print the character at the a0 register 

li $v0, 10       #11=system code for terminating, $v0=register that gets the system code for terminating (optional, but desirable)
syscall          #Call to the System to terminate the execution

MAR .MAS फ़िल्टाइप के साथ फ़ाइलों को स्वीकार और निर्यात करता है

लेकिन ऊपर का कोड सिर्फ एक चरित्र को छापता है, अच्छे राजभाषा "हैलो वर्ल्ड" के बारे में क्या? क्या बारे में, पता नहीं, एक नंबर या कुछ और जोड़कर? ठीक है, हम बदल सकते हैं जो हमारे लिए थोड़ा सा था:

.data               #data section 
str: .asciiz "Hello world\n"  
number: .word 256
 
.text                 #code section 
.globl main 
main: 
li       $v0, 4                #system call for printing strings 
la       $a0, str              #loading our string from data section to the $a0 register
syscall  
       
la       $t0, number        #loading our number from data section to the $t0 register
lw       $s1, 0($t0)        #loading our number as a word to another register, $s1 

addi     $t2, $s1, 8         #adding our number ($s1) with 8 and leaving the sum to register $t2

sw       $t2, 0($t0)        #storing the sum of register $t2 as a word at the first place of $t0

li       $v0, 10               # system call for terminating the execution
syscall 

MARS के माध्यम से परिणामों को चित्रित करने से पहले, इन आदेशों के बारे में थोड़ा और स्पष्टीकरण की आवश्यकता है:

• सिस्टम कॉल ऑपरेटिंग सिस्टम से प्रदान की जाने वाली सेवाओं का एक समूह है। सिस्टम कॉल का उपयोग करने के लिए, आवश्यक ऑपरेशन के लिए कॉल कोड को $ v0 रजिस्टर करने की आवश्यकता होती है। यदि सिस्टम कॉल में तर्क होते हैं, तो उन्हें $ a-$ a2 रजिस्टर में डाल दिया जाता है। यहां सभी सिस्टम कॉल हैं।

• li (लोड तत्काल) एक छद्म निर्देश है (हम बाद में उस बारे में बात करेंगे) जो तुरंत एक रजिस्टर को एक मूल्य के साथ लोड करता है। la (भार पता) भी एक छद्म निर्देश है जो एक पते को एक रजिस्टर में लोड करता है। साथ li $v0, 4 $ V0 रजिस्टर है अब 4 मूल्य के रूप में है, जबकि la $a0, str भार के स्ट्रिंग str के लिए $a0 रजिस्टर।

• एक शब्द है (जितना हम MIPS के बारे में बात कर रहे हैं) एक 32 बिट्स अनुक्रम है, जिसमें बिट 31 सबसे महत्वपूर्ण बिट है और बिट 0 कम से कम महत्वपूर्ण बिट है।

• lw (लोड वर्ड) मेमोरी से एक रजिस्टर में ट्रांसफर होता है, जबकि sw (स्टोर वर्ड) एक रजिस्टर से मेमोरी में ट्रांसफर होता है। lw $s1, 0($t0) कमांड के साथ, हमने $s1 उस मूल्य को रजिस्टर करने के लिए लोड किया है जो $t0 रजिस्टर के LSB पर था (यानी 0 यहाँ क्या दर्शाता है, शब्द की ऑफसेट), उर्फ 256 । यहाँ $t0 का पता है, जबकि $s1 का मूल्य है। sw $t2, 0($t0) इसके ठीक विपरीत काम करता है।

• MARS लिटिल एंडियन का उपयोग करता है, जिसका अर्थ है कि किसी शब्द का LSB मेमोरी के सबसे छोटे बाइट पते पर संग्रहीत होता है।

• MIPS बाइट पते का उपयोग करता है , इसलिए एक पता इसके पिछले और अगले 4 से अलग है।

कोड को पहले से असेंबल करके, हम आगे समझ सकते हैं कि मेमोरी और रजिस्टर कैसे एक्सचेंज करते हैं, डेटा सेगमेंट से "हेक्साडेसिमल वैल्यूज़" को अक्षम करते हैं:

या डेटा सेगमेंट से "ASCII" को सक्षम करना:

इसे ऐसे शुरू करें

$ java -jar Mars4_5.jar

इस फाइल को बनाएं और सेव करें।

    .text
main:
    li    $s0,0x30
loop:
    move    $a0,$s0        # copy from s0 to a0
    
    li    $v0,11        # syscall with v0 = 11 will print out
    syscall            # one byte from a0 to the Run I/O window

    addi    $s0,$s0,3    # what happens if the constant is changed?
    
    li    $t0,0x5d
    bne    $s0,$t0,loop
    nop            # delay slot filler (just in case)

stop:    j    stop        # loop forever here
    nop            # delay slot filler (just in case)

इसे एसेम्बली करने के लिए F3 दबाएँ और फिर रन दबाएँ। अब आप MIPS कोड का संकलन और क्रियान्वयन शुरू कर रहे हैं।