GCC Statische initialisierung.

[Hans-Georg L. (h-g-l)]

Bei einem Placement new oder std::construct_at sollte doch der Compiler 
einfach die Adresse zuweisen und keine statische Initialisierung machen. 
Wenn ich den nachfolgenden Code im Compiler Explorer 
https://gcc.godbolt.org/ eingebe zeigt mir der GCC 12.2.noeabi bei 
beiden Varianten statischen Initialisierungscode an. Warum ?
Optionen : -std=c++20 -Og

#include <cstdint>
#include <memory> 

const std::uintptr_t CONST_GPIOA_BASE = 0x40020000UL;
const std::uintptr_t CONST_GPIOB_BASE = 0x40020400UL;

struct gpio_type {  
    volatile std::uint32_t moder;    // offset: 0x00
    volatile std::uint32_t otyper;   // offset: 0x04
    volatile std::uint32_t ospeedr;  // offset: 0x08
    volatile std::uint32_t pupdr;    // offset: 0x0C    
    volatile std::uint32_t idr;      // offset: 0x10 
    volatile std::uint32_t odr;      // offset: 0x14  
    volatile std::uint32_t bssr;     // offset: 0x18  
    volatile std::uint32_t lckr;     // offset: 0x1C 
    volatile std::uint32_t afr[2];   // offset: 0x20/0x24  
};

// placement new 
auto gpio_A = new (reinterpret_cast<void*>(CONST_GPIOA_BASE)) gpio_type;

// std::construct_at (C++20)
auto gpio_B = std::construct_at(reinterpret_cast<gpio_type*>CONST_GPIOA_BASE));

int main()
{
    gpio_A->moder = 4711;
    gpio_B->moder = 4712;
}

>

[Niklas G. (erlkoenig)]

Hans-Georg L. schrieb:
> Warum ?

Weil deine Variablen nicht constinit/constexpr sind und daher eben 
Laufzeit-initialisiert werden. Eigentlich müsstest du "constinit" 
hinzufügen, aber reinterpret_cast ist in constant expressions nicht 
erlaubt.

placement-new bzw construct_at ist eigentlich eh das falsche Werkzeug, 
du willst ja keinen Konstruktor auf den Peripherie-Registern aufrufen!

Man muss den Cast auf die Laufzeit verschieben, und im constant 
expression Kontext halt nur mit dem Integer hantieren. z.B. so:

#include <cstdint>

#include <memory> 

constexpr std::uintptr_t CONST_GPIOA_BASE = 0x40020000UL;

constexpr std::uintptr_t CONST_GPIOB_BASE = 0x40020400UL;

struct gpio_type {  

    volatile std::uint32_t moder;    // offset: 0x00

    volatile std::uint32_t otyper;   // offset: 0x04

    volatile std::uint32_t ospeedr;  // offset: 0x08

    volatile std::uint32_t pupdr;    // offset: 0x0C    

    volatile std::uint32_t idr;      // offset: 0x10 

    volatile std::uint32_t odr;      // offset: 0x14  

    volatile std::uint32_t bssr;     // offset: 0x18  

    volatile std::uint32_t lckr;     // offset: 0x1C 

    volatile std::uint32_t afr[2];   // offset: 0x20/0x24  

};

template <typename PeriphType, std::uintptr_t Addr>
struct PeriphWrapper {
    [[gnu::always_inline]] inline PeriphType& get () const { return *reinterpret_cast<PeriphType*> (Addr); }
    [[gnu::always_inline]] inline PeriphType* operator -> () const { return &get (); }
};

static constexpr PeriphWrapper<gpio_type, CONST_GPIOA_BASE> gpio_A;
static constexpr PeriphWrapper<gpio_type, CONST_GPIOB_BASE> gpio_B;

int main()
{

    gpio_A->moder = 4711;
    gpio_B->moder = 0x815;

}

https://gcc.godbolt.org/z/cejd945na

Die Variablen gpio_A und gpio_B sind leere Dummys und belegen keinen 
Speicher, erst beim Aufruf des Pfeil-Operators erfolgt der Cast. Also 
eben zur Laufzeit, nur durch das Inlinen wird es dann effizient.

Aber ob das jetzt so schön ist...

[Richard W. (richardw)]

Niklas G. schrieb:
> Aber ob das jetzt so schön ist...

Also ich würd's kaufen. Insbesondere die Trennung der Registerstruktur 
und der Klasse für den Speicherzugriff ist doch sehr schön. So ginge 
auch:

#include <cstdint>

constexpr std::uintptr_t CONST_GPIOA_BASE = 0x40020000UL;
constexpr std::uintptr_t CONST_GPIOB_BASE = 0x40020400UL;

template<std::uintptr_t Addr>
struct gpio_type {
    std::uint32_t moder;    // offset: 0x00
    std::uint32_t otyper;   // offset: 0x04
    std::uint32_t ospeedr;  // offset: 0x08
    std::uint32_t pupdr;    // offset: 0x0C
    std::uint32_t idr;      // offset: 0x10
    std::uint32_t odr;      // offset: 0x14
    std::uint32_t bssr;     // offset: 0x18
    std::uint32_t lckr;     // offset: 0x1C
    std::uint32_t afr[2];   // offset: 0x20/0x24

    inline volatile gpio_type* operator -> () const { return reinterpret_cast<gpio_type*>(Addr); }
};

using GPIOA = gpio_type<CONST_GPIOA_BASE>;
using GPIOB = gpio_type<CONST_GPIOB_BASE>;

void test()
{
    GPIOA()->moder = 0x4711;
    GPIOB()->moder = 0x815;
}

https://gcc.godbolt.org/z/E94PfaPrK

Sieht auf den ersten Blick ein klitzeklein wenig einfacher aus weil auf 
die Trennung verzichtet wird, ebenso auf die statische Variable. Es wird 
trotzdem gleiche Maschinencode erzeugt. Mit -Os oder -Oz wird's sogar 
noch kleiner.

[Niklas G. (erlkoenig)]

Richard W. schrieb:
> Sieht auf den ersten Blick ein klitzeklein wenig einfacher aus

Gefällt mir nicht so ganz weil es so keinen nicht-templatisierten 
"gpio_type" gibt. Dadurch kann man kein "gpio_type*" als 
Funktionsparameter übergeben o.ä.