Masalah

Dalam konteks embedded-metal tingkat rendah , saya ingin membuat ruang kosong di memori, dalam struktur C ++ dan tanpa nama, untuk melarang pengguna mengakses lokasi memori tersebut.

Saat ini, saya telah mencapainya dengan meletakkan uint32_t :96;bitfield jelek yang akan dengan mudah menggantikan tiga kata, tetapi itu akan memunculkan peringatan dari GCC (Bitfield terlalu besar untuk muat dalam uint32_t), yang cukup sah.

Meskipun berfungsi dengan baik, itu tidak terlalu bersih ketika Anda ingin mendistribusikan perpustakaan dengan beberapa ratus peringatan itu ...

Bagaimana cara melakukannya dengan benar?

Mengapa ada masalah di tempat pertama?

Proyek yang saya kerjakan terdiri dari mendefinisikan struktur memori dari periferal yang berbeda dari seluruh jalur mikrokontroler (STMicroelectronics STM32). Untuk melakukannya, hasilnya adalah kelas yang berisi gabungan beberapa struktur yang mendefinisikan semua register, bergantung pada mikrokontroler yang ditargetkan.

Salah satu contoh sederhana untuk perangkat yang cukup sederhana adalah sebagai berikut: Input / Output Tujuan Umum (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;
    };
};

Dimana semuanya GPIO_MAPx_YYYadalah makro, didefinisikan sebagai uint32_t :32atau tipe register (struktur khusus).

Di sini Anda melihat uint32_t :192;mana yang berfungsi dengan baik, tetapi ini memicu peringatan.

Apa yang saya pertimbangkan sejauh ini:

Saya mungkin telah menggantinya dengan beberapa uint32_t :32;(6 di sini), tetapi saya memiliki beberapa kasus ekstrim di mana saya memiliki uint32_t :1344;(42) (antara lain). Jadi saya lebih suka tidak menambahkan sekitar seratus baris di atas 8k lainnya, meskipun pembuatan struktur sudah dituliskan.

Pesan peringatan yang tepat adalah seperti: width of 'sool::ll::GPIO::<anonymous union>::<anonymous struct>::<anonymous>' exceeds its type(Saya suka betapa teduhnya itu).

Saya lebih suka tidak menyelesaikan ini hanya dengan menghapus peringatan, tetapi menggunakan

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

semoga bisa menjadi solusi ... jika saya temukan TheRightFlag. Namun, seperti yang ditunjukkan di utas ini , gcc/cp/class.cdengan bagian kode yang menyedihkan ini:

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

Yang memberi tahu kita bahwa tidak ada -Wxxxbendera untuk menghapus peringatan ini ...

Gunakan beberapa bitfield anonim yang berdekatan. Jadi, alih-alih:

    uint32_t :160;

misalnya, Anda akan memiliki:

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

Satu untuk setiap register Anda ingin menjadi anonim.

Jika Anda memiliki ruang yang besar untuk diisi, mungkin akan lebih jelas dan lebih sedikit kesalahan yang rawan menggunakan makro untuk mengulang satu ruang 32 bit. Misalnya, diberikan:

#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)

Kemudian ruang 1344 (42 * 32 bit) dapat ditambahkan sebagai berikut:

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

Bagaimana dengan cara C ++ - ish?

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;
}

Anda mendapatkan pelengkapan otomatis karena GPIOnamespace, dan tidak perlu padding tiruan. Bahkan, lebih jelas apa yang terjadi, karena Anda dapat melihat alamat dari setiap register, Anda tidak perlu bergantung pada perilaku padding compiler sama sekali.

Dalam arena sistem tertanam, Anda dapat memodelkan perangkat keras baik dengan menggunakan struktur atau dengan menentukan pointer ke alamat register.

Pemodelan berdasarkan struktur tidak disarankan karena kompilator diperbolehkan untuk menambahkan bantalan antar anggota untuk tujuan penyelarasan (walaupun banyak kompiler untuk sistem tertanam memiliki pragma untuk mengemas struktur).

Contoh:

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);

Anda juga bisa menggunakan notasi array:

uint16_t status = UART1[UART_STATUS_OFFSET];  

Jika Anda harus menggunakan struktur, IMHO, metode terbaik untuk melewati alamat adalah dengan menentukan anggota dan tidak mengaksesnya:

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

Dalam salah satu proyek kami, kami memiliki konstanta dan struct dari vendor yang berbeda (vendor 1 menggunakan konstanta sedangkan vendor 2 menggunakan struktur).

hak geza bahwa Anda benar-benar tidak ingin menggunakan kelas untuk ini.

Tetapi, jika Anda bersikeras, cara terbaik untuk menambahkan anggota yang tidak terpakai dengan lebar n byte, adalah dengan melakukannya:

char unused[n];

Jika Anda menambahkan pragma khusus implementasi untuk mencegah penambahan padding arbitrer ke anggota kelas, ini bisa berfungsi.

Untuk GNU C / C ++ (gcc, clang, dan lainnya yang mendukung ekstensi yang sama), salah satu tempat yang valid untuk meletakkan atribut ini adalah:

#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");

(contoh pada penjelajah kompilator Godbolt menampilkan offsetof(GPIO, b)= 7 byte.)

Untuk memperluas jawaban @ Clifford dan @Adam Kotwasinski:

#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;
}

Untuk memperluas jawaban Clifford, Anda selalu dapat membuat makro dari bitfield anonim.

Jadi, bukan

uint32_t :160;

menggunakan

#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

Dan kemudian gunakan seperti itu

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

Sayangnya, Anda akan membutuhkan sebanyak mungkin EMPTY_32_Xvarian byte yang Anda miliki :( Namun, ini memungkinkan Anda memiliki deklarasi tunggal di struct Anda.

Untuk mendefinisikan spacer besar sebagai kelompok 32 bit.

#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)
};

Saya pikir akan bermanfaat untuk memperkenalkan beberapa struktur lagi; yang dapat, pada gilirannya, memecahkan masalah spacer.

Sebutkan variannya

Sementara namespace datar bagus, masalahnya adalah Anda berakhir dengan kumpulan bidang yang beraneka ragam dan tidak ada cara sederhana untuk meneruskan semua bidang terkait bersama-sama. Selain itu, dengan menggunakan struct anonim dalam penyatuan anonim Anda tidak bisa meneruskan referensi ke struct itu sendiri, atau menggunakannya sebagai parameter templat.

Oleh karena itu, sebagai langkah pertama, saya akan mempertimbangkan untuk memecahstruct :

// 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 ...

Dan terakhir, tajuk global:

// Gpio.h
#pragma once

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

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

Sekarang, saya bisa menulis void special_map0(Gpio:: Map0 volatile& map);, serta mendapatkan gambaran umum singkat dari semua arsitektur yang tersedia dalam sekejap.

Spacer Sederhana

Dengan pembagian definisi dalam beberapa tajuk, tajuk secara individual jauh lebih mudah dikelola.

Oleh karena itu, pendekatan awal saya untuk benar-benar memenuhi kebutuhan Anda akan tetap dengan berulang std::uint32_t:32; . Ya, ini menambahkan beberapa baris 100 ke baris 8k yang ada, tetapi karena setiap tajuk lebih kecil secara individual, mungkin tidak seburuk itu.

Namun, jika Anda ingin mempertimbangkan solusi yang lebih eksotis ...

Memperkenalkan $.

Ini adalah fakta yang sedikit diketahui bahwa $karakter yang layak untuk pengenal C ++; itu bahkan karakter awal yang layak (tidak seperti angka).

Sebuah $muncul dalam kode sumber kemungkinan akan mengangkat alis, dan $$$$pasti akan menarik perhatian selama tinjauan kode. Ini adalah sesuatu yang dapat Anda manfaatkan dengan mudah:

#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);
};

Anda bahkan dapat menyusun "lint" sederhana sebagai hook pra-commit atau di CI Anda yang mencari $$$$dalam kode C ++ yang dikomit dan menolak komit tersebut.

Meskipun saya setuju struct tidak boleh digunakan untuk akses port I / O MCU, pertanyaan asli dapat dijawab dengan cara ini:

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

Anda mungkin perlu mengganti __attribute__((packed))dengan #pragma packatau yang serupa tergantung pada sintaks kompilator Anda.

Menggabungkan anggota pribadi dan publik dalam sebuah struct biasanya mengakibatkan tata letak memori tersebut tidak lagi dijamin oleh standar C ++. Namun jika semua anggota non-statis dari sebuah struct bersifat pribadi, itu masih dianggap POD / tata letak standar, dan begitu juga struct yang menyematkannya.

Untuk beberapa alasan gcc menghasilkan peringatan jika anggota struct anonim bersifat pribadi jadi saya harus memberinya nama. Atau, membungkusnya ke dalam struct anonim lain juga menghilangkan peringatan (ini mungkin bug).

Perhatikan bahwa spaceranggota itu sendiri tidak bersifat pribadi, jadi data masih dapat diakses dengan cara ini:

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

Namun ungkapan seperti itu terlihat seperti retasan yang jelas, dan semoga tidak akan digunakan tanpa alasan yang benar-benar bagus, apalagi sebagai kesalahan.

Anti-solusi.

JANGAN LAKUKAN INI: Campurkan bidang pribadi dan publik.

Mungkin makro dengan penghitung untuk menghasilkan nama variabel unik akan berguna?

#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];
};