CS 208 s20 — C: Programming With Memory

• we will conceive of memory as one giant array of cells or locations, each of which can store one byte (8 bits) of data
• the index or location of a byte in memory is called its memory address
  • a memory address, like an array index, is just a number identifying a position within the array of bytes
• where do these addresses come from? how big can they be (i.e., how long is our array of bytes)?
  • the organization of a system's memory is based on the word size
  • among other things, the word size defines the number of bytes in a memory address
    • all memory addresses will be this same fixed length
  • the size of a memory address determines the number of possible addresses
    • the address space is the amount of memory that can be given addresses
• EXAMPLE: let's bring this together by considering a very small memory

• in this example, memory addresses (and the word size) are 3 bits
  • 3 bits give 8 unique combinations, and thus 8 unique memory addresses (i.e., locations for a byte in memory)
  • so we say that the address space for this memory is 8 bytes—we have enough unique addresses to refer to a total of 8 different locations/bytes
• QUICK CHECK: if our word size is 4 bits, how big is our address space? (how many different bytes can we refer to with the set of possible addresses) ¹
• modern systems use 64-bit (8-byte) words, for a potential address space of \(2^{64}\) bytes = 18 billion billion bytes = 18 exabytes

ASSIGNED READING: section 2.1.2 of the CSPP book (p. 39–42)

• not all data consists of just a single byte
• for example, a C int is 32 bits/4 bytes wide
  • what address should we use?
  • any chunk of memory is addressed using the first byte (i.e., lowest memory address)
• just like we saw that the bit pattern 0x4e6f21 had many different interpretations, the interpretation of data at a memory address depends on both the address and the size

• so a char stored at memory address 0x100 would consist of just the single byte at 0x100

• It helps you think like an actual computer (abstraction close to machine level) without dealing with raw machine code
• You'll understand just how much Your Favorite Language provides
• C is still widely used
• C's pitfalls still fuel devastating reliability and security failures today (modern relevance, after a sense)

• Probably not the right language for your next personal project
• It "gets out of the programmer's way" even when the programmer is unwittingly running toward a cliff
• Advances in programming language design have produced languages that fix C's problems while keeping its strengths
  • Rust is a good example

Take a look at this spreadsheet-based Memory diagram. First I'll go over how to read the diagram:

• I've taken a section of memory 40-bytes long (address 0x00 to 0x27) and laid it out as a grid
  • 10 rows of 4 bytes each
• Each row goes from left to right, so to read all the bytes in consecutive order, you would follow a zig-zag pattern
  • left to right on the bottom row, then back to the left byte of the next row up, and so on
• The address of the first byte in each row is shown along the left-most column
• Along the top is shown a byte offset
• To get the address of a particular byte/spreadsheet cell, take the row address to the left and add the byte offset for the column
  • So the 4 bytes in the bottom row are at addresses 0x00, 0x01 (0x00 + 0x01), 0x02 (0x00 + 0x02), and 0x03 (0x00 + 0x03)
  • The 4 bytes on the row above that are at 0x04 (0x04 + 0x00), 0x04 (0x04 + 0x01), 0x06 (0x04 + 0x02), and 0x07 (0x04 + 0x03)

Next, let's go through the values in the diagram and what they mean:

• This is a 32-bit example, meaning that the memory addresses are 32-bit (4 bytes) wide
• I'm using little-endian byte ordering
• The number 240 is stored at address 0x20 (240 = 0xf0 = 0x00 00 00 f0 using little endian)
• A pointer stored at address 0x08 and points to the contents at address 0x20
• A pointer to a pointer is stored at address 0x00
• The number 12 is stored at address 0x10. Is it a pointer? How do we know values are pointers or not?
  • Remember: everything is bits, what the value at 0x10 means depends on interpretation/context

In C, think of assignment statements as having the above structure: a memory location on the left and a value to write to that location on the right.

int* p; // p: 0x04
int x = 5; // x: 0x14, store 5 at 0x14
int y = 2; // y: 0x24, store 2 at 0x24
p = &x; // store 0x14 at 0x04
// load the contents at 0x04 (0x14)
// load the contents at 0x14 (0x5)
// add 1 and store sum at 0x24
y = 1 + *p;
// load the contents at 0x04 (0x14)
// store 0xF0 (240) at 0x14
*p = 240;

Here's a memory diagram to go along with the example code above. Again, I am using a 32-bit word size. Trace through the C code and make sure you understand how this code makes the changes between the top and bottom diagrams.

What will be printed?

int a = 10;
int b = 20;
int *pa = &a;
a += 5;
int *pb = &b;
*pa = *pb - *pa;
*pb += a;
printf("a = %d b = %d\n", a, b);