#include "branch.h"

Include dependency graph for branch.c:

Functions
void	rjmp (uint8_t k, struct CORE *core)
	Perform a relative jump.

void	ijmp (struct CORE *core)
	Perform an indirect jump.

void	jmp (uint32_t k, struct CORE *core)
	Perform an absolute jump.

void	rcall (uint8_t k, struct CORE core, struct SRAM sram)
	Perform a relative call to a subroutine.

void	icall (struct CORE core, struct SRAM sram)
	Perform an indirect call to a subroutine.

void	ret (struct CORE core, struct SRAM sram)
	Return from a subroutine.

void	reti (struct CORE core, struct SRAM sram)
	Return from an interrupt.

void	cpse (uint8_t d, uint8_t r, struct CORE *core)
	Compare and skip if equal.

void	cp (uint8_t d, uint8_t r, struct CORE *core)
	Compare two registers.

void	cpc (uint8_t d, uint8_t r, struct CORE *core)
	Compare two registers with carry.

void	cpi (uint8_t d, uint8_t K, struct CORE *core)
	Compare register with an immediate value.

void	sbrc (uint8_t r, uint8_t b, struct CORE *core)
	Skip if bit in register is cleared.

void	sbrs (uint8_t r, uint8_t b, struct CORE *core)
	Skip if bit in register is set.

void	sbic (uint8_t A, uint8_t b, struct CORE core, union DATA_SPACE data_space)
	Skip if bit in I/O register is cleared.

void	sbis (uint8_t A, uint8_t b, struct CORE core, union DATA_SPACE data_space)
	Skip if bit in I/O register is set.

void	brbs (uint8_t s, uint8_t k, struct CORE *core)
	Branch if status flag is set.

void	brbc (uint8_t s, uint8_t k, struct CORE *core)
	Branch if status flag is cleared.

void	breq (uint8_t k, struct CORE *core)
	Branch if equal.

void	brne (uint8_t k, struct CORE *core)
	Branch if not equal.

void	brcs (uint8_t k, struct CORE *core)
	Branch if carry set.

void	brcc (uint8_t k, struct CORE *core)
	Branch if carry cleared.

void	brsh (uint8_t k, struct CORE *core)
	Branch if same or higher.

void	brlo (uint8_t k, struct CORE *core)
	Branch if lower.

void	brmi (uint8_t k, struct CORE *core)
	Branch if minus.

void	brpl (uint8_t k, struct CORE *core)
	Branch if plus.

void	brge (uint8_t k, struct CORE *core)
	Branch if greater or equal.

void	brlt (uint8_t k, struct CORE *core)
	Branch if less than.

void	brhs (uint8_t k, struct CORE *core)
	Branch if half carry set.

void	brhc (uint8_t k, struct CORE *core)
	Branch if half carry cleared.

void	brts (uint8_t k, struct CORE *core)
	Branch if T flag set.

void	brtc (uint8_t k, struct CORE *core)
	Branch if T flag cleared.

void	brvs (uint8_t k, struct CORE *core)
	Branch if overflow set.

void	brvc (uint8_t k, struct CORE *core)
	Branch if overflow cleared.

void	brie (uint8_t k, struct CORE *core)
	Branch if interrupts enabled.

void	brid (uint8_t k, struct CORE *core)
	Branch if interrupts disabled.

Function Documentation

◆ brbc()

void brbc	(	uint8_t	s,
		uint8_t	k,
		struct CORE *	core
	)

Branch if status flag is cleared.

Parameters

s	Status flag.
k	Relative address.
core	Pointer to the CORE structure.

Definition at line 247 of file branch.c.

                                                   {
    // Branch if bit in SREG cleared
    // If S(s) = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if ((core->sreg.sreg & (1 << s)) == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, SREG::sreg, and CORE::sreg.

◆ brbs()

void brbs	(	uint8_t	s,
		uint8_t	k,
		struct CORE *	core
	)

Branch if status flag is set.

Parameters

s	Status flag.
k	Relative address.
core	Pointer to the CORE structure.

Definition at line 230 of file branch.c.

                                                   {
    // Branch if bit in SREG set
    // If S(s) = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if ((core->sreg.sreg & (1 << s)) == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, SREG::sreg, and CORE::sreg.

◆ brcc()

void brcc	(	uint8_t	k,
		struct CORE *	core
	)

Branch if carry cleared.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 315 of file branch.c.

                                        {
    // Branch if carry cleared
    // If C = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.C == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::C, CORE::PC, and CORE::sreg.

◆ brcs()

void brcs	(	uint8_t	k,
		struct CORE *	core
	)

Branch if carry set.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 298 of file branch.c.

                                        {
    // Branch if carry set
    // If C = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.C == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::C, CORE::PC, and CORE::sreg.

◆ breq()

void breq	(	uint8_t	k,
		struct CORE *	core
	)

Branch if equal.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 264 of file branch.c.

                                        {
    // Branch if equal
    // If Z = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.Z == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, CORE::sreg, and SREG::Z.

◆ brge()

void brge	(	uint8_t	k,
		struct CORE *	core
	)

Branch if greater or equal.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 400 of file branch.c.

                                        {
    // Branch if greater or equal
    // If N = V, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.N == core->sreg.V) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::N, CORE::PC, CORE::sreg, and SREG::V.

◆ brhc()

void brhc	(	uint8_t	k,
		struct CORE *	core
	)

Branch if half carry cleared.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 451 of file branch.c.

                                        {
    // Branch if half carry cleared
    // If H = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.H == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::H, CORE::PC, and CORE::sreg.

◆ brhs()

void brhs	(	uint8_t	k,
		struct CORE *	core
	)

Branch if half carry set.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 434 of file branch.c.

                                        {
    // Branch if half carry set
    // If H = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.H == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::H, CORE::PC, and CORE::sreg.

◆ brid()

void brid	(	uint8_t	k,
		struct CORE *	core
	)

Branch if interrupts disabled.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 553 of file branch.c.

                                        {
    // Branch if global interrupt disabled
    // If I = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.I == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::I, CORE::PC, and CORE::sreg.

◆ brie()

void brie	(	uint8_t	k,
		struct CORE *	core
	)

Branch if interrupts enabled.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 536 of file branch.c.

                                        {
    // Branch if global interrupt enabled
    // If I = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.I == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::I, CORE::PC, and CORE::sreg.

◆ brlo()

void brlo	(	uint8_t	k,
		struct CORE *	core
	)

Branch if lower.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 349 of file branch.c.

                                        {
    // Branch if lower
    // If C = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.C == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::C, CORE::PC, and CORE::sreg.

◆ brlt()

void brlt	(	uint8_t	k,
		struct CORE *	core
	)

Branch if less than.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 417 of file branch.c.

                                        {
    // Branch if less than
    // If N != V, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.N != core->sreg.V) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::N, CORE::PC, CORE::sreg, and SREG::V.

◆ brmi()

void brmi	(	uint8_t	k,
		struct CORE *	core
	)

Branch if minus.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 366 of file branch.c.

                                        {
    // Branch if minus
    // If N = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.N == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::N, CORE::PC, and CORE::sreg.

◆ brne()

void brne	(	uint8_t	k,
		struct CORE *	core
	)

Branch if not equal.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 281 of file branch.c.

                                        {
    // Branch if not equal
    // If Z = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.Z == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, CORE::sreg, and SREG::Z.

◆ brpl()

void brpl	(	uint8_t	k,
		struct CORE *	core
	)

Branch if plus.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 383 of file branch.c.

                                        {
    // Branch if plus
    // If N = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.N == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::N, CORE::PC, and CORE::sreg.

◆ brsh()

void brsh	(	uint8_t	k,
		struct CORE *	core
	)

Branch if same or higher.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 332 of file branch.c.

                                        {
    // Branch if same or higher
    // If C = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.C == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References SREG::C, CORE::PC, and CORE::sreg.

◆ brtc()

void brtc	(	uint8_t	k,
		struct CORE *	core
	)

Branch if T flag cleared.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 485 of file branch.c.

                                        {
    // Branch if T flag cleared
    // If T = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.T == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, CORE::sreg, and SREG::T.

◆ brts()

void brts	(	uint8_t	k,
		struct CORE *	core
	)

Branch if T flag set.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 468 of file branch.c.

                                        {
    // Branch if T flag set
    // If T = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.T == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, CORE::sreg, and SREG::T.

◆ brvc()

void brvc	(	uint8_t	k,
		struct CORE *	core
	)

Branch if overflow cleared.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 519 of file branch.c.

                                        {
    // Branch if overflow cleared
    // If V = 0, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.V == 0) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, CORE::sreg, and SREG::V.

◆ brvs()

void brvs	(	uint8_t	k,
		struct CORE *	core
	)

Branch if overflow set.

Parameters

k	The offset for the branch.
core	Pointer to the core structure.

Definition at line 502 of file branch.c.

                                        {
    // Branch if overflow set
    // If V = 1, PC <- PC + k + 1
    // 1 cycle
 
    // Execute instruction
    if (core->sreg.V == 1) {
        core->PC = core->PC + k + 1;
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::PC, CORE::sreg, and SREG::V.

◆ cp()

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

Compare two registers.

Parameters

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

Definition at line 120 of file branch.c.

                                                 {
    // Compare
    // Rd - Rr
    // 1 cycle
 
    // Execute instruction
    uint8_t result = core->gp.R[d] - core->gp.R[r];
 
    // Update SREG
    update_sreg_arithm(core, core->gp.R[d], core->gp.R[r], result);
}

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

◆ cpc()

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

Compare two registers with carry.

Parameters

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

Definition at line 132 of file branch.c.

                                                  {
    // Compare with carry
    // Rd - Rr - C
    // 1 cycle
 
    // Execute instruction
    uint8_t result = core->gp.R[d] - core->gp.R[r] - core->sreg.C;
 
    // Update SREG
    update_sreg_arithm(core, core->gp.R[d], core->gp.R[r], result);
}

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

◆ cpi()

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

Compare register with an immediate value.

Parameters

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

Definition at line 144 of file branch.c.

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

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

◆ cpse()

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

Compare and skip if equal.

Parameters

d	The destination register.
r	The source register.
core	Pointer to the CORE structure.

Definition at line 102 of file branch.c.

                                                   {
    // Compare, skip if equal
    // If Rd = Rr, PC <- PC + 2
    // 1 cycle
 
    // Execute instruction
    if (core->gp.R[d] == core->gp.R[r]) {
        core->PC = core->PC + 2;
        // LACKS IMPLEMENTATION + 3 if instruction skipped is 2word long
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::gp, CORE::PC, and GP::R.

◆ icall()

void icall	(	struct CORE *	core,
		struct SRAM *	sram
	)

Perform an indirect call to a subroutine.

Parameters

core	Pointer to the CORE structure.
sram	Pointer to the SRAM structure.

Definition at line 54 of file branch.c.

                                                 {
    // Indirect call to address contained in Z
    // PC <- Z
    // Push return address to stack
    // 3 cycles
 
    // Execute instruction
    sram->mem[core->SP] = core->PC + 1;
    core->SP = core->SP - 2;
    core->PC = core->gp.Z;
 
    // Update SREG
    // NONE
}

References CORE::gp, SRAM::mem, CORE::PC, CORE::SP, and GP::Z.

◆ ijmp()

void ijmp ( struct CORE * core )

Perform an indirect jump.

Parameters

core	Pointer to the CORE structure.

Definition at line 15 of file branch.c.

                             {
    // Indirect jump to address contained in Z
    // PC <- Z
    // 2 cycles
 
    // Execute instruction
    core->PC = core->gp.R[30] << 8 | core->gp.R[31];
 
    // Update SREG
    // NONE
}

References CORE::gp, CORE::PC, and GP::R.

◆ jmp()

void jmp	(	uint32_t	k,
		struct CORE *	core
	)

Perform an absolute jump.

Parameters

k	The address to jump to.
core	Pointer to the CORE structure.

Definition at line 27 of file branch.c.

                                        {
    // Absolute jump
    // PC <- k
    // 3 cycles
 
    // Execute instruction
    core->PC = k;
 
    // Update SREG
    // NONE
}

References CORE::PC.

◆ rcall()

void rcall	(	uint8_t	k,
		struct CORE *	core,
		struct SRAM *	sram
	)

Perform a relative call to a subroutine.

Parameters

k	The offset for the call.
core	Pointer to the CORE structure.
sram	Pointer to the SRAM structure.

Definition at line 39 of file branch.c.

                                                            {
    // Relative call
    // PC <- PC + k + 1
    // Push return address to stack
    // 3 cycles
 
    // Execute instruction
    sram->mem[core->SP] = core->PC + 1;
    core->SP = core->SP - 2;
    core->PC = core->PC + k + 1;
 
    // Update SREG
    // NONE
}

References SRAM::mem, CORE::PC, and CORE::SP.

◆ ret()

void ret	(	struct CORE *	core,
		struct SRAM *	sram
	)

Return from a subroutine.

Parameters

core	Pointer to the CORE structure.
sram	Pointer to the SRAM structure.

Definition at line 73 of file branch.c.

                                               {
    // Return from subroutine
    // Pop return address from stack
    // PC <- (SP + 1)
    // 4 cycles
 
    // Execute instruction
    core->SP = core->SP + 1;
    core->PC = sram->mem[core->SP] << 8 | sram->mem[core->SP + 1];
 
    // Update SREG
    // NONE
}

References SRAM::mem, CORE::PC, and CORE::SP.

◆ reti()

void reti	(	struct CORE *	core,
		struct SRAM *	sram
	)

Return from an interrupt.

Parameters

core	Pointer to the CORE structure.
sram	Pointer to the SRAM structure.

Definition at line 87 of file branch.c.

                                                {
    // Return from interrupt
    // Pop return address from stack
    // PC <- (SP + 1)
    // Enable global interrupts
    // 4 cycles
 
    // Execute instruction
    core->SP = core->SP + 1;
    core->PC = sram->mem[core->SP] << 8 | sram->mem[core->SP + 1];
 
    // Update SREG
    update_sreg_I(&core->sreg, true);
}

References SRAM::mem, CORE::PC, CORE::SP, CORE::sreg, and update_sreg_I().

◆ rjmp()

void rjmp	(	uint8_t	k,
		struct CORE *	core
	)

Perform a relative jump.

Parameters

k	The offset for the jump.
core	Pointer to the CORE structure.

Definition at line 3 of file branch.c.

                                        {
    // Relative jump
    // PC <- PC + k + 1
    // 2 cycles
 
    // Execute instruction
    core->PC = core->PC + k + 1;
 
    // Update SREG
    // NONE
}

References CORE::PC.

◆ sbic()

void sbic	(	uint8_t	A,
		uint8_t	b,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Skip if bit in I/O register is cleared.

Parameters

A	I/O register address.
b	Bit position.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 192 of file branch.c.

                                                                                 {
    // Skip if bit in I/O register cleared
    // Only for 0 <= A <= 31
    // If I/O(A)(b) = 0, PC <- PC + 2
    // 1 cycle
 
    // Execute instruction
    if ((data_space->io_reg[A] & (1 << b)) == 0) {
        core->PC = core->PC + 2;
        // LACKS IMPLEMENTATION + 3 if instruction skipped is 2word long
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References DATA_SPACE::io_reg, and CORE::PC.

◆ sbis()

void sbis	(	uint8_t	A,
		uint8_t	b,
		struct CORE *	core,
		union DATA_SPACE *	data_space
	)

Skip if bit in I/O register is set.

Parameters

A	I/O register address.
b	Bit position.
core	Pointer to the CORE structure.
data_space	Pointer to the DATA_SPACE union.

Definition at line 211 of file branch.c.

                                                                                 {
    // Skip if bit in I/O register set
    // Only for 0 <= A <= 31
    // If I/O(A)(b) = 1, PC <- PC + 2
    // 1 cycle
 
    // Execute instruction
    if ((data_space->io_reg[A] & (1 << b)) == 1) {
        core->PC = core->PC + 2;
        // LACKS IMPLEMENTATION + 3 if instruction skipped is 2word long
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References DATA_SPACE::io_reg, and CORE::PC.

◆ sbrc()

void sbrc	(	uint8_t	r,
		uint8_t	b,
		struct CORE *	core
	)

Skip if bit in register is cleared.

Parameters

r	Register.
b	Bit position.
core	Pointer to the CORE structure.

Definition at line 156 of file branch.c.

                                                   {
    // Skip if bit in register cleared
    // If Rr(b) = 0, PC <- PC + 2
    // 1 cycle
 
    // Execute instruction
    if ((core->gp.R[r] & (1 << b)) == 0) {
        core->PC = core->PC + 2;
        // LACKS IMPLEMENTATION + 3 if instruction skipped is 2word long
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::gp, CORE::PC, and GP::R.

◆ sbrs()

void sbrs	(	uint8_t	r,
		uint8_t	b,
		struct CORE *	core
	)

Skip if bit in register is set.

Parameters

r	Register.
b	Bit position.
core	Pointer to the CORE structure.

Definition at line 174 of file branch.c.

                                                   {
    // Skip if bit in register set
    // If Rr(b) = 1, PC <- PC + 2
    // 1 cycle
 
    // Execute instruction
    if ((core->gp.R[r] & (1 << b)) == 1) {
        core->PC = core->PC + 2;
        // LACKS IMPLEMENTATION + 3 if instruction skipped is 2word long
    }
    else {
        core->PC = core->PC + 1;
    }
 
    // Update SREG
    // NONE
}

References CORE::gp, CORE::PC, and GP::R.

Functions

Function Documentation

◆ brbc()

◆ brbs()

◆ brcc()

◆ brcs()

◆ breq()

◆ brge()

◆ brhc()

◆ brhs()

◆ brid()

◆ brie()

◆ brlo()

◆ brlt()

◆ brmi()

◆ brne()

◆ brpl()

◆ brsh()

◆ brtc()

◆ brts()

◆ brvc()

◆ brvs()

◆ cp()

◆ cpc()

◆ cpi()

◆ cpse()

◆ icall()

◆ ijmp()

◆ jmp()

◆ rcall()

◆ ret()

◆ reti()

◆ rjmp()

◆ sbic()

◆ sbis()

◆ sbrc()

◆ sbrs()