0
0x8048384 <main+16>: 0x00fc45c7     0x83000000     0x7e09fc7d     0xc713eb02
0x8048394 <main+32>: 0x84842404     0x01e80804     0x8dffffff     0x00fffc45

So each memory address contains 16 bytes of data? 4x4 = 16. So 4 bytes is = 0x00fc45c7

Am I right?

5
  • 2
    I am not sure I follow your question. Either you read it as 'One memory address contains one byte of data. Per definition. And in the case of PCs that byte is 8 bit wide). Then 0x00fc45c7 is a set of four bytes (0x00, 0xFC, 0x45 and 0xC7) written in a shorter form. Or you are looking at four sets of 4 bytes per line.
    – Hennes
    Nov 28, 2012 at 23:28
  • Hmm ... so it is 8 bytes wide. I thought it was 4 bytes wide. Because you have main incrementing from 16 to 16. Are you sure?
    – Alkerak
    Nov 28, 2012 at 23:30
  • 4 sets of 4 bytes is 16 bytes (or 0x10 bytes in hexadecimal). 0x80483<b>8</b>4 plus sixteen (0x10) is 0x80483<b>9</b>4
    – Hennes
    Nov 28, 2012 at 23:32
  • ok, I think I got it. So 0x00fc45c7 is 4 bytes. And I have 16 bytes total per line. But is this not one memory address? 0x8048384. So in this memory address are stored 16 bytes of data or 0x00fc45c7 0x83000000 0x7e09fc7d 0xc713eb02
    – Alkerak
    Nov 28, 2012 at 23:36
  • It depends on how you look at a memory address. One way is to look at an address is a single byte. Another way would be to look at it with the width of the databus (in which case a single address is a set of four sequential bytes. All which which can be read simultaneously, and which start at a modulo 4 offset).
    – Hennes
    Nov 28, 2012 at 23:39

1 Answer 1

5

It doesn't. A specific address in memory generally points to one byte of memory. However, your display here is showing you every byte of memory from 0x8048384 to 0x80483A4 - That's 32 bytes of memory, organized into 2 rows of 4 4-byte values.

If you look carefully on the left side, the addresses don't increment by one between the lines, but rather by 16: 84 -> 94 (in base 16), which tells you that there are 16 bytes of memory being displayed on each line. This is often more convenient than 1-byte-per-line, and these 16-byte lines are further broken down into 4-byte groups because it's quite common to use aligned, 32-bit numbers, which each grouping of 4 bytes represents. This makes it easier to visually process the information without resorting to other tools for interpretation.

4
  • 2
    I think I get it. So 0x00fc45c7 rests at 0x8048384 and 0x83000000 rests at (0x8048384+4) and so forth. Am I correct?
    – Alkerak
    Nov 28, 2012 at 23:45
  • Yes, that's correct. Nov 29, 2012 at 1:40
  • 1
    Addendum: debuggers, disk dump utilities, and similar tools commonly use the sort of display shown. The output COULD be shown as a four-byte address (eight hex digits) followed by a single byte, then another four-byte address (one higher than the previous) followed by another byte, etc. But that would take a lot of space on the display. Displaying on each line 16 bytes' worth of content along with the address of the first byte is a convenient and widely-understood convention for saving display space while showing enough "landmarks" (addresses) so one doesn't get lost. Sep 17, 2015 at 8:25
  • 1
    Addendum 2. A memory address does not contain data. A memory address tells where data is. The memory at the address contains data. Sep 26, 2016 at 3:23

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .