Arithmetic and logic operations. More...

#include <stdint.h>
#include <stdbool.h>
#include "core.h"
#include "sreg_utils.h"

Include dependency graph for arithm_logic.h:

This graph shows which files directly or indirectly include this file:

Functions
void	add (uint8_t d, uint8_t r, struct CORE *core)
	Add without carry.

void	adc (uint8_t d, uint8_t r, struct CORE *core)
	Add with carry.

void	adiw (uint8_t d, uint8_t K, struct CORE *core)
	Add immediate to word.

void	sub (uint8_t d, uint8_t r, struct CORE *core)
	Subtract.

void	subi (uint8_t d, uint8_t K, struct CORE *core)
	Subtract immediate.

void	sbc (uint8_t d, uint8_t r, struct CORE *core)
	Subtract with carry.

void	sbci (uint8_t d, uint8_t K, struct CORE *core)
	Subtract immediate with carry.

void	sbiw (uint8_t d, uint8_t K, struct CORE *core)
	Subtract immediate from word.

void	and (uint8_t d, uint8_t r, struct CORE *core)
	Logical AND.

void	andi (uint8_t d, uint8_t K, struct CORE *core)
	Logical AND with immediate.

void	or (uint8_t d, uint8_t r, struct CORE *core)
	Logical OR.

void	ori (uint8_t d, uint8_t K, struct CORE *core)
	Logical OR with immediate.

void	eor (uint8_t d, uint8_t r, struct CORE *core)
	Perform bitwise exclusive OR between two registers.

void	com (uint8_t d, struct CORE *core)
	Perform one's complement on a register.

void	neg (uint8_t d, struct CORE *core)
	Perform two's complement (negation) on a register.

void	sbr (uint8_t d, uint8_t K, struct CORE *core)
	Set bits in a register.

void	cbr (uint8_t d, uint8_t K, struct CORE *core)
	Clear bits in a register.

void	inc (uint8_t d, struct CORE *core)
	Increment the value of a register.

void	dec (uint8_t d, struct CORE *core)
	Decrement the value of a register.

void	tst (uint8_t d, struct CORE *core)
	Test for zero or minus after AND operation.

void	clr (uint8_t d, struct CORE *core)
	Clear a register (set to zero).

void	ser (uint8_t d, struct CORE *core)
	Set all bits in a register.

void	mul (uint8_t d, uint8_t r, struct CORE *core)
	Multiplies two unsigned 8-bit integers and stores the result in the CORE structure.

void	muls (uint8_t d, uint8_t r, struct CORE *core)
	Multiplies two signed 8-bit integers and stores the result in the CORE structure.

void	mulsu (uint8_t d, uint8_t r, struct CORE *core)
	Multiplies a signed 8-bit integer with an unsigned 8-bit integer and stores the result in the CORE structure.

void	fmul (uint8_t d, uint8_t r, struct CORE *core)
	Multiplies two unsigned 8-bit integers with fractional representation and stores the result in the CORE structure.

void	fmuls (uint8_t d, uint8_t r, struct CORE *core)
	Multiplies two signed 8-bit integers with fractional representation and stores the result in the CORE structure.

void	fmulsu (uint8_t d, uint8_t r, struct CORE *core)
	Multiplies a signed 8-bit integer with an unsigned 8-bit integer with fractional representation and stores the result in the CORE structure.

Detailed Description

Arithmetic and logic operations.

Contains all atomic arithmetic and logic operations

Author: Antonin Pivard

Date: 2024

Warning: Not tested

Copyright: GNU General Public License v3.0

Definition in file arithm_logic.h.

Function Documentation

◆ adc()

void adc	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Add with carry.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 19 of file arithm_logic.c.

                                                  {
    // Add with cary
    // Rd <- Rd + Rr + C
    // 1 cycle
 
    uint8_t R_tmp = core->gp.R[d];
 
    // Execute instruction
    core->gp.R[d] = core->gp.R[d] + core->gp.R[r] + core->sreg.C;
 
    // Update SREG
    update_sreg_arithm(core, R_tmp, core->gp.R[r], core->gp.R[d]);
 
    inc_pc(core);
}

References SREG::C, CORE::gp, inc_pc(), GP::R, CORE::sreg, and update_sreg_arithm().

◆ add()

void add	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Add without carry.

Parameters

d	Destination register index
r	Source register index
core	Pointer to the CORE structure

Definition at line 3 of file arithm_logic.c.

                                                  {
    // Add without carry
    // Rd <- Rd + Rr
    // 1 cycle
    
    uint8_t R_tmp = core->gp.R[d];
 
    // Execute instruction
    core->gp.R[d] = core->gp.R[d] + core->gp.R[r];
 
    // Update SREG
    update_sreg_arithm(core, R_tmp, core->gp.R[r], core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_arithm().

◆ adiw()

void adiw	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Add immediate to word.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 35 of file arithm_logic.c.

                                                   {
    // Add immediate to word
    // Rd:Rd+1 <- Rd:Rd+1 + K
    // 2 cycle
 
    // Execute instruction 
    uint16_t Rd = core->gp.R[d] | (core->gp.R[d + 1] << 8);
    uint16_t result = Rd + K;
    core->gp.R[d] = result & 0xFF;
    core->gp.R[d + 1] = (result >> 8) & 0xFF;
 
    // Update SREG
    udpate_sreg_arithm_16bit(core, Rd, result);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and udpate_sreg_arithm_16bit().

◆ and()

void and	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Logical AND.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 133 of file arithm_logic.c.

                                                  {
    // Logical AND
    // Rd <- Rd & Rr
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] & core->gp.R[r];
 
    // Update SREG
    update_sreg_logic(core, core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_logic().

◆ andi()

void andi	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Logical AND with immediate.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 147 of file arithm_logic.c.

                                                   {
    // Logical AND with immediate
    // Rd <- Rd & K
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] & K;
 
    // Update SREG
    update_sreg_logic(core, core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_logic().

◆ cbr()

void cbr	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Clear bits in a register.

Parameters

d	Destination register.
K	Constant value to clear bits.
core	Pointer to the CORE structure.

Definition at line 238 of file arithm_logic.c.

                                                  {
    // Clear Bit in Register
    // Rd <- Rd & ($FF - K)
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] & ~K;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ clr()

void clr	(	uint8_t	d,
		struct CORE *	core
	)

Clear a register (set to zero).

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 278 of file arithm_logic.c.

                                       {
    // Clear Register
    // Rd <- 0
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = 0;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ com()

void com	(	uint8_t	d,
		struct CORE *	core
	)

Perform one's complement on a register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 203 of file arithm_logic.c.

                                       {
    // Logical Complement
    // Rd <- $FF - Rd
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = ~core->gp.R[d];
 
    // Update SREG
    update_sreg_logic(core, core->gp.R[d]);
    update_sreg_C(core, true);
    
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, update_sreg_C(), and update_sreg_logic().

◆ dec()

void dec	(	uint8_t	d,
		struct CORE *	core
	)

Decrement the value of a register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 258 of file arithm_logic.c.

                                       {
    // Decrement
    // Rd <- Rd - 1
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] - 1;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ eor()

void eor	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Perform bitwise exclusive OR between two registers.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 189 of file arithm_logic.c.

                                                  {
    // Logical Exclusive OR
    // Rd <- Rd ^ Rr
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] ^ core->gp.R[r];
 
    // Update SREG
    update_sreg_logic(core, core->gp.R[d]);
    
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_logic().

◆ fmul()

void fmul	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Multiplies two unsigned 8-bit integers with fractional representation and stores the result in the CORE structure.

Parameters

d	First operand.
r	Second operand.
core	Pointer to the CORE structure where the result will be stored.

Definition at line 334 of file arithm_logic.c.

                                                   {
    // Fractional Multiply Unsigned
    // R1:R0 <- Rd * Rr (UU)
    // 2 cycle
 
    // Execute instruction 
    uint16_t result = (uint16_t)core->gp.R[d] * (uint16_t)(core->gp.R[r] << 1);
    core->gp.R[0] = result & 0xFF;
    core->gp.R[1] = (result >> 8) & 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ fmuls()

void fmuls	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Multiplies two signed 8-bit integers with fractional representation and stores the result in the CORE structure.

Parameters

d	First operand.
r	Second operand.
core	Pointer to the CORE structure where the result will be stored.

Definition at line 346 of file arithm_logic.c.

                                                    {
    // Fractional Multiply Signed
    // R1:R0 <- Rd * Rr (SS)
    // 2 cycle
 
    // Execute instruction 
    int16_t result = (int16_t)core->gp.R[d] * (int16_t)(core->gp.R[r] << 1);
    core->gp.R[0] = result & 0xFF;
    core->gp.R[1] = (result >> 8) & 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ fmulsu()

void fmulsu	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Multiplies a signed 8-bit integer with an unsigned 8-bit integer with fractional representation and stores the result in the CORE structure.

Parameters

d	First operand (signed).
r	Second operand (unsigned).
core	Pointer to the CORE structure where the result will be stored.

Definition at line 358 of file arithm_logic.c.

                                                     {
    // Fractional Multiply Signed with Unsigned
    // R1:R0 <- Rd * Rr (SU)
    // 2 cycle
 
    // Execute instruction 
    int16_t result = (int16_t)core->gp.R[d] * (uint16_t)(core->gp.R[r] << 1);
    core->gp.R[0] = result & 0xFF;
    core->gp.R[1] = (result >> 8) & 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ inc()

void inc	(	uint8_t	d,
		struct CORE *	core
	)

Increment the value of a register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 248 of file arithm_logic.c.

                                       {
    // Increment
    // Rd <- Rd + 1
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] + 1;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ mul()

void mul	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Multiplies two unsigned 8-bit integers and stores the result in the CORE structure.

Parameters

d	First operand.
r	Second operand.
core	Pointer to the CORE structure where the result will be stored.

Definition at line 298 of file arithm_logic.c.

                                                  {
    // Multiply Unsigned
    // R1:R0 <- Rd * Rr (UU)
    // 2 cycle
 
    // Execute instruction 
    uint16_t result = (uint16_t)core->gp.R[d] * (uint16_t)core->gp.R[r];
    core->gp.R[0] = result & 0xFF;
    core->gp.R[1] = (result >> 8) & 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ muls()

void muls	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Multiplies two signed 8-bit integers and stores the result in the CORE structure.

Parameters

d	First operand.
r	Second operand.
core	Pointer to the CORE structure where the result will be stored.

Definition at line 310 of file arithm_logic.c.

                                                   {
    // Multiply Signed
    // R1:R0 <- Rd * Rr (SS)
    // 2 cycle
 
    // Execute instruction 
    int16_t result = (int16_t)core->gp.R[d] * (int16_t)core->gp.R[r];
    core->gp.R[0] = result & 0xFF;
    core->gp.R[1] = (result >> 8) & 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ mulsu()

void mulsu	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Multiplies a signed 8-bit integer with an unsigned 8-bit integer and stores the result in the CORE structure.

Parameters

d	First operand (signed).
r	Second operand (unsigned).
core	Pointer to the CORE structure where the result will be stored.

Definition at line 322 of file arithm_logic.c.

                                                    {
    // Multiply Signed with Unsigned
    // R1:R0 <- Rd * Rr (SU)
    // 2 cycle
 
    // Execute instruction 
    int16_t result = (int16_t)core->gp.R[d] * (uint16_t)core->gp.R[r];
    core->gp.R[0] = result & 0xFF;
    core->gp.R[1] = (result >> 8) & 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ neg()

void neg	(	uint8_t	d,
		struct CORE *	core
	)

Perform two's complement (negation) on a register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 218 of file arithm_logic.c.

                                       {
    // Two's Complement
    // Rd <- $00 - Rd
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = -core->gp.R[d];
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ or()

void or	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Logical OR.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 161 of file arithm_logic.c.

                                                 {
    // Logical OR
    // Rd <- Rd | Rr
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] | core->gp.R[r];
 
    // Update SREG
    update_sreg_logic(core, core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_logic().

◆ ori()

void ori	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Logical OR with immediate.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 175 of file arithm_logic.c.

                                                  {
    // Logical OR with immediate
    // Rd <- Rd | K
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] | K;
 
    // Update SREG
    update_sreg_logic(core, core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_logic().

◆ sbc()

void sbc	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Subtract with carry.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 84 of file arithm_logic.c.

                                                  {
    // Subtract with cary
    // Rd <- Rd - Rr - C
    // 1 cycle
 
    uint8_t R_tmp = core->gp.R[d];
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] - core->gp.R[r] - core->sreg.C;
 
    // Update SREG
    update_sreg_arithm(core, R_tmp, core->gp.R[r], core->gp.R[d]);
 
    inc_pc(core);
}

References SREG::C, CORE::gp, inc_pc(), GP::R, CORE::sreg, and update_sreg_arithm().

◆ sbci()

void sbci	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Subtract immediate with carry.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 100 of file arithm_logic.c.

                                                   {
    // Subtract immediate with cary
    // Rd <- Rd - K - C
    // 1 cycle
 
    uint8_t R_tmp = core->gp.R[d];
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] - K - core->sreg.C;
 
    // Update SREG
    update_sreg_arithm(core, R_tmp, K, core->gp.R[d]);
 
    inc_pc(core);
}

References SREG::C, CORE::gp, inc_pc(), GP::R, CORE::sreg, and update_sreg_arithm().

◆ sbiw()

void sbiw	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Subtract immediate from word.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 116 of file arithm_logic.c.

                                                   {
    // Subtract immediate from word
    // Rd:Rd+1 <- Rd:Rd+1 - K
    // 2 cycle
 
    // Execute instruction 
    uint16_t Rd = core->gp.R[d] | (core->gp.R[d + 1] << 8);
    uint16_t result = Rd - K;
    core->gp.R[d] = result & 0xFF;
    core->gp.R[d + 1] = (result >> 8) & 0xFF;
 
    // Update SREG
    udpate_sreg_arithm_16bit(core, Rd, result);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and udpate_sreg_arithm_16bit().

◆ sbr()

void sbr	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Set bits in a register.

Parameters

d	Destination register.
K	Constant value to set bits.
core	Pointer to the CORE structure.

Definition at line 228 of file arithm_logic.c.

                                                  {
    // Set Bit in Register
    // Rd <- Rd | K
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] | K;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ ser()

void ser	(	uint8_t	d,
		struct CORE *	core
	)

Set all bits in a register.

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 288 of file arithm_logic.c.

                                       {
    // Set Register
    // Rd <- $FF
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = 0xFF;
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

◆ sub()

void sub	(	uint8_t	d,
		uint8_t	r,
		struct CORE *	core
	)

Subtract.

Parameters

d	Destination register.
r	Source register.
core	Pointer to the CORE structure.

Definition at line 52 of file arithm_logic.c.

                                                  {
    // Subtract without cary
    // Rd <- Rd - Rr
    // 1 cycle
 
    uint8_t R_tmp = core->gp.R[d];
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] - core->gp.R[r];
    
    // Update SREG
    update_sreg_arithm(core, R_tmp, core->gp.R[r], core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_arithm().

◆ subi()

void subi	(	uint8_t	d,
		uint8_t	K,
		struct CORE *	core
	)

Subtract immediate.

Parameters

d	Destination register.
K	Immediate value.
core	Pointer to the CORE structure.

Definition at line 68 of file arithm_logic.c.

                                                   {
    // Subtract immediate
    // Rd <- Rd - K
    // 1 cycle
 
    uint8_t R_tmp = core->gp.R[d];
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] - K;
 
    // Update SREG
    update_sreg_arithm(core, R_tmp, K, core->gp.R[d]);
 
    inc_pc(core);
}

References CORE::gp, inc_pc(), GP::R, and update_sreg_arithm().

◆ tst()

void tst	(	uint8_t	d,
		struct CORE *	core
	)

Test for zero or minus after AND operation.

Parameters

d	Destination register.
core	Pointer to the CORE structure.

Definition at line 268 of file arithm_logic.c.

                                       {
    // Test for Zero or Minus
    // Rd <- Rd & Rd
    // 1 cycle
 
    // Execute instruction 
    core->gp.R[d] = core->gp.R[d] & core->gp.R[d];
    inc_pc(core);
}

References CORE::gp, inc_pc(), and GP::R.

Functions

Detailed Description

Function Documentation

◆ adc()

◆ add()

◆ adiw()

◆ and()

◆ andi()

◆ cbr()

◆ clr()

◆ com()

◆ dec()

◆ eor()

◆ fmul()

◆ fmuls()

◆ fmulsu()

◆ inc()

◆ mul()

◆ muls()

◆ mulsu()

◆ neg()

◆ or()

◆ ori()

◆ sbc()

◆ sbci()

◆ sbiw()

◆ sbr()

◆ ser()

◆ sub()

◆ subi()

◆ tst()