ปัญหา

ในบริบทฝังโลหะเปลือยระดับต่ำฉันต้องการสร้างพื้นที่ว่างในหน่วยความจำภายในโครงสร้าง C ++ และไม่มีชื่อใด ๆ เพื่อห้ามไม่ให้ผู้ใช้เข้าถึงตำแหน่งหน่วยความจำดังกล่าว

ตอนนี้ฉันทำได้สำเร็จแล้วโดยการใส่uint32_t :96;บิตฟิลด์ที่น่าเกลียดซึ่งจะแทนที่สามคำได้อย่างสะดวก แต่มันจะขึ้นคำเตือนจาก GCC (Bitfield ใหญ่เกินไปที่จะใส่ใน uint32_t) ซึ่งค่อนข้างถูกต้อง

แม้ว่าจะใช้งานได้ดี แต่ก็ไม่ค่อยสะอาดนักเมื่อคุณต้องการแจกจ่ายห้องสมุดที่มีคำเตือนหลายร้อยคำ ...

ฉันจะทำอย่างถูกต้องได้อย่างไร?

เหตุใดจึงมีปัญหาตั้งแต่แรก

โครงการที่ฉันกำลังดำเนินการประกอบด้วยการกำหนดโครงสร้างหน่วยความจำของอุปกรณ์ต่อพ่วงต่างๆของสายไมโครคอนโทรลเลอร์ทั้งหมด (STMicroelectronics STM32) ในการทำเช่นนั้นผลลัพธ์คือคลาสที่มีการรวมกันของโครงสร้างต่างๆซึ่งกำหนดการลงทะเบียนทั้งหมดขึ้นอยู่กับไมโครคอนโทรลเลอร์เป้าหมาย

ตัวอย่างง่ายๆสำหรับอุปกรณ์ต่อพ่วงที่เรียบง่ายมีดังต่อไปนี้: อินพุต / เอาท์พุตวัตถุประสงค์ทั่วไป (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;
    };
};

โดยที่ทั้งหมดGPIO_MAPx_YYYคือมาโครกำหนดเป็นuint32_t :32หรือประเภทรีจิสเตอร์ (โครงสร้างเฉพาะ)

ที่นี่คุณจะเห็นสิ่งuint32_t :192;ที่ทำงานได้ดี แต่มันทำให้เกิดคำเตือน

สิ่งที่ฉันได้พิจารณาแล้ว:

ฉันอาจจะแทนที่มันด้วยหลาย ๆ อันuint32_t :32;(6 ที่นี่) แต่ฉันมีบางกรณีที่รุนแรงซึ่งฉันมีuint32_t :1344;(42) (ท่ามกลางคนอื่น ๆ ) ดังนั้นฉันจึงไม่อยากเพิ่มบรรทัดอีกประมาณหนึ่งร้อยบรรทัดจาก 8k อื่น ๆ แม้ว่าการสร้างโครงสร้างจะเป็นสคริปต์ก็ตาม

ข้อความเตือนที่แน่นอนมีดังนี้: width of 'sool::ll::GPIO::<anonymous union>::<anonymous struct>::<anonymous>' exceeds its type(ฉันชอบความร่มรื่น)

ฉันไม่อยากจะแก้ปัญหานี้โดยเพียงแค่ลบคำเตือน แต่ใช้ไฟล์

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

อาจจะเป็นวิธีการแก้ปัญหา ... TheRightFlagถ้าฉันพบ อย่างไรก็ตามในขณะที่ชี้ให้เห็นในกระทู้นี้ , gcc/cp/class.cมีส่วนรหัสเศร้านี้:

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

ซึ่งบอกเราว่าไม่มี-Wxxxธงที่จะลบคำเตือนนี้ ...

ใช้หลายบิตฟิลด์ที่ไม่ระบุชื่อที่อยู่ติดกัน แทนที่จะเป็น:

    uint32_t :160;

ตัวอย่างเช่นคุณมี:

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

หนึ่งรายการสำหรับการลงทะเบียนแต่ละรายการที่คุณต้องการไม่ระบุชื่อ

หากคุณมีช่องว่างขนาดใหญ่ให้เติมอาจชัดเจนและมีข้อผิดพลาดน้อยกว่าที่จะใช้มาโครเพื่อทำซ้ำช่องว่าง 32 บิตเดียว ตัวอย่างเช่นกำหนด:

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

จากนั้นสามารถเพิ่มพื้นที่ 1344 (42 * 32 บิต) ได้ดังนี้:

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

แล้ว C ++ เป็นอย่างไรบ้าง?

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

คุณได้รับการเติมข้อความอัตโนมัติเนื่องจากGPIOเนมสเปซและไม่จำเป็นต้องมีช่องว่างภายในแบบจำลอง ถึงแม้จะมีความชัดเจนมากขึ้นว่าเกิดอะไรขึ้นเนื่องจากคุณสามารถดูที่อยู่ของแต่ละรีจิสเตอร์คุณไม่จำเป็นต้องพึ่งพาพฤติกรรมการเติมของคอมไพเลอร์

ในเวทีระบบฝังตัวคุณสามารถสร้างโมเดลฮาร์ดแวร์ได้โดยใช้โครงสร้างหรือโดยการกำหนดพอยน์เตอร์ไปยังที่อยู่รีจิสเตอร์

ไม่แนะนำให้สร้างแบบจำลองตามโครงสร้างเนื่องจากคอมไพเลอร์ได้รับอนุญาตให้เพิ่มช่องว่างระหว่างสมาชิกเพื่อวัตถุประสงค์ในการจัดตำแหน่ง (แม้ว่าคอมไพเลอร์จำนวนมากสำหรับระบบฝังตัวจะมี pragma สำหรับบรรจุโครงสร้าง)

ตัวอย่าง:

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

คุณยังสามารถใช้สัญกรณ์อาร์เรย์:

uint16_t status = UART1[UART_STATUS_OFFSET];  

หากคุณต้องใช้โครงสร้าง IMHO วิธีที่ดีที่สุดในการข้ามที่อยู่คือการกำหนดสมาชิกและไม่สามารถเข้าถึงได้:

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

ในโครงการหนึ่งของเราเรามีทั้งค่าคงที่และโครงสร้างจากผู้ขายที่แตกต่างกัน (ผู้ขาย 1 ใช้ค่าคงที่ในขณะที่ผู้ขาย 2 ใช้โครงสร้าง)

geza มีสิทธิ์ที่คุณไม่ต้องการใช้คลาสสำหรับสิ่งนี้

แต่ถ้าคุณต้องยืนยันวิธีที่ดีที่สุดในการเพิ่มสมาชิกที่ไม่ได้ใช้ของความกว้างnไบต์ก็ทำได้ง่ายๆ:

char unused[n];

หากคุณเพิ่ม pragma เฉพาะการนำไปใช้งานเพื่อป้องกันการเพิ่มช่องว่างโดยพลการให้กับสมาชิกของชั้นเรียนสิ่งนี้สามารถใช้ได้

สำหรับ GNU C / C ++ (gcc, clang และอื่น ๆ ที่รองรับนามสกุลเดียวกัน) หนึ่งในตำแหน่งที่ถูกต้องในการใส่แอตทริบิวต์คือ:

#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แสดงoffsetof(GPIO, b)= 7 ไบต์)

หากต้องการขยายคำตอบของ @ Clifford's และ @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;
}

หากต้องการขยายคำตอบของ Clifford คุณสามารถมาโครบิตฟิลด์ที่ไม่ระบุชื่อได้ตลอดเวลา

ดังนั้นแทนที่จะเป็น

uint32_t :160;

ใช้

#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

แล้วก็ใช้แบบ

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

น่าเสียดายที่คุณจะต้องใช้EMPTY_32_Xตัวแปรให้มากที่สุดเท่าที่คุณมี :( แต่ยังอนุญาตให้คุณมีการประกาศเดียวในโครงสร้างของคุณ

เพื่อกำหนดตัวเว้นวรรคขนาดใหญ่เป็นกลุ่ม 32 บิต

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

ฉันคิดว่ามันจะเป็นประโยชน์ในการแนะนำโครงสร้างเพิ่มเติม ซึ่งอาจช่วยแก้ปัญหาของตัวเว้นวรรคได้

ตั้งชื่อตัวแปร

ในขณะที่เนมสเปซแบบแบนเป็นสิ่งที่ดี แต่ปัญหาก็คือคุณจบลงด้วยการรวบรวมฟิลด์ที่หลากหลายและไม่มีวิธีง่ายๆในการส่งฟิลด์ที่เกี่ยวข้องทั้งหมดเข้าด้วยกัน นอกจากนี้การใช้โครงสร้างแบบไม่ระบุตัวตนในสหภาพที่ไม่ระบุชื่อคุณจะไม่สามารถส่งต่อการอ้างอิงไปยังโครงสร้างด้วยตนเองหรือใช้เป็นพารามิเตอร์เทมเพลต

ในขั้นตอนแรกฉันจะพิจารณาแยกstruct :

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

และสุดท้ายส่วนหัวส่วนกลาง:

// Gpio.h
#pragma once

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

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

ตอนนี้ฉันสามารถเขียนไฟล์ void special_map0(Gpio:: Map0 volatile& map);และดูภาพรวมคร่าวๆของสถาปัตยกรรมที่มีอยู่ทั้งหมดได้อย่างรวดเร็ว

ตัวเว้นวรรคแบบธรรมดา

ด้วยการแบ่งคำจำกัดความในส่วนหัวหลาย ๆ ส่วนหัวแต่ละส่วนจึงสามารถจัดการได้มากขึ้น

ดังนั้นแนวทางเริ่มต้นของฉันเพื่อให้ตรงกับความต้องการของคุณคือการทำซ้ำ std::uint32_t:32;ดังนั้นวิธีการเริ่มต้นของฉันให้ตรงตอบสนองความต้องการของคุณจะติดด้วยซ้ำใช่มันเพิ่มเส้น 100s สองสามเส้นใน 8k บรรทัดที่มีอยู่ แต่เนื่องจากแต่ละส่วนหัวมีขนาดเล็กลงทีละรายการจึงอาจไม่เลวร้ายนัก

หากคุณยินดีที่จะพิจารณาวิธีแก้ปัญหาที่แปลกใหม่มากขึ้นแม้ว่า ...

ขอแนะนำ $.

เป็นความจริงที่ไม่ค่อยมีใครรู้ว่า$เป็นอักขระที่ใช้งานได้สำหรับตัวระบุ C ++ มันเป็นอักขระเริ่มต้นที่ทำงานได้ (ไม่เหมือนตัวเลข)

การ$ปรากฏในซอร์สโค้ดอาจทำให้คิ้วขมวดและ$$$$จะดึงดูดความสนใจในระหว่างการตรวจสอบโค้ด นี่คือสิ่งที่คุณสามารถใช้ประโยชน์จาก:

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

คุณยังสามารถรวม "ผ้าสำลี" แบบธรรมดาเป็นตะขอก่อนคอมมิตหรือใน CI ของคุณซึ่งมองหา$$$$ในรหัส C ++ ที่มีการผูกมัดและปฏิเสธข้อตกลงดังกล่าว

แม้ว่าฉันยอมรับว่าไม่ควรใช้โครงสร้างสำหรับการเข้าถึงพอร์ต MCU I / O แต่คำถามดั้งเดิมสามารถตอบได้ด้วยวิธีนี้:

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

คุณอาจต้องแทนที่__attribute__((packed))ด้วย#pragma packหรือคล้ายกันขึ้นอยู่กับไวยากรณ์ของคอมไพเลอร์ของคุณ

การผสมสมาชิกส่วนตัวและสาธารณะในโครงสร้างโดยปกติจะส่งผลให้เค้าโครงหน่วยความจำนั้นไม่ได้รับการรับรองโดยมาตรฐาน C ++ อีกต่อไป แต่ถ้าทุกคนไม่ใช่สมาชิกคงที่ของ struct เป็นส่วนตัวก็ถือว่ายังคง POD / รูปแบบมาตรฐานและเพื่อให้มี structs ที่ฝังไว้

ด้วยเหตุผลบางประการ gcc สร้างคำเตือนหากสมาชิกของโครงสร้างที่ไม่ระบุชื่อเป็นส่วนตัวดังนั้นฉันจึงต้องตั้งชื่อให้ หรืออีกวิธีหนึ่งคือการรวมไว้ในโครงสร้างที่ไม่ระบุตัวตนอื่นก็จะกำจัดคำเตือน (นี่อาจเป็นข้อบกพร่อง)

โปรดทราบว่าspacerสมาชิกไม่ได้เป็นส่วนตัวดังนั้นจึงยังสามารถเข้าถึงข้อมูลได้ด้วยวิธีนี้:

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

อย่างไรก็ตามการแสดงออกดังกล่าวดูเหมือนเป็นการแฮ็กที่ชัดเจนและหวังว่าจะไม่ถูกนำไปใช้โดยไม่มีเหตุผลที่ดีจริง ๆ นับประสาอะไรกับความผิดพลาด

น้ำยาป้องกัน.

อย่าทำสิ่งนี้: ผสมฟิลด์ส่วนตัวและฟิลด์สาธารณะ

บางทีมาโครที่มีตัวนับเพื่อสร้างชื่อตัวแปร uniqie จะมีประโยชน์หรือไม่?

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