Carry flag

The carry flag (often abbreviated as CF) is a single-bit flag in a processor's status register that signals whether an arithmetic operation, such as addition or subtraction, has produced a carry-out from the most significant bit (MSB) or required a borrow-in for the operation, primarily serving to detect overflow in unsigned integer arithmetic.^[1] This flag is essential for handling multi-precision arithmetic, where it propagates carry or borrow values between successive operations to compute results larger than a single register can hold.^[1] In the x86 architecture, the carry flag occupies bit 0 of the EFLAGS or RFLAGS register and is set to 1 upon a carry-out during instructions like ADD or ADC, cleared to 0 otherwise, and can be explicitly manipulated using instructions such as STC (set), CLC (clear), or CMC (complement).^[1] It distinguishes itself from the overflow flag (OF), which handles signed integer overflow, enabling conditional jumps (e.g., JC for jump if carry) that support efficient unsigned comparisons and loop controls in assembly language programming.^[1] Similarly, in ARM architectures, the carry flag in the application program status register (APSR) is set to 1 on addition if an unsigned overflow occurs or on subtraction if no borrow is needed, and it also captures the last bit shifted out in shift operations, facilitating conditional execution of instructions based on arithmetic outcomes.^[2] The carry flag's role extends to bit manipulation instructions like shifts (SHL, SHR) and rotates (ROL, ROR), where it stores overflow bits to enable precise control in low-level operations, and it remains a foundational element in CPU design across architectures for ensuring arithmetic integrity without software intervention.^[1]^[2]

Fundamentals

Definition

The carry flag (CF), also known as the C flag in some architectures, is a single-bit status flag within a processor's flags register that indicates a carry-out from the most significant bit (MSB) position during unsigned arithmetic operations, such as addition, or during certain bit manipulation instructions like shifts and rotates.^[3]^[4] In the x86 architecture, for instance, the carry flag occupies bit 0 of the EFLAGS register and is set to 1 when a carry occurs from the MSB or a borrow is required into the MSB for subtraction, while it is cleared to 0 otherwise.^[3] Similarly, in ARM architectures, the carry flag is part of the application program status register (APSR) and reflects carry conditions from arithmetic instructions.^[4] Its primary purpose is to detect overflow in unsigned integer operations, signaling when the result cannot be fully represented within the operand's bit width and requires an additional bit.^[3] For example, in an 8-bit unsigned addition, if the sum exceeds 255 (the maximum value representable in 8 bits), a carry-out into a hypothetical 9th bit sets the flag to 1, enabling software to handle the overflow appropriately, such as in multi-precision arithmetic.^[3] This mechanism is essential for maintaining accuracy in computations involving unsigned values across various processor designs. In terms of binary mechanics, for an n-bit addition of two operands, the carry flag is set to 1 if a carry propagates out of the MSB, indicating the sum necessitates an (n+1)th bit to represent it fully.^[3] Consider a 4-bit example: adding 1011₂ (decimal 11) and 0101₂ (decimal 5) produces 10000₂ (decimal 16), where the leading 1 beyond the 4 bits sets the carry flag to 1.^[3] This flag's behavior is consistent in its role for detecting such carry-outs, though its exact setting conditions may vary slightly by instruction and architecture.^[4]

Binary Representation

In x86 architecture, the carry flag (CF) is encoded as the least significant bit, designated as bit 0, of the EFLAGS or RFLAGS register; bit positions vary by architecture. It is set to 1 to indicate the generation of a carry out from the most significant bit during an arithmetic operation and cleared to 0 in the absence of such a carry.^[3] In x86-like architectures, dedicated instructions enable explicit manipulation of the carry flag, including STC (opcode F9) to set CF to 1, CLC (opcode F8) to clear CF to 0, and CMC (opcode F5) to complement its current value by toggling between 0 and 1.^[3] The carry flag interacts with the flags register, also known as the status word, through automatic updates following specific operations. For instance, arithmetic instructions such as ADD set or clear CF based on whether a carry out occurs from the most significant bit, whereas non-arithmetic instructions like MOV leave CF unchanged. In addition operations, CF can be conceptually determined as follows: if the sum of the source and destination operands exceeds the maximum unsigned value for the operand size (2^n - 1 for n bits), then CF ← 1; otherwise, CF ← 0.^[3] Software visibility into the carry flag is provided via instructions that save or restore the entire flags register, such as PUSHF to push it onto the stack and POPF to pop and restore it, or through direct testing in assembly language using conditional jumps like JC (jump if carry) or JNC (jump if no carry).^[3]

Arithmetic Applications

Addition Operations

In binary addition within computer processors, the carry flag is set to 1 if the sum of two n-bit unsigned operands exceeds $2^n - 1, indicating an overflow for unsigned arithmetic that requires handling beyond the n-bit width.^[5] This occurs specifically when a carry-out is generated from the most significant bit (MSB) during the addition.^[6] The mechanics of carry generation rely on a ripple-carry adder structure, where addition propagates from the least significant bit (LSB) to the MSB. Each bit position employs a full adder that takes two operand bits and an incoming carry-in, producing a sum bit and a carry-out to the next position. The carry ripples sequentially: if the sum at any bit exceeds 1 (considering the carry-in), it sets the carry-out to 1, potentially propagating through higher bits until reaching the MSB.^[7] The carry-out from the MSB, which sets the carry flag, follows the full adder logic:

CF = (A_{n-1} \land B_{n-1}) \lor ((A_{n-1} \oplus B_{n-1}) \land C_{n-1})

where A_{n-1} and B_{n-1} are the MSBs of the operands, and C_{n-1} is the carry-in to the MSB.^[8] For instance, in an 8-bit addition of 255 ($11111111_2) and 1 ($00000001_2), the result is 256, which modulo $2^8 yields $00000000_2 with a carry-out of 1 from the MSB, thus setting the carry flag.^[5] This flag enables efficient multi-byte addition in unsigned arithmetic, as seen in instructions like ADC (Add with Carry), which adds the operands plus the current carry flag value as carry-in to the LSB, facilitating chained operations for larger integers across multiple registers or memory words.^[9]

Subtraction and Multi-Precision

In subtraction operations within computer architectures, the carry flag (CF) functions as a borrow indicator for unsigned arithmetic. Specifically, when performing a subtraction using the SUB instruction, CF is set to 1 if the subtrahend (source operand) is greater than the minuend (destination operand), indicating that a borrow was required from a higher significance bit; otherwise, it is cleared to 0.^[3] This behavior arises because subtraction in two's complement representation is implemented as the addition of the two's complement negation of the subtrahend, where the borrow corresponds to a carry out from the most significant bit during this addition.^[10] For example, consider an 8-bit unsigned subtraction of 10 (binary 00001010) from 5 (binary 00000101). The operation yields a result of 11111011 (decimal 251 in unsigned interpretation), and CF is set to 1 because 5 < 10, requiring a borrow.^[11] In general, for unsigned operands A and B, CF = 1 if A < B after subtraction, which is logically equivalent to the negation of (A ≥ B).^[3] The carry flag also plays a crucial role in multi-precision arithmetic, where it propagates borrows across multiple limbs (fixed-width portions of larger operands) to enable operations on numbers exceeding the processor's native word size. This is typically achieved using the SBB (Subtract with Borrow) instruction, which subtracts the source operand plus the current value of CF from the destination: DEST ← DEST - (SRC + CF), setting CF based on whether an additional borrow is needed.^[3] For instance, to subtract two 64-bit unsigned integers on a 32-bit architecture, the least significant 32 bits are subtracted first with SUB (setting CF if a borrow occurs), followed by SBB on the most significant 32 bits to incorporate and propagate the borrow from the lower limb.^[3] This chaining mechanism ensures accurate handling of large integers without native support for wider operands.

Architectural Implementations

x86 Family

In the x86 architecture, the carry flag (CF) resides at bit 0 of the FLAGS register in 16-bit mode, the EFLAGS register in 32-bit mode, and the RFLAGS register in 64-bit mode.^[9] This positioning allows CF to indicate carry-out from the most significant bit during arithmetic operations or serve as an input for multi-precision computations across all operating modes, including real, protected, virtual-8086, and long (64-bit).^[9] Key instructions that update CF include ADD, which sets the flag if there is a carry-out from the most significant bit of the result (indicating unsigned overflow), and ADC, which adds the source operand, destination operand, and the current CF value, setting CF if a carry-out occurs from the most significant bit.^[9] Similarly, SUB sets CF if the destination is smaller than the source for unsigned operands (indicating a borrow), while SBB subtracts the source and the current CF from the destination, setting CF if a borrow is required.^[9] Rotation instructions such as RCL (rotate left through carry) and RCR (rotate right through carry) treat CF as an extension of the operand, setting it to the bit shifted out of the most significant position or the previous CF value, depending on the rotation count.^[9] Conditional jumps based on CF include JC (jump if carry), which branches if CF is 1, and JNC (jump if no carry), which branches if CF is 0; these are commonly used in loops for multi-precision arithmetic, such as adding or subtracting numbers larger than the register size by propagating the carry or borrow across iterations.^[9] The carry flag mechanism was introduced with the Intel 8086 microprocessor, released on June 8, 1978, as part of its 16-bit FLAGS register to support unsigned arithmetic and bit manipulation.^[12]^[13] In modern x86-64 implementations, CF behavior remains consistent and size-specific: for example, a 32-bit ADD operation in 64-bit mode sets CF based on carry-out from bit 31 of the lower 32 bits, unaffected by the upper 32 bits of the 64-bit register, ensuring compatibility while allowing operand-size overrides via prefixes.^[9]

Other Instruction Sets

In the ARM architecture, the carry flag is implemented as the C bit (bit 29) in the Application Program Status Register (APSR), which is set to 1 when an instruction results in a carry condition, such as unsigned overflow during addition.^[14] This flag supports instructions like ADDS, which performs addition and updates the flags including C based on the result, and ADCS, which adds two operands along with the existing C flag value while setting the flags for the subsequent operation.^[15]^[16] RISC-V's base integer instruction set lacks a dedicated carry flag, relying instead on separate instructions to detect and propagate carry for multi-precision arithmetic. Carry detection typically uses the SLTU (set less than unsigned) instruction to check if the sum of two operands exceeds the first operand, effectively identifying overflow as a carry out. Extensions such as Zba (bit manipulation for address generation) provide instructions like add.uw that can assist in certain operations but do not introduce a persistent flag; add-with-carry operations are handled implicitly through sequencing multiple instructions or control/status registers (CSRs) in extended configurations. As of 2025, proposals for dedicated carry handling extensions, such as for multi-word arithmetic, remain under development but have not been ratified.^[17]^[18] The MIPS architecture omits a dedicated carry flag entirely, simulating carry handling through temporary registers and comparison instructions for multi-word operations.^[19] Specifically, the SLTU instruction sets a register to 1 if the first operand is less than the second under unsigned interpretation, enabling carry detection in addition (e.g., by comparing the sum against one operand) and borrow simulation in subtraction without altering a global flag state.^[19] Variations across other instruction sets highlight design trade-offs in flag management. In PowerPC, the carry (CA) bit resides in the XER special-purpose register and is updated by arithmetic instructions like ADD and SUBF to indicate unsigned overflow or borrow, while the summary overflow (SO) bit in CR0 (condition register field 0) latches overflow conditions persistently until cleared.^[20] Some RISC architectures merge carry and borrow semantics into a single bit for simplicity, as seen in PowerPC's unified handling, whereas others like MIPS and base RISC-V omit flags altogether to reduce hardware complexity and favor explicit register-based propagation.^[20]^[17] Portability challenges arise in flag-less architectures, where software must emulate carry propagation using additional instructions, often resulting in higher instruction counts and performance overhead compared to flag-supported designs. This emulation is essential for applications requiring big-integer operations.

Versus Borrow Flag

In many processor architectures, the carry flag serves a dual role in arithmetic operations, functioning as a borrow indicator during subtraction to facilitate multi-precision computations. For instance, in the x86 architecture, the carry flag (CF) is set to 1 when a subtraction (SUB) requires a borrow from a higher significant bit position, meaning the unsigned value of the destination operand is less than that of the source operand. This same flag is then used as an input for the subtract with borrow (SBB) instruction, which subtracts the source operand plus the CF value (1 for borrow pending, 0 otherwise) from the destination, enabling chained multi-word subtractions.^[21] This duality contrasts with architectures that employ a dedicated extend or borrow flag separate from the primary carry flag, though such designs are relatively uncommon due to the added hardware overhead of maintaining additional status bits. In the Motorola 68000 family, for example, the carry flag (C) indicates borrow during single-precision subtractions (e.g., SUB, CMP), set to 1 if a borrow occurs into the most significant bit.^[22] However, a distinct extend flag (X) is provided for multi-precision operations, mirroring C in most arithmetic instructions but persisting independently to propagate borrow across multiple words in instructions like SUBX (subtract extended).^[22] Not all instructions update both flags equally; for instance, certain shifts or logical operations may affect C without altering X, allowing finer control in borrow-only scenarios where no carry-in from prior additions is involved.^[22] The polarity of the borrow indication can also vary, introducing conceptual overlap but operational differences. In ARM architectures, the carry flag (C) is cleared (0) when a subtraction generates a borrow, effectively inverting the x86 convention where CF=1 signals borrow; instead, C=1 denotes no borrow, optimizing condition code usage for conditional execution.^[2] Dedicated borrow flags remain rare outside specialized designs like certain digital signal processors (DSPs), where separate flags may reduce logic complexity for signal processing tasks but increase register size—trading simplicity for precision in borrow propagation.^[23]

Versus Overflow Flag

The carry flag (CF) and overflow flag (OF) provide distinct mechanisms for detecting arithmetic overflow in binary operations, tailored to different number interpretations. The CF signals unsigned overflow by capturing a carry out from the most significant bit (MSB) during addition, indicating that the result has wrapped around modulo $2^n for an n-bit operand, without regard to sign. In contrast, the OF detects signed overflow in two's complement representation, flagging inconsistencies where the sign bit of the result does not align with the expected outcome for signed operands—specifically, when two positive numbers sum to a negative result or two negative numbers sum to a positive one.^[3]^[5] For addition, the OF is computed as the exclusive OR of the carry into the sign bit and the carry out from the sign bit:

OF = C_{in}^{n-1} \oplus C_{out}^{n-1}

where C_{in}^{n-1} is the carry generated into the MSB position from the lower bits, and C_{out}^{n-1} is the carry generated out of the MSB. This formulation identifies signed overflow precisely because it highlights a discrepancy in carry propagation at the sign position, which would not occur in valid signed arithmetic. The CF, however, is simply set to C_{out}^{n-1}, ignoring any sign-specific carry analysis.^[3]^[5] In an 8-bit signed addition, +127 ($01111111_2) + 1 ($00000001_2) produces $10000000_2 (-128), with no carry out (CF = 0) but a carry into the sign bit differing from the carry out (OF = 1), confirming signed overflow as the positive sum exceeds the maximum representable value of +127. For unsigned interpretation of the same bits, 255 ($11111111_2) + 1 ($00000001_2) yields $00000000_2 with carry out (CF = 1), but the carries into and out of the sign bit match (OF = 0), as the signed values -1 + 1 = 0 stay within bounds.^[3]^[5] The CF supports unsigned use cases like validating loop iterations or detecting modular wraparound in counters, where exceeding $2^n - 1 requires handling the modulo behavior. The OF is critical for signed validations, such as in algebraic computations or data processing, to prevent erroneous sign changes that could lead to incorrect results. Conditional instructions leverage both, with CF enabling jumps for unsigned conditions and OF for signed overflow checks, like JO (jump if overflow).^[3]