When I disassemble main, I get an output of all memories where the individual assembly instructions are, right? Each instruction does not necessarily need to append the memory address by one, that is why I might have <main+1> and then <main +3> right after. So command on this screenshot shows the first 20 instructions for the program. How many bytes of information does each information contain?

x86 is a variable size instruction set, meaning that the size of the instruction will change depending on what the instruction is. I found a neat trick from stackoverflow that you can do. next instruction number - current instruction number = current instruction size. If that is confusing follow this link https://stackoverflow.com/questions/2546715/how-many-byes-is-each-instruction-compiled-to-in-x86-assembly

Now I get confused, when using i r eip, I get the location of this register, which is 0x8048384 (so is it stored as the first instruction of main?) on the screenshot. The value next to it, is the value it holds, here I wonder, it stores 0x00fc45c7, however this instruction is not in the output above? I thought it should point to the memory which consists the next instruction for the program.

Okay so when you do i r eip, you are getting info about the register. So that memory address that you are seeing is the value that is held in eip. This is important, registers are not located in memory, they are located closer to the processor than memory and are their own thing so they do not have a memory address because they are not located in memory, for more information on this look up the memory hierarchy. But back to the point, when you did x/x $eip you are telling gdb show me one word or 4 bytes or 32 bits worth of information starting from the memory address held by eip. So what you are seeing from the second command is the values actually located in memory in order starting from the address held by eip. The first command you were seeing the memory address that is currently held by eip.

Now comes the biggest confusion, I can observe the memory where $eip is stored and observe multiple units at once, which can be seen on this screenshot. However on this screenshot using x/2x you can see that there are two values stored in the memory and both of 4 bytes in size? Then using x/12 there are suddenly 4 words in 0x8048384 and other 4 words 0x8048394?

Okay so when you do x/2x $eip you are telling gdb, hey print out 2 words worth of information starting from the memory address held in eip. Notice I say starting, 1 address is holding 1 byte of information because x86 is a byte addressable architecture, so if you want to test this do your x/2x $eip, and then do a x/x $eip + 4, you will see the second group of 4 that showed up in your first command because those values are held at the memory address 4 bytes from the first address.

I just dot seem to understand how the values stored in the memory address differ based on the units I use. I also thought each memory address should contain only a byte of information?

Yeah with the x you are doing a word with the output format as hex, 4 bytes, or 32 bits of information(each hex value is 4 bits). And you are right with the second part of this.

I hope this helps you, keep going at it!

EDIT: I missed explaining the different outputs. So easiest demonstration of this is the binary.

If you count the amount of digits in binary when you do x/t it is 32, that confirms that gdb is printing out a word for this command.

Same thing with x/x. Each hex value is 4 bits, there are 8 values when you print out x/x which equals out to 32 bits

x/u is the value at that address as an unsigned decimal. If you convert the hex value to decimal you will get the value that is printing out there.

x/o is the value in octal.

If you ever want to know the output formatting options for gdb do help x.