.section .data
    data_items:
    .long 3,67,34,222,45,75,54,34,44,33,22,11,66,0
re-1: the data_items is a tag name

we call that an 'identifier' , we use 'tags' in html...
I think it would also be considered a 'symbol' in assembly.
----
re-2: the last 0 will indicate no more items in the array long type

zero is the terminating character.
So this is a zero terminated string , the same as a C string.
----
re-3:
  .section .text "??"   ## a 'symbol' to indicate the program section
    .global _start "??"   ## a global scoped symbol named: 'start'
----
re-4:
  movl data_items(,%edi,4), %eax " here we are asigning
      the value of the first item in the array type
      (long, i think the size is 4 byte) which index 0 to register eax"
     
YES!
  'data_items' holds and address (like a C array identifier)
  %edi holds a value representing the indice (value is 0 at this time), 
  the data size must be stated in the 3rd parameter (yes 4 bytes, 32 bits).
----
re-5:
  start_loop: "??"

He's setting a symbol in the program running order. (contains an address)
Concept:
  The program runs from _start till 'nothing else to be done'. (exit)
  It is arranged in memory in the same order you see here.
  That 'start_loop' symbol will hold the address of that point in program.
  Then you will be able refer to it to 'jump' (jmp, je) to later.
  Think of it as a marker...
----
re-6:
  cmpl $0, %eax
  je loop-exit " tag to the code that ends the application"

Kinda,,, It says:
  If (the cmp operation set the %eflags register to indicate equal) 
  { jump to the address stored in 'loop-exit' (which is just before the exit routine). }
----
re-7:
  mov data_items(,%edi,4), %eax " loading the next
    item in the list i hope u can go over this part
    i do understand what it is doing but the syntax part
    i wanna know more about it"

yes this is an important concept to grasp
especially since your focus is supposed to be toward data structures

Note that in: (,%edi,4)  there is a first value missing (which is ok)
This is basically like pointer arithmetic in C (C++)
Think of that as a indice dereferencing statement like: 'data_items[%edi]'.

In C++ we would define that 'data structure' like this:
int data_items = { 3,67,34,222,45,75, ...}
C++ will log the size info automatically so we can use indicing as above.
In assembly we must supply all of that info.
In chapter 3 he has the section 'Addressing Modes' ... review (again)...
Note that what we are seeing here is in x86 syntax (AT&T)
  Intel syntax does this differently, something like: 'data_items[edi:4]' I think. 
----
re -8:
  cmpl %ebx, %eax
    "if %ebx>%eax skip a line and read after it else go back to the loop
     so we will retreive the next item.
     i wish if u go over the cmpl instruction cuz the book says it compare two
     integer and discard the result but returns a flag ??"

Right, good questons...  (You forgot the all-important following jle)
We take so much for granted in C when we do:
if( ebx > eax )
The 'if' looks for a true or false from the operation which detemines
whether it will run or 'jump' past the next line (or block of code).
This is how all that really works!

  cmpl %ebx, %eax
  jle start_loop   {  true: 'goto' that 'start_loop' address}   OR
                    false: fall through to next line ( replace the maximum)

Let's see if I can get this...
So, in the book:  'Appendix B. Common x86 Instructions' shows me:

	
Quote:
	

	

		

			
				
  cmpl                I/R/M, R/M         O/S/Z/A/P/C
Compares two integers by subtracting the first operand from the second.
It discards the results, but sets the flags accordingly.
			
		
	
	

OK, see the description of the eflags register at the begining of that appendix.
It's not very clear how true or false is set but if I take it one step at a time:

On the first pass ebx holds 3 , eax holds 67. (trace code with pencil and paper if needed)
So cmpl does this:  67 - 3 = 64

looking at the flag descriptions ask yourself: Self?
- is  overflow set? no
- is      sign set? no
- is      zero set? no
- is aux carry set? no
- is   parity  set? no
- is the carry set? no

Ok now look at the jcc description in the same appendix:

	
Quote:
	

	

		

			
				
Jcc            destination address  O/S/Z/A/C
Jumps to the given address if the condition code  is true
			
		
	
	

So it looks at those eflags (OSZAC) and lets see, are any of them true? NO
So jle is false , we fall through the jle and exchange the values....
Then we hit the jmp which takes us back up to the 'start_loop:'.
(I'm reallly confused now)

Ok so now ebx holds the new value 67 and eax comes up with 34:
So cmpl does this: 34 - 67 = -33  (you see, result is only needed to set flags)
- is  overflow set? no
- is      sign set? yes
- is      zero set? no
- is aux carry set? yes
- is   parity  set? no  NOT CHECKED  (see reference above)
- is the carry set? yes

So the jle sees all the trues and so takes us back up to 'start_loop:'
eax is NOT movl 'ed to ebx.

Does that make sense to you? Explain it to me then!
Now, you must be thinking:
'Howard , to know all that flag stuff, you sure are a fart smella'...
I would say to you 'whoeva is the smella is mos likely the della!'
Seriously: 
...realizing why the Sign flag is set is obvious to me but I am learning
 these things as we speak and writing them down as best I can for now.
For this part I have been using 'gdb' to observe these values which is 
something I have mentioned a few times but haven't gone into. 
With that I can see all the register values:

eax            0x22     34
ecx            0x0      0
edx            0x0      0
ebx            0x43     67
esp            0xbfbfb6a0       0xbfbfb6a0
ebp            0x0      0x0
esi            0x0      0
edi            0x2      2
eip            0x8048091        0x8048091 <start_loop+15>
eflags         0x293    [ CF AF SF IF ]

Pretty cool huh? Ready to learn that yet , it's easy and really neat.
----
Re-9: 
"now the last part is to call interruption 80 to exit the application.

It's an 'interrupt'  which causes an  interruption... (picky, picky)
----
Re-10:
i also want to know how echo $? will display the %ebx which is holding the
max value in the array"

It's like the 'int' value which is returned with 'int main()'
(to my understanding, this is one byte and so the max value is 255) 

You can check the return of any process this way in linux.
$ is used to indicate a shell 'variable' which is also an 'identifier'.
The ? is a special 'environment' variable ,, that is it's one of the many
values specified to make your working environment the way it is... type:
env     ... at the command line...  (read the bash prompt howto)

Well I hope I got some stuff right anyhow. I'll post and review....
sorry so long getting this done, I am very slow...

## Referring back to you post #21 'minimum value ---NOT' problem:
## First of all a couple of things got fouled up in your posting:
line 6:  .global_start   ##should be   .global _start
line 23:  star_loop:     ##should be   start_loop:

## To use gdb to trace through your program  you need to compile it
##   with the '-gstabs' option to add debugging information to the binary.
  as -gstabs  081212_zatora1.s -o 081212_zatora1.o

## link it as normal
  ld  081212_zatora1.o -o  081212_zatora1

## Then run it in the gdb debugger like this:
  gdb ./081212_zatora1

## So gdb cranks up with the program in it.
## Then set a break point to stop the program from running straight through:
##   (the * means an address +5 means up 5 bytes from there. (remember our
##      code goes into memory, the _start symbol represents an address  ))
(gdb) break *_start+u
Breakpoint 1 at 0x8048079: file 081212_zatora1.s, line 10.

## Then 'run' the program which stops at the breakpoint , showing the next line to be executed:
(gdb) run
Starting program: /mnt/e/forums/081212_zatora1

Breakpoint 1, _start () at 081212_zatora1.s:10
10      movl data_items(, %edi, 4), %eax  # moving item index 0 to EAX
Current language:  auto; currently asm

## Then we begin to 'step' through the program:
(gdb) step
_start () at 081212_zatora1.s:11
11      movl %eax, %ebx                         # initializing EBX to the value of EAX

## Line 10 has been executed. Line 11 is shown and will be next.
## Note: A press of [ENTER] will repeat the last gdb command (which was 'step')
(gdb)
start_loop () at 081212_zatora1.s:15
15      cmpl $0, %eax                   # check if EAX is 0

## Note that 's' can be used as a shortcut to 'step'. This is true for most.
## ok so to get a feel just step through the code until it exits thusly:

(gdb)
loop_exit () at 081212_zatora1.s:32
32      int  $0x80
(gdb)

Program exited with code 0336.

## 336? there is no 336 on the list!
## Oh , the leading 0 (zero) means it's the value is shown in 'octal' (base 8)
## ok so 6 + (3*8) + (3*64) = 6 + 24 + 192 = 222  ... still the maximum value!
## So it still finds the maximum instead of the minimum. So what's going wrong?
## run through it again but pay special attention this section:
(gdb)
start_loop () at 081212_zatora1.s:21
21      cmpl %eax, %ebx                 # compare %EAX to %EBX
(gdb)
start_loop () at 081212_zatora1.s:23
23      jg start_loop                   # jump to start_loop if EAX is greater or equal to %EBX

## now stop right there and look at the registers with:
(gdb) info register
eax            0x43     67
ecx            0x0      0
edx            0x0      0
ebx            0x3      3
esp            0xbfaf5db0       0xbfaf5db0
ebp            0x0      0x0
esi            0x0      0
edi            0x1      1
eip            0x8048091        0x8048091 <start_loop+15>
eflags         0x287    [ CF PF SF IF ]
cs             0x73     115
ss             0x7b     123
ds             0x7b     123
es             0x7b     123
fs             0x0      0
gs             0x0      0

## Keep in mind line 21 has just been done and 22 is next
## The compl has been done and eflags has been set according to the result.
## compl %eax, %ebx -does this ebx - eax == 3 - 67 == -64
## so  the Carry , Parity , and Sign flags are set (IF is always set... )
## now a look at the reference shows jg checks truth of positive result
## the sign bit is set so jg is going to say 'false'
## so the jump up will not occur and we fall through and value will be changed.
## so let's see it happen!
## Note: The uparrow keys will scroll though previous commands.
(gdb) s
start_loop () at 081212_zatora1.s:25
25      movl %eax, %ebx

## Which way did we go? The right way...
## BUT the WRONG way if we are looking for the minimum value!!!
## So that is where the problem is. So get in there and FIX IT !
## pretty cool huh.
## Type 'help' for a full list of gdb command topics to look into and try out.
## The end

(gdb) gdb ./beg  

## No, you don't do that within gdb.
## That's the command line to start gdb with the program loaded which you already did.

## Next you set the breakpoint and... wow I just looked back up there and it says:
(gdb) break *_start+u  

##  That is WRONG !!! I don't know what happended there... it should be:
(gdb) break *_start+5
( and my edit time is way past ,,, what a 'duh',,,  sorry)

## Then step,,, (just follow the steps)