{"id":100765,"date":"2019-01-22T23:00:00","date_gmt":"2019-01-23T14:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/?p=100765"},"modified":"2019-03-18T11:09:38","modified_gmt":"2019-03-18T18:09:38","slug":"20190123-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20190122-00\/?p=100765","title":{"rendered":"The Intel 80386, part 3: Flags and condition codes"},"content":{"rendered":"

The flags register contains a bunch of stuff, but here are the flags easily accessible in the debugger: <\/p>\n\n\n\n\n\n\n\n\n\n\n
Flag<\/th>\nClear\/Set<\/th>\nMeaning<\/th>\nNotes<\/th>\n<\/tr>\n
OF<\/td>\nnv\/ov<\/td>\nOverflow<\/td>\n<\/td>\n<\/tr>\n
DF<\/td>\nup\/dn<\/td>\nDirection<\/td>\nMust be up<\/var> at function boundaries<\/td>\n<\/tr>\n
SF<\/td>\npl\/ng<\/td>\nSign<\/td>\n<\/td>\n<\/tr>\n
IF<\/td>\nei\/di<\/td>\nInterrupts<\/td>\nSet if interrupts are enabled<\/td>\n<\/tr>\n
ZF<\/td>\nnz\/zr<\/td>\nZero<\/td>\n<\/td>\n<\/tr>\n
AF<\/td>\nna\/ac<\/td>\nAuxiliary carry<\/td>\nNot used by C code<\/td>\n<\/tr>\n
PF<\/td>\npe\/po<\/td>\nParity<\/td>\nNot used by C code<\/td>\n<\/tr>\n
CF<\/td>\nnc\/cy<\/td>\nCarry<\/td>\n<\/td>\n<\/tr>\n<\/table>\n

We’ll learn about the direction flag when we get to string operations. The important detail for now is that the direction flag must be clear (up<\/var>) at function boundaries. <\/p>\n

Instructions for manipulating the interrupt flag are privileged, so you won’t see user-mode code messing with it. I wouldn’t normally have mentioned it, but the Windows disassembler displays the state of the interrupt flags in the register output, so I included it here just so you can see what it means (and then promptly forget about it). <\/p>\n

The auxiliary carry is used to indicate whether a carry occurred between bits 3 and 4. It is used by the binary coded decimal instructions. <\/p>\n

The parity is used to indicate whether the number of set bits in the least significant 8 bits of the result is odd or even. <\/p>\n

The Clear\/Set<\/i> column denotes how the Windows disassembler represents flags in the register output: <\/p>\n

\neax=00000000 ebx=00000000 ecx=9f490000 edx=00000000 esi=7f19e000 edi=00000000\neip=77a93dad esp=0048f844 ebp=0048f870 iopl=0         nv up ei pl<\/span> zr na pe nc<\/span>\ncs=0023  ss=002b  ds=002b  es=002b  fs=0053  gs=002b             efl=00000246<\/span>\n<\/pre>\n
The efl<\/var> represents the value of the 32-bit flags register, and selected bits are parsed out and rendered as mnemonics on the line above. <\/p>\n
Various combinations of conditions can be expressed with condition codes. Note that many conditions have multiple mnemonics. The first one listed is the one the disassembler uses. <\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Code<\/th>\nMeaning<\/th>\nCondition<\/th>\nNotes<\/th>\n<\/tr>\n
E<\/code><\/td>\nEqual<\/td>\nZF<\/code><\/td>\n<\/td>\n<\/tr>\n
Z<\/code><\/td>\nZero<\/td>\n<\/tr>\n
NE<\/code><\/td>\nNot equal<\/td>\n!ZF<\/code><\/td>\n<\/td>\n<\/tr>\n
NZ<\/code><\/td>\nNot zero<\/td>\n<\/tr>\n
A<\/code><\/td>\nAbove<\/td>\n!CF && !ZF<\/code><\/td>\nUnsigned greater than<\/td>\n<\/tr>\n
NBE<\/code><\/td>\nNot below or equal<\/td>\n<\/tr>\n
AE<\/code><\/td>\nAbove or equal<\/td>\n!CF<\/code><\/td>\nUnsigned greater than or equal<\/td>\n<\/tr>\n
NB<\/code><\/td>\nNot below<\/td>\n<\/tr>\n
NC<\/code><\/td>\nNo carry<\/td>\nNo unsigned overflow<\/td>\n<\/tr>\n
B<\/code><\/td>\nBelow<\/td>\nCF<\/code><\/td>\nUnsigned less than<\/td>\n<\/tr>\n
NAE<\/code><\/td>\nNot above or equal<\/td>\n<\/tr>\n
C<\/code><\/td>\nCarry set<\/td>\nUnsigned overflow<\/td>\n<\/tr>\n
BE<\/code><\/td>\nBelow or equal<\/td>\nCF || ZF<\/code><\/td>\nUnsigned less than or equal<\/td>\n<\/tr>\n
NA<\/code><\/td>\nNot above<\/td>\n<\/tr>\n
G<\/code><\/td>\nGreater<\/td>\n!(SF ^ OF) && !ZF<\/code><\/td>\nSigned greater than<\/td>\n<\/tr>\n
NLE<\/code><\/td>\nNot less than or equal<\/td>\n<\/tr>\n
GE<\/code><\/td>\nGreater than or equal<\/td>\n!(SF ^ OF)<\/code><\/td>\nSigned greater than or equal<\/td>\n<\/tr>\n
NL<\/code><\/td>\nNot less than<\/td>\n<\/tr>\n
L<\/code><\/td>\nLess than<\/td>\n(SF ^ OF)<\/code><\/td>\nSigned less than<\/td>\n<\/tr>\n
NGE<\/code><\/td>\nNot greater than or equal<\/td>\n<\/tr>\n
LE<\/code><\/td>\nLess than or equal<\/td>\n(SF ^ OF) || ZF<\/code><\/td>\nSigned less than or equal<\/td>\n<\/tr>\n
NG<\/code><\/td>\nNot greater than<\/td>\n<\/tr>\n
S<\/code><\/td>\nSign<\/td>\nSF<\/code><\/td>\nNegative<\/td>\n<\/tr>\n
NS<\/code><\/td>\nNo sign<\/td>\n!SF<\/code><\/td>\nPositive or zero<\/td>\n<\/tr>\n
O<\/code><\/td>\nOverflow<\/td>\nOF<\/code><\/td>\nSigned overflow<\/td>\n<\/tr>\n
NO<\/code><\/td>\nNo overflow<\/td>\n!OF<\/code><\/td>\nNo signed overflow<\/td>\n<\/tr>\n
P<\/code><\/td>\nParity<\/td>\nPF<\/code><\/td>\nEven number of bits set<\/td>\n<\/tr>\n
PE<\/code><\/td>\nParity even<\/td>\n<\/tr>\n
NP<\/code><\/td>\nNo parity<\/td>\n!PF<\/code><\/td>\nOdd number of bits set<\/td>\n<\/tr>\n
PO<\/code><\/td>\nParity odd<\/td>\n<\/tr>\n<\/table>\n
The overflow and parity conditions are not normally used by C code. Note also that many flags are not testable via condition codes. (Poor auxiliary carry flag. Nobody loves you.) <\/p>\n
There are a few instructions for directly manipulating selected flags:<\/p>\n
\n    STC         ; set carry\n    CLC         ; clear carry\n    CMC         ; complement (toggle) carry\n\n    STD         ; set direction (go down)\n    CLD         ; clear direction (go up)\n<\/pre>\n
Controlling the interrupt flag is a privileged instruction, so you won’t see it in user-mode code. There are no instructions for directly manipulating the other flags, but you can manipulate them indirectly by performing an arithmetic operation with a known effect on flags. For example, you can force ZF<\/var> to be set by performing a calculation whose result is known to be zero, such as XOR EAX, EAX<\/code>. <\/p>\n
Okay, that was extremely boring, but it had to be done. Next time<\/a>, we’ll start doing arithmetic. <\/p>\n","protected":false},"excerpt":{"rendered":"
It’s just a bunch of stuff that happened.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[2],"class_list":["post-100765","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-history"],"acf":[],"blog_post_summary":"
It’s just a bunch of stuff that happened.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/100765","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=100765"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/100765\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=100765"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=100765"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=100765"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}