Super User is a question and answer site for computer enthusiasts and power users. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top
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?

share|improve this question
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 '12 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 '12 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 '12 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 '12 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 '12 at 23:39
up vote 4 down vote accepted

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.

share|improve this answer
1  
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 '12 at 23:45
    
Yes, that's correct. – Hand-E-Food Nov 29 '12 at 1:40
    
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. – Jamie Hanrahan Sep 17 '15 at 8:25

You must log in to answer this question.

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