Index

Modules: intops, intops/consts, intops/impl/inlineasm, intops/impl/inlineasm/arm64, intops/impl/inlineasm/x86, intops/impl/inlinec, intops/impl/intrinsics, intops/impl/intrinsics/gcc, intops/impl/intrinsics/x86, intops/impl/pure, intops/ops/add, intops/ops/composite, intops/ops/division, intops/ops/mul, intops/ops/muladd, intops/ops/sub.

API symbols

borrowingSub:

• x86: proc borrowingSub(a, b: int32; borrowIn: bool): (int32, bool)
• x86: proc borrowingSub(a, b: int64; borrowIn: bool): (int64, bool)
• x86: proc borrowingSub(a, b: uint32; borrowIn: bool): (uint32, bool)
• x86: proc borrowingSub(a, b: uint64; borrowIn: bool): (uint64, bool)
• inlinec: proc borrowingSub(a, b: uint64; borrowIn: bool): (uint64, bool)
• gcc: proc borrowingSub[T: SomeInteger](a, b: T; borrowIn: bool): (T, bool)
• x86: proc borrowingSub(a, b: uint32; borrowIn: bool): (uint32, bool)
• x86: proc borrowingSub(a, b: uint64; borrowIn: bool): (uint64, bool)
• pure: proc borrowingSub[T: SomeUnsignedInt](a, b: T; borrowIn: bool): (T, bool)
• pure: proc borrowingSub[T: SomeSignedInt](a, b: T; borrowIn: bool): (T, bool)
• sub: template borrowingSub(a, b: int32; borrowIn: bool): (int32, bool)
• sub: template borrowingSub(a, b: int64; borrowIn: bool): tuple[res: int64, borrowOut: bool]
• sub: template borrowingSub(a, b: uint32; borrowIn: bool): tuple[res: uint32, borrowOut: bool]
• sub: template borrowingSub(a, b: uint64; borrowIn: bool): tuple[res: uint64, borrowOut: bool]

builtinBorrowingSub:

• x86: proc builtinBorrowingSub(borrowIn: uint8; a, b: uint32; res: var uint32): uint8
• x86: proc builtinBorrowingSub(borrowIn: uint8; a, b: uint64; res: var uint64): uint8

builtinCarryingAdd:

• x86: proc builtinCarryingAdd(carryIn: uint8; a, b: uint32; res: var uint32): uint8
• x86: proc builtinCarryingAdd(carryIn: uint8; a, b: uint64; res: var uint64): uint8

builtinNarrowingDiv:

• x86: proc builtinNarrowingDiv(uHi, uLo, v: uint64; r: var uint64): uint64

builtinOverflowingAdd:

• gcc: proc builtinOverflowingAdd[T: SomeInteger](a, b: T; res: var T): bool

builtinOverflowingSub:

• gcc: proc builtinOverflowingSub[T: SomeInteger](a, b: T; res: var T): bool

canUseInlineAsm:

• consts: const canUseInlineAsm

canUseInlineC:

• consts: const canUseInlineC

canUseIntrinsics:

• consts: const canUseIntrinsics

carryingAdd:

• x86: proc carryingAdd(a, b: int32; carryIn: bool): (int32, bool)
• x86: proc carryingAdd(a, b: int64; carryIn: bool): (int64, bool)
• x86: proc carryingAdd(a, b: uint32; carryIn: bool): (uint32, bool)
• x86: proc carryingAdd(a, b: uint64; carryIn: bool): (uint64, bool)
• inlinec: proc carryingAdd(a, b: uint64; carryIn: bool): (uint64, bool)
• gcc: proc carryingAdd[T: SomeInteger](a, b: T; carryIn: bool): (T, bool)
• x86: proc carryingAdd(a, b: uint32; carryIn: bool): (uint32, bool)
• x86: proc carryingAdd(a, b: uint64; carryIn: bool): (uint64, bool)
• pure: proc carryingAdd[T: SomeUnsignedInt](a, b: T; carryIn: bool): (T, bool)
• pure: proc carryingAdd[T: SomeSignedInt](a, b: T; carryIn: bool): (T, bool)
• add: template carryingAdd(a, b: int32; carryIn: bool): tuple[res: int32, carryOut: bool]
• add: template carryingAdd(a, b: int64; carryIn: bool): tuple[res: int64, carryOut: bool]
• add: template carryingAdd(a, b: uint32; carryIn: bool): tuple[res: uint32, carryOut: bool]
• add: template carryingAdd(a, b: uint64; carryIn: bool): tuple[res: uint64, carryOut: bool]

compilerGccCompatible:

• consts: const compilerGccCompatible

compilerMsvc:

• consts: const compilerMsvc

cpu64Bit:

• consts: const cpu64Bit

cpuArm64:

• consts: const cpuArm64

cpuX86:

• consts: const cpuX86

mulAcc:

• pure: proc mulAcc[T: uint64 | uint32](t, u, v: T; a, b: T): (T, T, T)
• composite: proc mulAcc[T: uint64 | uint32](t, u, v: T; a, b: T): tuple[t, u, v: T]

mulDoubleAdd2:

• pure: proc mulDoubleAdd2[T: uint64 | uint32](a, b, c, dHi, dLo: T): (T, T, T)
• composite: template mulDoubleAdd2[T: uint64 | uint32](a, b, c, dHi, dLo: T): tuple[t2, r1, r0: T]

narrowingDiv:

• x86: proc narrowingDiv(uHi, uLo, v: uint64): (uint64, uint64)
• inlinec: proc narrowingDiv(uHi, uLo, v: uint64): (uint64, uint64)
• x86: proc narrowingDiv(uHi, uLo, v: uint64): (uint64, uint64)
• pure: proc narrowingDiv(uHi, uLo, v: uint64): (uint64, uint64)
• division: template narrowingDiv(uHi, uLo, v: uint64): tuple[q, r: uint64]

overflowingAdd:

• gcc: proc overflowingAdd[T: SomeInteger](a, b: T): (T, bool)
• pure: proc overflowingAdd[T: SomeUnsignedInt](a, b: T): (T, bool)
• pure: proc overflowingAdd[T: SomeSignedInt](a, b: T): (T, bool)
• add: template overflowingAdd[T: SomeInteger](a, b: T): tuple[res: T, didOverflow: bool]

overflowingSub:

• gcc: proc overflowingSub[T: SomeInteger](a, b: T): (T, bool)
• pure: proc overflowingSub[T: SomeUnsignedInt](a, b: T): (T, bool)
• pure: proc overflowingSub[T: SomeSignedInt](a, b: T): (T, bool)
• sub: template overflowingSub[T: SomeInteger](a, b: T): tuple[res: T, didOverflow: bool]

saturatingAdd:

• gcc: proc saturatingAdd[T: SomeUnsignedInt](a, b: T): T
• gcc: proc saturatingAdd[T: SomeSignedInt](a, b: T): T
• pure: proc saturatingAdd[T: SomeUnsignedInt](a, b: T): T
• pure: proc saturatingAdd[T: SomeSignedInt](a, b: T): T
• add: template saturatingAdd[T: SomeInteger](a, b: T): T

saturatingSub:

• gcc: proc saturatingSub[T: SomeUnsignedInt](a, b: T): T
• gcc: proc saturatingSub[T: SomeSignedInt](a, b: T): T
• pure: proc saturatingSub[T: SomeUnsignedInt](a, b: T): T
• pure: proc saturatingSub[T: SomeSignedInt](a, b: T): T
• sub: template saturatingSub[T: SomeInteger](a, b: T): T

wideningMul:

• inlinec: proc wideningMul(a, b: int64): (int64, uint64)
• inlinec: proc wideningMul(a, b: uint64): (uint64, uint64)
• pure: proc wideningMul(a, b: int32): (int32, uint32)
• pure: proc wideningMul(a, b: int64): (int64, uint64)
• pure: proc wideningMul(a, b: uint32): (uint32, uint32)
• pure: proc wideningMul(a, b: uint64): (uint64, uint64)
• mul: template wideningMul(a, b: int32): tuple[hi: int32, lo: uint32]
• mul: template wideningMul(a, b: int64): tuple[hi: int64, lo: uint64]
• mul: template wideningMul(a, b: uint32): tuple[hi, lo: uint32]
• mul: template wideningMul(a, b: uint64): tuple[hi, lo: uint64]

wideningMulAdd:

• inlinec: proc wideningMulAdd(a, b, c: uint64): (uint64, uint64)
• inlinec: proc wideningMulAdd(a, b, c, d: uint64): (uint64, uint64)
• pure: proc wideningMulAdd(a, b, c: uint64): (uint64, uint64)
• pure: proc wideningMulAdd(a, b, c, d: uint64): (uint64, uint64)
• muladd: template wideningMulAdd(a, b, c: uint64): tuple[hi, lo: uint64]
• muladd: template wideningMulAdd(a, b, c, d: uint64): tuple[hi, lo: uint64]