Адресация

индексация, SPIM: работа с байтами. Секции .text и .data

  1. Адресация.
    • Адресация — обращение к элементу данных по его адресу. Существует несколько способ интерпретации битов инструкции для указания местоположения данных:
    • Неявная адресация
    • Непосредственная
    • Прямая
    • Регистровая
    • Косвенная
    • Базовая
    • Относительная
    • Индексная
    • ...
  2. Секции(сегменты)
    • В программе принято отделять данные от кода. Секция есть непрерывный диапазон адресов, все данные в которых считаются с некоторой точки зрения однородными.
    • Некоторые процессоры аппаратно поддерживают подобное разделение.
    • Для определения секций в языке ассемблера MARS служат директивы: ".text" и ".data".
    • Ассемблер MARS не позволяет определять данные в секции .text.
      • директивы определения данных: ".word", ".half", ".byte", ".asciiz", ".ascii"
      • метки
      • точка входа, директива ".globl"
  3. Команды загрузки и сохранения:
    • lw, lh, lhu, lb, lbu
    • sw, sh, sb
    • lbu
    •    1 ## poly.asm -- complete program
         2 ##
         3 ## evaluate  5x^2 -12x + 97 
         4 ##
         5 ## Register Use:
         6 ##
         7 ## $10 base register, address of x
         8 ## $11 x
         9 ## $12 value of the polynomial
        10 ## $13 temporary
        11 
        12         .text
        13         .globl  main
        14 
        15 main: 
        16         lui   $10,0x1001     #  Init base register
        17         lw    $11,0($10)     #  Load x
        18 
        19         ori   $12,$0,97      #  Initialize the accumulator
        20                              #  during the "load delay slot"
        21 
        22         ori   $13,$0,12      #  evaluate second term
        23         mult  $11,$13        #  12x
        24         mflo  $13            #  assume 32 bit result
        25         subu  $12,$12,$13    #  accumulator = -12x +97
        26 
        27                              #  evaluate third term
        28         mult  $11,$11        #  x^2
        29         mflo  $11            #  assume 32 bit result
        30         ori   $13,$0,5       #  5
        31         mult  $11,$13        #  5x^2
        32         mflo  $13            #
        33         addu  $12,$12,$13    #  accumulator = 5x^2-12x+97
        34 
        35         sw    $12,4($10)     #  Store result in poly
        36 
        37         .data
        38 x:      .word   17           #  Edit this line to change the value of x
        39 poly:   .word   0            #  Result is placed here.
        40 
        41 ## End of file
      
  4. Команды перехода:
    • j, jr
    • beq, bne, bltz, bgez
    •    1 ##   $8  --- A, two's comp. integer
         2 ##   $9  --- sign bit of A
         3 ##   $10 --- base register for .data section
         4 
         5         .text
         6         .globl  main
         7 
         8 main: 
         9 # Get A
        10         lui   $10,0x1001     #  Init base register
        11         lw    $8,0($10)      #  Load A
        12         sll   $0,$0,0
        13 
        14 # Is A Negative?
        15         srl   $9,$8,31       #  Shift sign bit to position 0
        16         beq   $0,$9,done     #  sign bit == zero, done
        17         sll   $0,$0,0
        18 
        19 # Store -A
        20         subu  $8,$0,$8       #  negate A
        21         sw    $8,0($10)      #  save it
        22 
        23 done:   sll   $0,$0,0        #  target of the branch
        24 
        25         .data
        26 A:      .word  -14
        27 
        28 ## End of File
      
  5. Работа с байтами.
    •    1 ## endian.asm
         2 ##
         3 ## copy $9 to memory in big-endian order
         4 ##
         5 ## Register Use:
         6 ## $8  --- first byte of the tape buffer
         7 ## $9  --- 4-byte integer
         8 
         9       .text
        10       .globl  main
        11 
        12 main: 
        13       lui  $9,0x1234      # put data in $9
        14       ori  $9, $9, 0x5678      #
        15       lui  $8,0x1001      # $8 is base register
        16       sb   $9,3($8)       # least significant byte
        17       srl  $9,$9,8        # move next byte to low order
        18       sb   $9,2($8)       # bits 8-15 
        19       srl  $9,$9,8        # move next byte to low order
        20       sb   $9,1($8)       # bits 16-23 
        21       srl  $9,$9,8        # move next byte to low order
        22       sb   $9,0($8)       # most significant byte
        23 
        24       .data
        25 tape:                     # base register points here
        26       .space 1024         # tape buffer (1K bytes)
        27          
      
  6. Массивы.
    •    1 ## addIntArray.asm
         2 ##
         3 ## Sum all integers, the positive integers,
         4 ## and the negative integers in an array.
         5 
         6 ## Registers:
         7 ##  $8 -- count
         8 ##  $9 -- pointer to the array entry
         9 ## $10 -- current array entry
        10 ## $11 -- sum of all integers
        11 ## $12 -- sum of negative integers
        12 ## $13 -- sum of positive integers
        13 ## $14 -- pos. or neg. flag
        14 ## $15 -- length of the array
        15 
        16          .text
        17          .globl  main
        18 # Initialize
        19 main:    ori      $8,$0,0        #  count = 0
        20          ori      $11,$0,0       #  sum = 0
        21          ori      $12,$0,0       #  neg = 0
        22          ori      $13,$0,0       #  pos = 0
        23          lui      $9,0x1001      #  point at SIZE
        24 
        25          lw       $15,0($9)      #  get SIZE
        26          addiu    $9,$9,4        #  point to first entry
        27 
        28 # while  count < SIZE do
        29 loop:    beq      $8,$15,done 
        30          sll      $0,$0,0        #  branch delay
        31 
        32 # get entry, add to sum
        33          lw       $10,0($9)      #  get entry
        34          sll      $0,$0,0        #  load delay
        35          addu     $11,$11,$10    #  add to sum
        36 
        37 #  test neg. or pos.
        38          slti     $14,$10,0x0    #  set $14 if entry is neg
        39          bne      $14,$0,neg     #  branch if negative
        40          sll      $0,$0,0        #  branch delay
        41          addu     $13,$13,$10    #  positive: add to PLUS
        42          j        ifend
        43          sll      $0,$0,0        #  branch delay
        44 
        45 neg:     addu     $12,$12,$10    #  negative: add to NEG
        46 
        47 ifend:   addiu    $8,$8,1        # count++
        48          addiu    $9,$9,4        # point at next entry
        49          j        loop
        50          sll      $0,$0,0        #  branch delay
        51 
        52 # finish
        53 done:    sll      $0,$0,0        # target for branch
        54 
        55         .data
        56 size:   .word  4
        57 array:  .word  1, 2, -2, -1
      
  7. Аресация MIPS:

addr.png

ArchitectureAssembler/09_Addressing (last edited 2015-12-29 08:43:59 by FrBrGeorge)