Basic Data Types

1
Basic Data Types

• Integral
• Stored operated on in general registers
• Signed vs. unsigned depends on instructions used
• Intel GAS Bytes C
• byte b 1 unsigned char
• word w 2 unsigned short
• double word l 4 unsigned int
• Floating Point
• Stored operated on in floating point registers
• Intel GAS Bytes C
• Single s 4 float
• Double l 8 double
• Extended t 10/12 long double

2
Array Allocation

• Basic Principle
• T AL
• Array of data type T and length L
• Contiguously allocated region of L sizeof(T)
  bytes

char p3
3
Array Access

• Basic Principle
• T AL
• Array of data type T and length L
• Identifier A can be used as a pointer to array
  element 0
• Reference Type Value
• val4 int 3
• val int x
• val1 int x 4
• val2 int x 8
• val5 int ??
• (val1) int 5
• val i int x 4 i

4
Array Example
typedef int zip_dig5 zip_dig uc 6, 0, 6,
3, 7 zip_dig mit 0, 2, 1, 3, 9 zip_dig
cmu 1, 5, 2, 1, 3

• Notes
• Declaration zip_dig cmu equivalent to int
  cmu5
• Example arrays were allocated in successive 20
  byte blocks
• Not guaranteed to happen in general

5
Array Accessing Example

• Computation
• Register edx contains starting address of array
• Register eax contains array index
• Desired digit at 4eax edx
• Use memory reference (edx,eax,4)

int get_digit (zip_dig z, int dig) return
zdig

• Memory Reference Code

edx z eax dig movl
(edx,eax,4),eax zdig
6
Referencing Examples

• Code Does Not Do Any Bounds Checking!
• Reference Address Value Guaranteed?
• mit3 36 4 3 48 3
• mit5 36 4 5 56 1
• mit-1 36 4-1 32 7
• uc15 16 415 76 ??
• Out of range behavior implementation-dependent
• No guaranteed relative allocation of different
  arrays

Yes
No
No
No
7
Nested Array Example
define PCOUNT 4 zip_dig pghPCOUNT 1, 5,
2, 0, 6, 1, 5, 2, 1, 3 , 1, 5, 2, 1, 7
, 1, 5, 2, 2, 1

• Declaration zip_dig pgh4 equivalent to int
  pgh45
• Variable pgh denotes array of 4 elements
• Allocated contiguously
• Each element is an array of 5 ints
• Allocated contiguously
• Row-Major ordering of all elements guaranteed

8
Nested Array Allocation

• Declaration
• T ARC
• Array of data type T
• R rows, C columns
• Type T element requires K bytes
• Array Size
• R C K bytes
• Arrangement
• Row-Major Ordering

int ARC
4RC Bytes
9
Nested Array Row Access

• Row Vectors
• Ai is array of C elements
• Each element of type T
• Starting address A i C K

int ARC
  
  
A
AiC4
A(R-1)C4
10
Nested Array Row Access Code
int get_pgh_zip(int index) return
pghindex

• Row Vector
• pghindex is array of 5 ints
• Starting address pgh20index
• Code
• Computes and returns address
• Compute as pgh 4(index4index)

eax index leal (eax,eax,4),eax 5
index leal pgh(,eax,4),eax pgh (20 index)
11
Nested Array Element Access

• Array Elements
• Aij is element of type T
• Address A (i C j) K

A i j
int ARC
Ai
  
  
A i j
  
  
A
AiC4
A(R-1)C4
A(iCj)4
12
Nested Array Element Access Code

• Array Elements
• pghindexdig is int
• Address
• pgh 20index 4dig
• Code
• Computes address
• pgh 4dig 4(index4index)
• movl performs memory reference

int get_pgh_digit (int index, int dig)
return pghindexdig
ecx dig eax index leal
0(,ecx,4),edx 4dig leal (eax,eax,4),eax
5index movl pgh(edx,eax,4),eax (pgh
4dig 20index)
13
Multi-Level Array Example

• Variable univ denotes array of 3 elements
• Each element is a pointer
• 4 bytes
• Each pointer points to array of ints

zip_dig uc 6, 0, 6, 3, 7 zip_dig mit
0, 2, 1, 3, 9 zip_dig cmu 1, 5, 2, 1, 3
define UCOUNT 3 int univUCOUNT mit, cmu,
uc
14
Element Access in Multi-Level Array
int get_univ_digit (int index, int dig)
return univindexdig

• Computation
• Element access MemMemuniv4index4dig
• Must do two memory reads
• First get pointer to row array
• Then access element within array

ecx index eax dig leal
0(,ecx,4),edx 4index movl univ(edx),edx
Memuniv4index movl (edx,eax,4),eax
Mem...4dig
15
Array Element Accesses

• Similar C references
• Nested Array
• Element at
• Mempgh20index4dig

• Different address computation
• Multi-Level Array
• Element at
• MemMemuniv4index4dig

int get_pgh_digit (int index, int dig)
return pghindexdig
int get_univ_digit (int index, int dig)
return univindexdig
16
Strange Referencing Examples

• Reference Address Value Guaranteed?
• univ23 5643 68 3
• univ15 1645 36 0
• univ2-1 564-1 52 9
• univ3-1 ?? ??
• univ112 16412 64 6
• Code does not do any bounds checking
• Ordering of elements in different arrays not
  guaranteed

Yes
No
No
No
No
17
Using Nested Arrays
define N 16 typedef int fix_matrixNN

• Strengths
• C compiler handles doubly subscripted arrays
• Generates very efficient code
• Avoids multiply in index computation
• Limitation
• Only works if have fixed array size

/ Compute element i,k of fixed matrix product
/ int fix_prod_ele (fix_matrix a, fix_matrix b,
int i, int k) int j int result 0 for
(j 0 j lt N j) result
aijbjk return result
18
Dynamic Nested Arrays

• Strength
• Can create matrix of arbitrary size
• Programming
• Must do index computation explicitly
• Performance
• Accessing single element costly
• Must do multiplication

int new_var_matrix(int n) return (int )
calloc(sizeof(int), nn)
int var_ele (int a, int i, int j, int n)
return ainj
movl 12(ebp),eax i movl 8(ebp),edx
a imull 20(ebp),eax ni addl
16(ebp),eax nij movl (edx,eax,4),eax
Mema4(inj)
19
Structures

• Concept
• Contiguously-allocated region of memory
• Refer to members within structure by names
• Members may be of different types
• Accessing Structure Member

struct rec int i int a3 int p
Memory Layout
Assembly
void set_i(struct rec r, int val)
r-gti val
eax val edx r movl eax,(edx)
Memr val
20
Generating Pointer to Struct. Member
r
struct rec int i int a3 int p
i
a
p
0
4
16
r 4 4idx

• Generating Pointer to Array Element
• Offset of each structure member determined at
  compile time

int find_a (struct rec r, int idx) return
r-gtaidx
ecx idx edx r leal 0(,ecx,4),eax
4idx leal 4(eax,edx),eax r4idx4
21
Structure Referencing (Cont.)

• C Code

struct rec int i int a3 int p
void set_p(struct rec r) r-gtp
r-gtar-gti
edx r movl (edx),ecx r-gti leal
0(,ecx,4),eax 4(r-gti) leal
4(edx,eax),eax r44(r-gti) movl
eax,16(edx) Update r-gtp
22
Alignment

• Aligned Data
• Primitive data type requires K bytes
• Address must be multiple of K
• Required on some machines advised on IA32
• treated differently by Linux and Windows!
• Motivation for Aligning Data
• Memory accessed by (aligned) double or quad-words
• Inefficient to load or store datum that spans
  quad word boundaries
• Virtual memory very tricky when datum spans 2
  pages
• Compiler
• Inserts gaps in structure to ensure correct
  alignment of fields

23
Specific Cases of Alignment

• Size of Primitive Data Type
• 1 byte (e.g., char)
• no restrictions on address
• 2 bytes (e.g., short)
• lowest 1 bit of address must be 02
• 4 bytes (e.g., int, float, char , etc.)
• lowest 2 bits of address must be 002
• 8 bytes (e.g., double)
• Windows (and most other OSs instruction sets)
• lowest 3 bits of address must be 0002
• Linux
• lowest 2 bits of address must be 002
• i.e., treated the same as a 4-byte primitive data
  type
• 12 bytes (long double)
• Linux
• lowest 2 bits of address must be 002
• i.e., treated the same as a 4-byte primitive data
  type

24
Satisfying Alignment with Structures

• Offsets Within Structure
• Must satisfy elements alignment requirement
• Overall Structure Placement
• Each structure has alignment requirement K
• Largest alignment of any element
• Initial address structure length must be
  multiples of K
• Example (under Windows)
• K 8, due to double element

struct S1 char c int i2 double v
p
c
i0
i1
v
p0
p4
p8
p16
p24
Multiple of 4
Multiple of 8
Multiple of 8
Multiple of 8
25
Linux vs. Windows
struct S1 char c int i2 double v
p

• Windows (including Cygwin)
• K 8, due to double element
• Linux
• K 4 double treated like a 4-byte data type

26
Overall Alignment Requirement
struct S2 double x int i2 char c
p
p must be multiple of 8 for Windows 4 for
Linux
struct S3 float x2 int i2 char c
p
p must be multiple of 4 (in either OS)
27
Ordering Elements Within Structure
struct S4 char c1 double v char c2
int i p
10 bytes wasted space in Windows
struct S5 double v char c1 char c2
int i p
2 bytes wasted space
28
Arrays of Structures

• Principle
• Allocated by repeating allocation for array type
• In general, may nest arrays structures to
  arbitrary depth

struct S6 short i float v short j
a10
a12
a20
a16
a24
29
Accessing Element within Array

• Compute offset to start of structure
• Compute 12i as 4(i2i)
• Access element according to its offset within
  structure
• Offset by 8
• Assembler gives displacement as a 8
• Linker must set actual value

struct S6 short i float v short j
a10
short get_j(int idx) return aidx.j
eax idx leal (eax,eax,2),eax
3idx movswl a8(,eax,4),eax
a12i
a12i8
30
Satisfying Alignment within Structure

• Achieving Alignment
• Starting address of structure array must be
  multiple of worst-case alignment for any element
• a must be multiple of 4
• Offset of element within structure must be
  multiple of elements alignment requirement
• vs offset of 4 is a multiple of 4
• Overall size of structure must be multiple of
  worst-case alignment for any element
• Structure padded with unused space to be 12 bytes

struct S6 short i float v short j
a10
Multiple of 4
Multiple of 4
31
Vulnerable Buffer Code
/ Echo Line /void echo() char buf4
/ Way too small! / gets(buf)
puts(buf)
int main() printf("Type a string")
echo() return 0
32
Buffer Overflow Executions
unixgt./bufdemo Type a string123 123
unixgt./bufdemo Type a string12345 Segmentation
Fault
unixgt./bufdemo Type a string12345678 Segmentation
Fault
33
Buffer Overflow Stack
/ Echo Line /void echo() char buf4
/ Way too small! / gets(buf)
puts(buf)
echo pushl ebp Save ebp on stack movl
esp,ebp subl 20,esp Allocate space on
stack pushl ebx Save ebx addl -12,esp
Allocate space on stack leal -4(ebp),ebx
Compute buf as ebp-4 pushl ebx Push buf on
stack call gets Call gets . . .
34
Buffer Overflow Stack Example
Before call to gets
35
Buffer Overflow Example 1
Before Call to gets
Input 123
No Problem
36
Buffer Overflow Stack Example 2
Input 12345
Saved value of ebp set to 0xbfff0035 Bad news
when later attempt to restore ebp

echo code
8048592 push ebx 8048593 call 80483e4
lt_init0x50gt gets 8048598 mov
0xffffffe8(ebp),ebx 804859b mov ebp,esp
804859d pop ebp ebp gets set to invalid
value 804859e ret
37
Buffer Overflow Stack Example 3
Input 12345678
ebp and return address corrupted
8048648 call 804857c ltechogt 804864d mov
0xffffffe8(ebp),ebx Return Point