AVR Freaks

@gchapman, I succeeded in placing at 0x0000 an array with address of needed function, but unfortunately, this is not JMP.

I also tried goto, but it seems not to be converted to JMP (nor RJMP)

I think it is easier with JMP or RJMP. I am maybe wrong.

I have found some clue in optiboot code and this seems to work (to put RJMP) :

int main(void);
void biosEraseFlash(void);
void biosCopyFlash(void);

__attribute__((naked)) __attribute__((section(".ctors"))) void jumpTable(void) {
  asm volatile (
    "	rjmp    main\n"
    "	rjmp    biosEraseFlash\n"
    "	rjmp    biosCopyFlash\n"
  );
}

__attribute__((naked)) __attribute__((section(".ctors"))) int main(void) {
	/* Initialize system for AVR GCC support, expects r1 = 0 */
	asm volatile("clr r1");
	SREG=0;
	SP = RAMEND;

	/* Go to application, located immediately after boot section */
	fn_ptr_t app = (fn_ptr_t)(AppcodeSectionAddr / sizeof(fn_ptr_t));
	app();
	return(0);
}

Disasm is :

Disassembly of section .text:

00000000 <jumpTable>:
int main(void);
void biosEraseFlash(void);
void biosCopyFlash(void);

__attribute__((naked)) __attribute__((section(".ctors"))) void jumpTable(void) {
  asm volatile (
   0:	02 c0       	rjmp	.+4      	; 0x6 <main>
   2:	0c c0       	rjmp	.+24     	; 0x1c <biosEraseFlash>
   4:	15 c0       	rjmp	.+42     	; 0x30 <biosCopyFlash>

00000006 <main>:
  );
}

__attribute__((naked)) __attribute__((section(".ctors"))) int main(void) {
	/* Initialize system for AVR GCC support, expects r1 = 0 */
	asm volatile("clr r1");
   6:	11 24       	eor	r1, r1
	SREG=0;
   8:	1f be       	out	0x3f, r1	; 63
	SP = RAMEND;
   a:	8f ef       	ldi	r24, 0xFF	; 255
   c:	9f e3       	ldi	r25, 0x3F	; 63
   e:	8d bf       	out	0x3d, r24	; 61
  10:	9e bf       	out	0x3e, r25	; 62

	/* Go to application, located immediately after boot section */
	fn_ptr_t app = (fn_ptr_t)(AppcodeSectionAddr / sizeof(fn_ptr_t));
	app();
  12:	e0 e0       	ldi	r30, 0x00	; 0
  14:	f2 e0       	ldi	r31, 0x02	; 2
  16:	09 95       	icall
	return(0);
}
  18:	80 e0       	ldi	r24, 0x00	; 0
  1a:	90 e0       	ldi	r25, 0x00	; 0

0000001c <biosEraseFlash>:
void biosEraseFlash(void) {
}

...

Sure but getting the address from the table is also something like an indirection

So 2 vs quite 2 !

But many thanks for your lines of code, they will help me. And maybe I will finally implement this solution.
For now, I am just at the beginning of this dev.

D.

If functions are declared with const, it still uses icall, but value are loaded directly without using RAM

typedef uint16_t (*fptr_u16u16u16_t) (uint16_t, uint16_t);
static const fptr_u16u16u16_t addition = (fptr_u16u16u16_t) (0x0006/2);
static const fptr_u16u16u16_t substraction = (fptr_u16u16u16_t) (0x0008/2);

Disassembly :

		uint16_t resultAddition = addition(12,23);
    1460:	67 e1       	ldi	r22, 0x17	; 23
    1462:	70 e0       	ldi	r23, 0x00	; 0
    1464:	8c e0       	ldi	r24, 0x0C	; 12
    1466:	90 e0       	ldi	r25, 0x00	; 0
    1468:	e3 e0       	ldi	r30, 0x03	; 3
    146a:	f0 e0       	ldi	r31, 0x00	; 0
    146c:	09 95       	icall
    146e:	b8 2e       	mov	r11, r24
    1470:	a9 2e       	mov	r10, r25
		uint16_t resultSubstraction = substraction(42,23);
    1472:	67 e1       	ldi	r22, 0x17	; 23
    1474:	70 e0       	ldi	r23, 0x00	; 0
    1476:	8a e2       	ldi	r24, 0x2A	; 42
    1478:	90 e0       	ldi	r25, 0x00	; 0
    147a:	e4 e0       	ldi	r30, 0x04	; 4
    147c:	f0 e0       	ldi	r31, 0x00	; 0
    147e:	09 95       	icall
    1480:	d8 2e       	mov	r13, r24
    1482:	c9 2e       	mov	r12, r25

But I do not understand avr gcc optimisation as :

LDI+LDI+ICALL = 4/5 clocks and 48 bits of code

and CALL = 3/4 clocks and 32 bits of code

So CALL seems more efficient in all terms than ICALL !