Sorun

Bir de düşük düzeyde çıplak metal gömülü bağlamda, bir erişim, bellek konumu için kullanıcı yasaklamış, C ++ yapı içinde ve herhangi bir isim vermeden, bellek boş bir alan yaratmak istiyoruz.

Şu anda, bunu uint32_t :96;üç sözcüğün yerini alabilecek çirkin bir bitfield koyarak başardım , ancak bu oldukça meşru olan GCC'den (Bitfield uint32_t'ye sığmayacak kadar büyük) bir uyarı getirecek.

İyi çalışsa da, bu uyarıların birkaç yüzünü içeren bir kitaplığı dağıtmak istediğinizde çok temiz değil ...

Bunu nasıl düzgün bir şekilde yaparım?

İlk etapta neden bir sorun var?

Üzerinde çalıştığım proje, tüm bir mikrodenetleyici hattının (STMicroelectronics STM32) farklı çevre birimlerinin bellek yapısını tanımlamaktan ibarettir. Bunu yapmak için, sonuç, hedeflenen mikro denetleyiciye bağlı olarak tüm kayıtları tanımlayan birkaç yapının bir birleşimini içeren bir sınıftır.

Oldukça basit bir çevre birimi için basit bir örnek şudur: Genel Amaçlı Giriş / Çıkış (GPIO)

union
{

    struct
    {
        GPIO_MAP0_MODER;
        GPIO_MAP0_OTYPER;
        GPIO_MAP0_OSPEEDR;
        GPIO_MAP0_PUPDR;
        GPIO_MAP0_IDR;
        GPIO_MAP0_ODR;
        GPIO_MAP0_BSRR;
        GPIO_MAP0_LCKR;
        GPIO_MAP0_AFR;
        GPIO_MAP0_BRR;
        GPIO_MAP0_ASCR;
    };
    struct
    {
        GPIO_MAP1_CRL;
        GPIO_MAP1_CRH;
        GPIO_MAP1_IDR;
        GPIO_MAP1_ODR;
        GPIO_MAP1_BSRR;
        GPIO_MAP1_BRR;
        GPIO_MAP1_LCKR;
        uint32_t :32;
        GPIO_MAP1_AFRL;
        GPIO_MAP1_AFRH;
        uint32_t :64;
    };
    struct
    {
        uint32_t :192;
        GPIO_MAP2_BSRRL;
        GPIO_MAP2_BSRRH;
        uint32_t :160;
    };
};

Hepsi GPIO_MAPx_YYYbir makrodur, ya uint32_t :32kayıt tipi olarak tanımlanır (özel bir yapı).

Burada uint32_t :192;hangisinin iyi çalıştığını görüyorsunuz , ancak bir uyarıyı tetikliyor.

Şimdiye kadar düşündüklerim:

Birkaç tane ile değiştirmiş olabilirim uint32_t :32;(burada 6), ancak sahip olduğum bazı aşırı durumlar var uint32_t :1344;(42) (diğerleri arasında). Bu nedenle, yapı oluşturma komut dosyası yazılmış olsa bile, 8k diğerinin üzerine yaklaşık yüz satır eklememeyi tercih ederim.

Tam uyarı mesajı şöyle bir şeydir: width of 'sool::ll::GPIO::<anonymous union>::<anonymous struct>::<anonymous>' exceeds its type(Ne kadar gölgeli olduğunu seviyorum).

Daha doğrusu olurdu değil sadece uyarı kaldırarak bunu çözmek, ancak kullanımı

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-WTheRightFlag"
/* My code */
#pragma GCC diagnostic pop

bir çözüm olabilir ... bulursam TheRightFlag. Ancak, bu başlıkta da belirtildiği gibi , gcc/cp/class.cbu üzücü kod bölümü ile:

warning_at (DECL_SOURCE_LOCATION (field), 0,
        "width of %qD exceeds its type", field);

Bu da bize -Wxxxbu uyarıyı kaldıracak bayrak olmadığını söylüyor ...

Birden çok bitişik anonim bit alanı kullanın. Yani bunun yerine:

    uint32_t :160;

örneğin, sahip olacaksınız:

    uint32_t :32;
    uint32_t :32;
    uint32_t :32;
    uint32_t :32;
    uint32_t :32;

Anonim olmasını istediğiniz her kayıt için bir tane.

Doldurmanız gereken geniş alanlarınız varsa, tek 32 bitlik alanı tekrarlamak için makroları kullanmaya daha açık ve daha az hata eğilimi olabilir. Örneğin, verilen:

#define REPEAT_2(a) a a
#define REPEAT_4(a) REPEAT_2(a) REPEAT_2(a)
#define REPEAT_8(a) REPEAT_4(a) REPEAT_4(a)
#define REPEAT_16(a) REPEAT_8(a) REPEAT_8(a)
#define REPEAT_32(a) REPEAT_16(a) REPEAT_16(a)

Daha sonra 1344 (42 * 32 bit) boşluk şu şekilde eklenebilir:

struct
{
    ...
    REPEAT_32(uint32_t :32;) 
    REPEAT_8(uint32_t :32;) 
    REPEAT_2(uint32_t :32;)
    ...
};

C ++ - ish yöntemine ne dersiniz?

namespace GPIO {

static volatile uint32_t &MAP0_MODER = *reinterpret_cast<uint32_t*>(0x4000);
static volatile uint32_t &MAP0_OTYPER = *reinterpret_cast<uint32_t*>(0x4004);

}

int main() {
    GPIO::MAP0_MODER = 42;
}

Ad GPIOalanı nedeniyle otomatik tamamlama elde edersiniz ve kukla dolguya gerek yoktur. Hatta, her kaydın adresini görebildiğiniz için, derleyicinin doldurma davranışına hiç güvenmek zorunda kalmadığınız için neler olduğu daha açık.

Gömülü sistemler alanında, bir yapı kullanarak veya kayıt adreslerine işaretçiler tanımlayarak donanımı modelleyebilirsiniz.

Yapıya göre modelleme, derleyicinin hizalama amacıyla üyeler arasında dolgu eklemesine izin verildiğinden (gömülü sistemler için birçok derleyicinin yapıyı paketlemek için bir pragması olmasına rağmen) önerilmez.

Misal:

uint16_t * const UART1 = (uint16_t *)(0x40000);
const unsigned int UART_STATUS_OFFSET = 1U;
const unsigned int UART_TRANSMIT_REGISTER = 2U;
uint16_t * const UART1_STATUS_REGISTER = (UART1 + UART_STATUS_OFFSET);
uint16_t * const UART1_TRANSMIT_REGISTER = (UART1 + UART_TRANSMIT_REGISTER);

Ayrıca dizi gösterimini de kullanabilirsiniz:

uint16_t status = UART1[UART_STATUS_OFFSET];  

IMHO yapısını kullanmanız gerekiyorsa, adresleri atlamanın en iyi yöntemi bir üye tanımlamak ve ona erişmek değil:

struct UART1
{
  uint16_t status;
  uint16_t reserved1; // Transmit register
  uint16_t receive_register;
};

Projelerimizden birinde, farklı satıcılardan hem sabitler hem de yapılar var (satıcı 1 sabitleri kullanırken satıcı 2 yapıları kullanıyor).

bunun için sınıfları kullanmak istemediğin konusunda haklısın.

Ancak, ısrar edecekseniz, n bayt genişliğinde kullanılmayan bir üye eklemenin en iyi yolu basitçe bunu yapmaktır:

char unused[n];

Sınıf üyelerine rastgele doldurmanın eklenmesini önlemek için uygulamaya özgü bir pragma eklerseniz, bu işe yarayabilir.

GNU C / C ++ (gcc, clang ve aynı uzantıları destekleyen diğerleri) için, niteliği koymak için geçerli yerlerden biri şudur:

#include <stddef.h>
#include <stdint.h>
#include <assert.h>  // for C11 static_assert, so this is valid C as well as C++

struct __attribute__((packed)) GPIO {
    volatile uint32_t a;
    char unused[3];
    volatile uint32_t b;
};

static_assert(offsetof(struct GPIO, b) == 7, "wrong GPIO struct layout");

( Godbolt derleyici kaşifindeoffsetof(GPIO, b) = 7 bayt gösteren örnek .)

@ Clifford ve @Adam Kotwasinski'nin yanıtlarını genişletmek için:

#define REP10(a)        a a a a a a a a a a
#define REP1034(a)      REP10(REP10(REP10(a))) REP10(a a a) a a a a

struct foo {
        int before;
        REP1034(unsigned int :32;)
        int after;
};
int main(void){
        struct foo bar;
        return 0;
}

Clifford'un cevabını genişletmek için, anonim bit alanlarını her zaman makro yapabilirsiniz.

Yani yerine

uint32_t :160;

kullanım

#define EMPTY_32_1 \
 uint32_t :32
#define EMPTY_32_2 \
 uint32_t :32;     \ // I guess this also can be replaced with uint64_t :64
 uint32_t :32
#define EMPTY_32_3 \
 uint32_t :32;     \
 uint32_t :32;     \
 uint32_t :32
#define EMPTY_UINT32(N) EMPTY_32_ ## N

Ve sonra onu şu şekilde kullan

struct A {
  EMPTY_UINT32(3);
  /* which resolves to EMPTY_32_3, which then resolves to real declarations */
}

Ne yazık ki, sahip olduğunuz EMPTY_32_Xbayta kadar değişkene ihtiyacınız olacak :( Yine de, yapınızda tek bildirimlere sahip olmanıza izin verir.

32 bitlik gruplar olarak büyük bir ara parça tanımlamak için.

#define M_32(x)   M_2(M_16(x))
#define M_16(x)   M_2(M_8(x))
#define M_8(x)    M_2(M_4(x))
#define M_4(x)    M_2(M_2(x))
#define M_2(x)    x x

#define SPACER int : 32;

struct {
    M_32(SPACER) M_8(SPACER) M_4(SPACER)
};

Biraz daha yapı getirmenin faydalı olacağını düşünüyorum; bu da ara parça sorununu çözebilir.

Varyantları adlandırın

Düz ad alanları güzel olsa da, sorun, rengarenk bir alan koleksiyonuna sahip olmanız ve ilgili tüm alanları bir araya getirmenin basit bir yolunu bulmamanızdır. Ayrıca, anonim bir birleşimde anonim yapılar kullanarak, yapıların kendilerine referanslar iletemez veya bunları şablon parametreleri olarak kullanamazsınız.

İlk adım olarak, bu nedenle, şu hususları kırmayıstruct düşünürdüm :

// GpioMap0.h
#pragma once

// #includes

namespace Gpio {
struct Map0 {
    GPIO_MAP0_MODER;
    GPIO_MAP0_OTYPER;
    GPIO_MAP0_OSPEEDR;
    GPIO_MAP0_PUPDR;
    GPIO_MAP0_IDR;
    GPIO_MAP0_ODR;
    GPIO_MAP0_BSRR;
    GPIO_MAP0_LCKR;
    GPIO_MAP0_AFR;
    GPIO_MAP0_BRR;
    GPIO_MAP0_ASCR;
};
} // namespace Gpio

// GpioMap1.h
#pragma once

// #includes

namespace Gpio {
struct Map1 {
    // fields
};
} // namespace Gpio

// ... others headers ...

Ve son olarak, genel başlık:

// Gpio.h
#pragma once

#include "GpioMap0.h"
#include "GpioMap1.h"
// ... other headers ...

namespace Gpio {
union Gpio {
    Map0 map0;
    Map1 map1;
    // ... others ...
};
} // namespace Gpio

Şimdi, void special_map0(Gpio:: Map0 volatile& map);bir bakışta mevcut tüm mimarilere hızlı bir bakış atmanın yanı sıra bir yazabilirim .

Basit Paspayı

Tanım birden çok başlığa bölündüğünde, başlıklar ayrı ayrı çok daha yönetilebilir.

Bu nedenle, gereksinimlerinizi tam olarak karşılamak için ilk yaklaşımım, tekrarlananlara bağlı kalmak olacaktır std::uint32_t:32;. Evet, mevcut 8k satırlarına birkaç 100s satır ekler, ancak her başlık ayrı ayrı daha küçük olduğu için o kadar da kötü olmayabilir.

Yine de daha egzotik çözümler düşünmeye istekliysen ...

$ İle tanışın.

$C ++ tanımlayıcıları için geçerli bir karakter olduğu az bilinen bir gerçektir ; hatta geçerli bir başlangıç ​​karakteridir (rakamların aksine).

$Kaynak kodda bir görünme muhtemelen kaşları kaldıracaktır ve $$$$kod incelemeleri sırasında kesinlikle dikkat çekecektir. Bu, kolayca yararlanabileceğiniz bir şeydir:

#define GPIO_RESERVED(Index_, N_) std::uint32_t $$$$##Index_[N_];

struct Map3 {
    GPIO_RESERVED(0, 6);
    GPIO_MAP2_BSRRL;
    GPIO_MAP2_BSRRH;
    GPIO_RESERVED(1, 5);
};

Hatta bir ön-kesinleştirme kancası olarak veya CI'nizde $$$$, işlenmiş C ++ kodunu arayan ve bu tür taahhütleri reddeden basit bir "tüy" bile oluşturabilirsiniz .

Yapıların MCU G / Ç bağlantı noktası erişimi için kullanılmaması gerektiğini kabul etmeme rağmen, orijinal soru şu şekilde yanıtlanabilir:

struct __attribute__((packed)) test {
       char member1;
       char member2;
       volatile struct __attribute__((packed))
       {
       private:
              volatile char spacer_bytes[7];
       }  spacer;
       char member3;
       char member4;
};

Sen değiştirmeniz gerekebilir __attribute__((packed))ile #pragma packveya benzeri derleyici sözdizimi bağlı.

Bir yapıda özel ve genel üyelerin karıştırılması normalde bellek düzeninin artık C ++ standardı tarafından garanti edilmemesiyle sonuçlanır. Bununla birlikte , bir yapının statik olmayan tüm üyeleri özelse, yine de POD / standart düzen ve onları gömen yapılar olarak kabul edilir.

Bazı nedenlerden ötürü, anonim yapının bir üyesi özelse gcc bir uyarı üretiyor, bu yüzden ona bir isim vermem gerekiyordu. Alternatif olarak, onu başka bir anonim yapıya sarmak da uyarıdan kurtulur (bu bir hata olabilir).

spacerÜyenin kendisinin özel olmadığını unutmayın , bu nedenle verilere yine de bu yolla erişilebilir:

(char*)(void*)&testobj.spacer;

Bununla birlikte, böyle bir ifade apaçık bir hack gibi görünür ve umarım, bırakın hata olarak, gerçekten iyi bir sebep olmadan kullanılamaz.

Anti-çözüm.

BUNU YAPMAYIN: Özel ve genel alanları karıştırın.

Belki uniqie değişken adları oluşturmak için bir sayacı olan bir makro yararlı olabilir?

#define CONCAT_IMPL( x, y ) x##y
#define MACRO_CONCAT( x, y ) CONCAT_IMPL( x, y )
#define RESERVED MACRO_CONCAT(Reserved_var, __COUNTER__) 


struct {
    GPIO_MAP1_CRL;
    GPIO_MAP1_CRH;
    GPIO_MAP1_IDR;
    GPIO_MAP1_ODR;
    GPIO_MAP1_BSRR;
    GPIO_MAP1_BRR;
    GPIO_MAP1_LCKR;
private:
    char RESERVED[4];
public:
    GPIO_MAP1_AFRL;
    GPIO_MAP1_AFRH;
private:
    char RESERVED[8];
};