check_parity_flag:
        mov eax, esi
        mov ax, dx
        and ax, 4h
        cmp ax, 4h
        je parity_flag_set
check_aux_flag:
        mov eax, esi
        mov ax, dx
        and ax, 10h
        cmp ax, 10h
        je aux_flag_set
    

  cmp one_thing,another_thing
  jz .test1_equal
  ;test1 not equal path
  ;...
  jmp .test1_done
.test1_equal:
  ;test1 equal path
  ;...
.test1_done:    

Hello,

So I am pretty familiar with basic usage of x86 assembly instruction set at this point as well as the main CPU flags.

However, when I write asm programs, I am finding that I am struggling with program control flow because of the linear nature of assembly. What I mean by this is, I can use cmp and conditional jmp instructions, but I am not accounting for the fact that, for example, if the jump is not taken, the control flow falls through to areas that I don't want it to.

Obviously, in C and higher, if statements make this crystal clear... But in assembly, I am finding that my programs step into areas that I do not want. For example, I wrote a program which does a pushf, loads the flags into ax, and then does some bit masks to check each individual flag and it's supposed to output whether each flag is set via printf msvcrt. Here is a small snippet:

Code:

check_parity_flag:
        mov eax, esi
        mov ax, dx
        and ax, 4h
        cmp ax, 4h
        je parity_flag_set
check_aux_flag:
        mov eax, esi
        mov ax, dx
        and ax, 10h
        cmp ax, 10h
        je aux_flag_set
    

The thing is, if for example the parity flag is not set, execution falls through to check_aux_flag but my mov, eax esi instruction is only valid if the code at parity_flag_set is executed BEFORE the code at check_aux_flag. If the parity flag is NOT set, the execution falls through to mov eax, esi and it overwites eax with the value in esi that I do not want and messes up the rest of the program.

Are there any good books or resources on how to properly structure your assembly program to avoid these kinds of pitfalls? I obviously understand that this is a problem, but since I am still new to this, I am having a hard time coming up with a solution in an elegant way without making the program unnecessarily complex and confusing. In this example, I have code at parity_flag_set and aux_flag_set which calls printf and thus clears out the registers that I want. Is this just because I need to be using memory and cannot effectively accomplish this with registers only?

Thank you.

Are there any good books or resources on how to properly structure your assembly program to avoid these kinds of pitfalls? I obviously understand that this is a problem, but since I am still new to this, I am having a hard time coming up with a solution in an elegant way without making the program unnecessarily complex and confusing. In this example, I have code at parity_flag_set and aux_flag_set which calls printf and thus clears out the registers that I want. Is this just because I need to be using memory and cannot effectively accomplish this with registers only?
Thank you.

  cmp one_thing, another_thing
  jz .test1_equal
    ; test1 not equal path
    ; ...
    jmp .test1_done
  .test1_equal:
    ; test1 equal path
    ; ...
.test1_done:
  blah    

I suggest you indent your blocks just like in a HLL, makes it much easier to see IMO. Using revolution's example:

Code:

  cmp one_thing, another_thing
  jz .test1_equal
    ; test1 not equal path
    ; ...
    jmp .test1_done
  .test1_equal:
    ; test1 equal path
    ; ...
.test1_done:
  blah    

Roughly translates to an if...else block.