You can read more about the difference on Wikipedia<\/a>. There are some instructions which perform a combined addition and subtraction, and in that case, the only sane choice is to use true carry. (If you had chosen carry as borrow, then it wouldn’t be clear whether the final carry bit represented the carry from the addition or the borrow from subtraction.) <\/p>\nTo emphasize the fact that the PowerPC uses true carry, I will rewrite all subtractions as additions, taking advantage of the twos complement identity <\/p>\n
\n -x = ~x + 1\n<\/pre>\nOkay, now we can do some arithmetic. Let’s start with addition. <\/p>\n
\n add rd, ra, rb ; rd = ra + rb\n add. rd, ra, rb ; rd = ra + rb, update cr0\n addo rd, ra, rb ; rd = ra + rb, update XER overflow bits\n addo. rd, ra, rb ; rd = ra + rb, update cr0 and XER overflow bits\n<\/pre>\nThese instructions add two source registers and optionally update the xer<\/var> register to capture any possible overflow (by appending an o<\/code>), and also optionally update the cr0<\/var> register to reflect the sign of the result and any summary overflow (by appending a period). <\/p>\nI don’t know what they were thinking, using an easily-overlooked mark of punctuation to carry important information. <\/p>\n
There is also a version of the above instruction that takes a signed 16-bit immediate: <\/p>\n
\n addi rd, ra\/0, imm16 ; rd = ra\/0 + (int16_t)imm16\n<\/pre>\nNote that this variant does not accept o<\/code> or .<\/code> suffixes. <\/p>\nThe ra\/0<\/var> notation means “This can be any general purpose register, but if you ask for r0<\/var>, you actually get the constant zero.” The register r0<\/var> is weird like that. Sometimes it stands for itself, but sometimes it reads as zero. As a result, the r0<\/var> register isn’t used much. <\/p>\nThe assembler lets you write r0<\/var> through r31<\/var> as synonyms for the integers 0 through 31, so the following are equivalent: <\/p>\n\n add r3, r0, r4 ; r3 = r0 + r4\n add 3, 0, 4 ; r3 = r0 + r4\n add r3, r0, 4 ; r3 = r0 + r4\n<\/pre>\nThis can get very confusing. That last example sure looks like you’re setting r3<\/var> to r0<\/var> plus 4, but it’s not. The 4 is in a position where a register is expected, so it actually means r4<\/var>. <\/p>\nSimilarly, you might think you’re adding an immediate to r0<\/var> when you write <\/p>\n\n addi r3, r0, 256 ; r3 = r0 + 256, right?\n<\/pre>\nbut nope, the value of 0 as the second operand to addi<\/code> is interpreted as the constant zero, not register number zero. <\/p>\nFortunately, the Windows disassembler always calls registers by their mnemonic rather than by number. <\/p>\n
Wait, we’re not done with addition yet. <\/p>\n
\n ; add and set carry\n addc rd, ra, rb ; rd = ra + rb, update carry\n addc. rd, ra, rb ; rd = ra + rb, update carry and cr0\n addco rd, ra, rb ; rd = ra + rb, update carry and XER overflow bits\n addco. rd, ra, rb ; rd = ra + rb, update carry and cr0 and XER overflow bits\n<\/pre>\nThe “add and set carry” instructions act like the corresponding regular add instructions, except that the also update the carry bit in xer<\/var> based on whether a carry propagated out of the highest-order bit. <\/p>\n\n ; add extended\n adde rd, ra, rb ; rd = ra + rb + carry, update carry\n adde. rd, ra, rb ; rd = ra + rb + carry, update carry and cr0\n addeo rd, ra, rb ; rd = ra + rb + carry, update carry and XER overflow bits\n addeo. rd, ra, rb ; rd = ra + rb + carry, update carry and cr0 and XER overflow bits\n<\/pre>\nThe “add extended” instructions act like the corresponding “add and set carry” instructions, except that they also add 1 if the carry bit was set. This makes multiword addition convenient. <\/p>\n
\n ; add minus one extended\n addme rd, ra ; rd = ra + carry + ~0, update carry\n addme. rd, ra ; rd = ra + carry + ~0, update carry and cr0\n addmeo rd, ra ; rd = ra + carry + ~0, update carry and XER overflow bits\n addmeo. rd, ra ; rd = ra + carry + ~0, update carry and cr0 and XER overflow bits\n<\/pre>\nThe “add minus one extended” instruction is like “add extended” except that the second parameter is hard-coded to −1. I wrote ~0<\/code> instead of −1 to emphasize that we are using true carry. (This is the combined addition-and-subtraction instruction I alluded to at the top of the article. It adds carry and then subtracts one.) Added<\/b>: As commenter Neil noted below, through the magic of true carry, this is the same as “subtract zero extended”, which makes it handy for multiword arithmetic. <\/p>\n\n ; add zero extended\n addze rd, ra ; rd = ra + carry, update carry\n addze. rd, ra ; rd = ra + carry, update carry and cr0\n addzeo rd, ra ; rd = ra + carry, update carry and XER overflow bits\n addzeo. rd, ra ; rd = ra + carry, update carry and cr0 and XER overflow bits\n<\/pre>\nThe “add zero extended” instruction is like “add extended” except that the second parameter is hard-coded to zero. <\/p>\n
And then there are some instructions that take signed 16-bit immediates: <\/p>\n
\n ; add immediate shifted\n addis rd, ra\/0, imm16 ; rd = ra\/0 + (imm16 << 16)\n\n ; add immediate and set carry\n addic rd, ra, imm16 ; rd = ra + (int16_t)imm16, update carry\n\n ; add immediate and set carry and update cr0\n addic. rd, ra, imm16 ; rd = ra + (int16_t)imm16, update carry and cr0\n<\/pre>\nPhew, that was addition. There are also subtraction instructions, which should look mostly familiar now that you’ve seen addition. <\/p>\n
\n ; subtract from\n subf rd, ra, rb ; rd = ~ra + rb + 1\n subf. rd, ra, rb ; rd = ~ra + rb + 1, update cr0\n subfo rd, ra, rb ; rd = ~ra + rb + 1, update XER overflow bits\n subfo. rd, ra, rb ; rd = ~ra + rb + 1, update cr0 and XER overflow bits\n\n ; subtract from and set carry\n subfc rd, ra, rb ; rd = ~ra + rb + 1, update carry\n subfc. rd, ra, rb ; rd = ~ra + rb + 1, update carry and cr0\n subfco rd, ra, rb ; rd = ~ra + rb + 1, update carry and XER overflow bits\n subfco. rd, ra, rb ; rd = ~ra + rb + 1, update carry and cr0 and XER overflow bits\n\n ; subtract from extended\n subfe rd, ra, rb ; rd = ~ra + rb + carry, update carry\n subfe. rd, ra, rb ; rd = ~ra + rb + carry, update carry and cr0\n subfeo rd, ra, rb ; rd = ~ra + rb + carry, update carry and XER overflow bits\n subfeo. rd, ra, rb ; rd = ~ra + rb + carry, update carry and cr0 and XER overflow bits\n\n ; subtract from minus one extended\n subfme rd, ra ; rd = ~ra + carry + ~0, update carry\n subfme. rd, ra ; rd = ~ra + carry + ~0, update carry and cr0\n subfmeo rd, ra ; rd = ~ra + carry + ~0, update carry and XER overflow bits\n subfmeo. rd, ra ; rd = ~ra + carry + ~0, update carry and cr0 and XER overflow bits\n\n ; subtract from zero extended\n subfze rd, ra ; rd = ~ra + carry, update carry\n subfze. rd, ra ; rd = ~ra + carry, update carry and cr0\n subfzeo rd, ra ; rd = ~ra + carry, update carry and XER overflow bits\n subfzeo. rd, ra ; rd = ~ra + carry, update carry and cr0 and XER overflow bits\n\n ; subtract from immediate and set carry\n subfic rd, ra, imm16 ; rd = ~ra + (int16_t)imm16 + 1, update carry\n<\/pre>\nNote that the instruction is “subtract from”, not “subtract”. The second operand is subtracted from the third operand; in other words, the two operands are backwards. Fortunately, the assembler provides a family of synthetic instructions that simply swap the last two operands: <\/p>\n
\n subf rd, rb, ra ; sub rd, ra, rb\n ; similarly \"sub.\", \"subo\", and \"subo.\".\n\n subfc rd, rb, ra ; subc rd, ra, rb\n ; similarly \"subc.\", \"subco\", and \"subco.\".\n<\/pre>\nSecond problem is that there is no subfis<\/code> to subtract a shifted immediate, nor is there subfic.<\/code> to update flags after subtracting from an immediate. But the assembler can synthesize those too: <\/p>\n\n addi rd, ra\/0, -imm16 ; subi rd, ra\/0, imm16\n addis rd, ra\/0, -imm16 ; subis rd, ra\/0, imm16\n addic rd, ra, -imm16 ; subic rd, ra, imm16\n addic. rd, ra, -imm16 ; subic. rd, ra, imm16\n<\/pre>\nPowerPC’s use of true carry allows this trick to work while still preserving the semantics of carry and overflow. <\/p>\n
We wrap up with multiplication and division. <\/p>\n
\n ; multiply low immediate\n mulli rd, ra, imm16 ; rd = (int32_t)ra * (int16_t)imm16\n\n ; multiply low word\n mullw rd, ra, rb ; rd = (int32_t)ra * (int32_t)rb\n ; also \"mullw.\", \"mullwo\", and \"mullwo.\".\n\n ; multiply high word\n mulhw rd, ra, rb ; rd = ((int32_t)ra * (int32_t)rb) >> 32\n ; also \"mulhw.\"\n\n ; multiply high word unsigned\n mulhwu rd, ra, rb ; rd = ((uint32_t)ra * (uint32_t)rb) >> 32\n ; also \"mulhwu.\"\n<\/pre>\nThe “multiply low” instructions perform the multiplication and return the low-order 32 bits. The “multiply high” instructions return the high-order 32 bits. <\/p>\n
Finally, we have division: <\/p>\n
\n ; divide word\n divw rd, ra, rb ; rd = (int32_t)ra ÷ (int32_t)rb\n ; also \"divw.\", \"divwo\", and \"divwo.\".\n\n ; divide word unsigned\n divwu rd, ra, rb ; rd = (uint32_t)ra ÷ (uint32_t)rb\n ; also \"divwu.\", \"divwuo\", and \"divwuo.\".\n<\/pre>\nIf you try to divide by zero or (for divw<\/code>) if you try to divide 0x80000000<\/code> by −1, then the results are garbage, and if you used the o<\/code> version of the instruction, then the overflow flag is set. No trap is generated. (If you didn’t use the o<\/code> version, then you get no indication that anything went wrong. You just get garbage.) <\/p>\nThere is no modulus instruction. If you want to get the remainder, take the quotient, multiple it by the divisor, and subtract it from the dividend. <\/p>\n
Okay, that was arithmetic. Next up<\/a> are the bitwise logical operators and combining arithmetic and logical operators to load constants. <\/p>\nBonus snark<\/b>: For a reduced instruction set computer, it sure has an awful lot of instructions. And we haven’t even gotten to control flow yet. <\/p>\n","protected":false},"excerpt":{"rendered":"
Who knew there were so many ways to add numbers.<\/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-99445","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-history"],"acf":[],"blog_post_summary":"
Who knew there were so many ways to add numbers.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/99445","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=99445"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/99445\/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=99445"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=99445"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=99445"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}