AVR Freaks

Write a small program, just doing e.g. one simple port I/O. Set the "save-temps" option in Atmel Studio: Project Properties, Toolchain, AVR/GNU C Compiler, Miscellaneous and then tick Do not delete temporary files.

Rebuild the project and then look for a file with the same name as your source but with file extension ".i". There's what the compiler sees after all pre-processing has been done.

Here's an example:

int main(void)
{
	DDRB = 0xFF;
}

Here's an excerpt of the main.i file build according to the instructions above:

# 11 ".././main.c"
int main(void)
{

# 13 ".././main.c" 3
(*(volatile uint8_t *)((0x04) + 0x20))
# 13 ".././main.c"
     = 0xFF;
}

Ignore all lines beginning with a hash sign (#) and you see that what the compiler proper will process is

(*(volatile uint8_t *)((0x04) + 0x20)) 

     = 0xFF;

So, your new program not relying on avr/io.h will be:

int main(void)
{
	(*(volatile uint8_t *)((0x04) + 0x20)) = 0xFF;
}

or possibly

int main(void)
{
	(*(volatile uint8_t *)(0x24) = 0xFF;
}

If you're not quite familiar and comfortable with the Harvard architecture, typecasts and pointers then that requires you to sit down with paper and pen and draw some sketches of memory/address-spaces and pointers. E,.g. you need to figure out why the + 0x20 is there. ;-)

Advice: Apart from the learning experience, don't rely on this style of coding.

Apart from the learning experience, what is the goal? Are there any cases where avr-gcc/avrlibc does not result in an optimal code sequence for the basic I/O operations?

OP only contributed the original post.  I've re-read it several times, and I cannot tell what the aim really is.

First, define "library".  Is avr-libc a "library"?  Next, can't DDRB=0xff; be done without AVR-libc?  Why would a chip-include file and subordinate .h be part of a "library"?

#include <avr/io.h>

int main(void) {
    DDRB = 0x55;
}

built for a mega16 (say) you will find first that -mmcu=atmega16 on the command line leads to __AVR_ATmega16__ being defined inside the compiler (you can study the compiler source to see the table where this happens). In turn that means that it's this small bit of <avr/io/h> that is really active:

#elif defined (__AVR_ATmega16__)
#  include <avr/iom16.h>

so among all the ioXXX.h headers that the compiler has, when building for mega16 it is the iom16.h file that is used. In turn you can study that to find:

#define DDRB    _SFR_IO8(0x17)

You will also find that <avr/io.h> includes <avr/sfr_defs.h> and in that you will find:

#define _SFR_IO8(io_addr) _MMIO_BYTE((io_addr) + __SFR_OFFSET)

within that:

#else  /* !_SFR_ASM_COMPAT */

#ifndef __SFR_OFFSET
#  if __AVR_ARCH__ >= 100
#    define __SFR_OFFSET 0x00
#  else
#    define __SFR_OFFSET 0x20
#  endif
#endif

as C is the NOT SFR_ASM_COMPAT case then this will define __SFR_OFFSET as 0x20. In the same file you will also find:

#ifndef __ASSEMBLER__
/* These only work in C programs.  */
#include <inttypes.h>

#define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr))

So the define of DDRB is:

#define DDRB   _MMIO_BYTE((0x17) + __SFR_OFFSET))

which in turn is:

#define DDRB   _MMIO_BYTE((0x17) + 0x20))

which in turn is:

#define DDRB   (*(volatile uint8_t *)((0x17) + 0x20)))

So:

#include <avr/io.h>

int main(void) {
    DDRB = 0x55;
}

is really

#include <avr/io.h>

int main(void) {
    (*(volatile uint8_t *)((0x17) + 0x20))) = 0x55;
}

but as Johan already showed in #3 you didn't need to manually unwind all the macro definitions because the C compiler will do all that for you:

C:\SysGCC\avr\bin>type avr.c
#include <avr/io.h>

int main(void) {
    DDRB = 0x55;
}

C:\SysGCC\avr\bin>avr-gcc -mmcu=atmega16 -Os -save-temps avr.c -o avr.elf

C:\SysGCC\avr\bin>tail avr.i


# 3 "avr.c"
int main(void) {

# 4 "avr.c" 3
   (*(volatile uint8_t *)((0x17) + 0x20))
# 4 "avr.c"
        = 0x55;
}

So there's no real mystery here. The -save-temps also gives you a .s file as well as .i and that has:

C:\SysGCC\avr\bin>type avr.s
        .file   "avr.c"
__SP_H__ = 0x3e
__SP_L__ = 0x3d
__SREG__ = 0x3f
__tmp_reg__ = 0
__zero_reg__ = 1
        .section        .text.startup,"ax",@progbits
.global main
        .type   main, @function
main:
/* prologue: function */
/* frame size = 0 */
/* stack size = 0 */
.L__stack_usage = 0
        ldi r24,lo8(85)
        out 0x17,r24
        ldi r24,0
        ldi r25,0
        ret
        .size   main, .-main
        .ident  "GCC: (GNU) 5.3.0"

which is the actual Asm file generated by the C compiler and then passed to the assembler to create your code. The LDI and OUT being the direct result of:

# 4 "avr.c" 3
   (*(volatile uint8_t *)((0x17) + 0x20))
# 4 "avr.c"
        = 0x55;

The 0x17 versus 0x37 is because 0x20 is first added to the IO address (0x17) to make it a "RAM address" but the compiler (because of -Os) optimises this and recognises that "STS 0x37, n" in RAM is more efficient as "OUT 0x17, n" in IO space so the +0x20 offset that was added was removed in the optimisation.

As I say none of this is "hidden". It's an open source compiler and it's also happy to show you (and sometimes extraordinary levels of detail!) how it is working internally so there's no need to be "scared" of using things like "DDRB = 0x55". It sure makes a heap more sense than "(*(volatile uint8_t *)((0x17) + 0x20)) = 0x55"!!

You may feel you have "won" if you do use that tortuous syntax because "nothing is hidden" but pretty soon you are going to find it a lot easier to type:

ADCSRA = (1 << ADEN) | (1 << ADSC);

than the non-macro alternative.

If you do want an alternative though then consider this:

https://www.avrfreaks.net/forum/b...

That will let you use:

https://www.avrfreaks.net/comment...

There is nothing "hidden" at all in that. The entire mega16 is being defined as a C struct on top of the SFR space. The only "machine specific" detail in the whole thing is really:

#define USE_SFRS() volatile SFRS_t * const pSFR = (SFRS_t *)0x0020

where it hard codes the 0x0020 base address for the SFRs. In this scheme you just:

#include "Atmega16.h"

USE_SFRS();

int main(void) {
    ddrb = 0x55; // note case used ! "ddrb" not "DDRB"
}

Everything (and I mean everything) is immediately visible in Atmega16.h which is the ONLY support header involved. Again working it back this has:

#define ddrb pSFR->_DDRB.all

and that in turn refers to:

	union {
		uint8_t all; // (@ 0x37) Port B Data Direction Register
		struct {
			unsigned int b0:1;
			unsigned int b1:1;
			unsigned int b2:1;
			unsigned int b3:1;
			unsigned int b4:1;
			unsigned int b5:1;
			unsigned int b6:1;
			unsigned int b7:1;
		} bits;
	} _DDRB;

which (as the comment tells you) just happens to be at offset 0x17 from the 0x0020 base (so at 0x0037).

I posed a few questions.  You have chosen not to address them.  There is a reason to ask each.  So I'm out.

I know.

But I certainly got the impression the OP was talking about actually doing the manual transcribing from the datasheet himself.

but my point is that's just pure laborious slog - there is nothing creative (OP's word) in doing that!