Download presentation

Presentation is loading. Please wait.

1
**Chapter 6 Data Structures**

Lecture notes to accompany the text book SPARC Architecture, Assembly Language Programming, and C, by Richard P. Paul, 2nd edition, 2000 Abinashi Dhungel 1

2
**Arrays and Structures Cannot be stored in registers**

Necessary to perform address arithmetic Registers do not have addresses Array – indexable data structure whose elements are all of same type and given an index i, j , k etc. the corresponding array element can be accessed 2

3
**One-Dimensional Array**

Address of ith array element = address_of_first_element + i*size_of_array_element_in_bytes (Chap 5) Accessing ith element (shift, add, load/store) sll %ir, 2, %o !o0 = i * 4 add %fp, %o0, %o0 !o0 = %fp + i*4 ld [%o0 + a_offset], %o0 !o0 = [%fp + a_offset + %ir * 4] 3

4
**Multidimensional Array**

Mapping may take many different forms Row major and Column major ordering For 2-D array arranged in row major order address a[i][j] = address of a[0][0] + (number of rows above ith row) * (number of elements in a row * size of an element) + (number of elements left of the jth column) * size of an element Assuming m rows and n columns and size_el for each element = address of a[0][0] + (i*n + j)*size_el Column major order ? 4

5
**Multidimensional Array**

Mapping ith, jth and kth element of 3-D array int arr[di][dj][dk] in row major order = address of arr[0][0] + i*dj*dk*size_el + j*dk*size_el + k*size_el = %fp + arr_offset + ((i*dj + j)*dk + k)*4 Many languages except Fortran – row major 5

6
**An example of multi-dimensional array access**

short ary[16][3][4][15] accessing i, j, kth element : (%fp + ary_offset) + (((i*d2 + j)*d3 + k)*d4 + l)*2 mov %i_r, %o0 call .mul mov d2, %o1 !%o0 = i*d2 add %j_r, %o0, %o0 !%o0 = i*d2 + j mov d3, %o1 !%o0 = (i*d2 + j)*d3 add %k_r, %o0, %o0 !%o0 = (i*d2 + j)*d3 + k .mul mov d4, %o1 !%o0 = ((i*d2 + j)*d3 + k)*d4 add %l_r, %o0, %o0 !%o0 = ((i*d2 + j)*d3 + k)*d4 + l sll %o0, 1, %o0 !%o0 = (((i*d2 + j)*d3 + k)*d4 + l) * 2 add %fp, %o0, %o0 ldsh [%o0 + ary_offset], %o0 !%o0 = ary[i][j][k][l] Address computation of an element in an n-dimensional array in general requires n-1 multilication and n additions 6

7
**Lower bound different from zero**

Example as in pascal, b: array[l1..u1, l2..u2, l3..u3] of integer d1 = u1 – l1 +1 d2 = u2 – l d3 = u3 – l3 + 1 Address of ith ,jth, and kth element is %fp + b_offset + (((i – l1) * dj + (j – l2)) * dk + (k – l3)) * 4 7

8
Array Bound Checking Can be checked with the lower or upper bound of an array to prevent invalid memory access. lower_bound = global main main: subcc %i_r, lower_bound, %g0 bl error error: Accessing a constant subscript may be done by an assembler, for example to access arr[-1][3][3] ld [%fp + b0 + (((-1*d2+3) * d3 + 3) << 2)], %o0 8

9
**Address Arithmetic (multiplication by positive constant)**

Multiplication by a constant can be done by shifting and adding mov %o0, %o1 !times one sll %o0, 2, %o0 !times four add %o0, %o1, %o1 !times five Easier with binary numbers Multiply %o0 by (03514)8 = binary sll %o0, 2, %o1 sll %o1, 1, %o0 add %o0, %o1, %o1 sll %o0, 3, %o0 sll %o0, 2, %o0 sll %o0, 1, %o0 9

10
**Multiplying with string of 1’s**

111 is same as multiplying with (1000 – 1) sub %g0, %o0, %o1 sll %l0, 3, %o0 add %o0, %o1, %o1 !times seven 1110 is same as multiplying with (10000 – 10) 10

11
**Structures Block of contiguous memory to store variables (fields)**

Fields may be of different types Must be aligned to the highest sized data element struct example { int a, b; char d; short x, y; int u, v; } a_offset = 0 b_offset = 4 d_offset = 8 x_offset = 10 y_offset = 12 u_offset = 16 v_offset = 20 str_size = 24 str_offset = -str_size & = -24 ld [%fp + str_offset + a_offset], %o0 !o0 = a ld [%fp + str_offset + b_offset], %o0 !o0 = b ldub [%fp + str_offset + d_offset], %o0 !o0 = d ldsh [%fp + str_offset + x_offset], %o0 !o0 = x ldsh [%fp + str_offset + y_offset], %o0 !o0 = y ld [%fp + str_offset + u_offset], %o0 !o0 = u ld [%fp + str_offset + v_offset], %o0 !o0 = v 11

12
**Alignining fields struct ex { int a, char b;**

short c; int d; } a_offset = 0 b_offset = align(a_offset + sizeof(a)) c_offset = align(b_offset + sizeof(b)) d_offset = align(c_offset + sizeof(c )) aligning any size x with b bytes can be done by (x + (b-1)) & -b a_offset = 0 b_offset = ((0+4) + 3) & -4 = 4 c_offset = ((4+1) + 1) & -2 = 6 d_offset = ((6+2) + 3) & -4 = 8 str_size = ((8+4) + 3) & -4 = 12 str_offset = -12&-4 = -12 12

Similar presentations

Presentation is loading. Please wait....

OK

Chapter 8 – Machine Instructions

Chapter 8 – Machine Instructions

© 2018 SlidePlayer.com Inc.

All rights reserved.

To ensure the functioning of the site, we use **cookies**. We share information about your activities on the site with our partners and Google partners: social networks and companies engaged in advertising and web analytics. For more information, see the Privacy Policy and Google Privacy & Terms.
Your consent to our cookies if you continue to use this website.

Ads by Google

Ppt on 3 phase ac circuits Ppt on how google search engine works Ppt on conservation of environment natural resources Ppt on world wide web Surface conduction electron emitter display ppt online Ppt on peace and nonviolence Ppt on network switching tutorial Ppt on diode characteristics pdf Ppt on van de graaff generator hair Ppt on fair and lovely cream