আমি কীভাবে একটি সি ++ শ্রেণীর মেমরি স্ট্রাকচারে একটি "স্পেসার" তৈরি করব?

Question 1

সমস্যাটি

একটি নিম্ন স্তরের বেয়ার মেটাল এমবেডেড প্রসঙ্গ, আমি একটি সি ++ কাঠামোর মধ্যে এবং কোন নাম ছাড়া মেমরির মধ্যে একটি ফাঁকা স্থান তৈরি করতে, অ্যাক্সেস মেমরি অবস্থানকে ব্যবহারকারী নিষেধ করতে চাই।

এই মুহুর্তে, আমি এটি একটি uint32_t :96;কুরুচিপূর্ণ বিটফিল্ড স্থাপন করে অর্জন করেছি যা সহজেই তিনটি শব্দের স্থান গ্রহণ করবে, তবে এটি জিসিসির কাছ থেকে একটি সতর্কতা উত্থাপন করবে (বিটফিল্ড uint32_t ফিট করতে খুব বড় হবে না) এটি বেশ বৈধ is

এটি কার্যকরভাবে কাজ করার সময়, আপনি যখন কয়েকশ সতর্কতা দিয়ে একটি লাইব্রেরি বিতরণ করতে চান তখন খুব পরিষ্কার হয় না ...

আমি কীভাবে এটি সঠিকভাবে করব?

প্রথমদিকে কেন একটি সমস্যা আছে?

আমি যে প্রকল্পে কাজ করছি তাতে সম্পূর্ণ মাইক্রোকন্ট্রোলার লাইনের (এসটিএমক্রোইলেকট্রনিক্স এসটিএম 32) বিভিন্ন পেরিফেরিয়ালগুলির মেমরি কাঠামো সংজ্ঞায়িত করে। এটি করার জন্য, ফলাফলটি এমন একটি শ্রেণী যা লক্ষ্যযুক্ত মাইক্রোকন্ট্রোলারের উপর নির্ভর করে সমস্ত রেজিস্ট্রার সংজ্ঞায়িত করে এমন বেশ কয়েকটি কাঠামোর একটি ইউনিয়ন ধারণ করে।

বেশ সহজ পেরিফেরিয়ালগুলির জন্য একটি সাধারণ উদাহরণ নিম্নরূপ: একটি সাধারণ উদ্দেশ্য ইনপুট / আউটপুট (জিপিআইও)

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এই সতর্কতাটি সরাতে কোনও পতাকা নেই ...

Question 2

একাধিক সংলগ্ন বেনামে বিটফিল্ড ব্যবহার করুন। এর পরিবর্তে:

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

Question 3

কীভাবে সি ++ - ইশ ওয়ে?

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নেমস্পেসের কারণে আপনি অটোকম্প্লেশন পান এবং ডামি প্যাডিংয়ের দরকার নেই। এমনকি, এটি কী চলছে তা আরও স্পষ্ট, যেমন আপনি প্রতিটি নিবন্ধকের ঠিকানা দেখতে পাচ্ছেন, আপনাকে সংকলকের প্যাডিং আচরণের উপর মোটেই নির্ভর করতে হবে না।

Question 4

এম্বেড থাকা সিস্টেমের ক্ষেত্রে, আপনি কাঠামো ব্যবহার করে বা রেজিস্টার ঠিকানাগুলিতে পয়েন্টার নির্ধারণ করে হার্ডওয়্যারকে মডেল করতে পারেন।

কাঠামো অনুসারে মডেলিংয়ের প্রস্তাব দেওয়া হয় না কারণ সংযোজক উদ্দেশ্যে প্রান্তিককরণের জন্য সদস্যদের মধ্যে প্যাডিং যুক্ত করার অনুমতি দেওয়া হয়েছে (যদিও এমবেডেড সিস্টেমগুলির জন্য অনেক সংকলক কাঠামোর প্যাকিংয়ের জন্য প্রগমা রয়েছে)।

উদাহরণ:

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

আপনার যদি অবশ্যই কাঠামো, আইএমএইচও ব্যবহার করতে হবে তবে ঠিকানাগুলি এড়িয়ে যাওয়ার সর্বোত্তম পদ্ধতিটি হ'ল কোনও সদস্যকে সংজ্ঞায়িত করা এবং এটি অ্যাক্সেস না করা:

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

আমাদের প্রকল্পগুলির একটিতে আমাদের কাছে বিভিন্ন বিক্রেতাদের কাছ থেকে ধ্রুবক এবং স্ট্রাক উভয়ই রয়েছে (বিক্রেতারা 1 কনস্ট্যান্ট ব্যবহার করেন এবং বিক্রেতারা স্ট্রাকচার ব্যবহার করেন 2)।

Question 5

geza এর অধিকার যে আপনি সত্যিই এই জন্য ক্লাস ব্যবহার করা চাই না।

তবে, যদি আপনি জোর দিয়ে থাকেন তবে এন বাইটের প্রস্থের অব্যক্ত সদস্যকে যুক্ত করার সর্বোত্তম উপায়টি কেবল এটি করা:

char unused[n];

আপনি যদি শ্রেণীর সদস্যদের মধ্যে স্বেচ্ছাসেবক প্যাডিং যোগ করা রোধ করতে একটি প্রয়োগ-নির্দিষ্ট প্রগমা যোগ করেন তবে এটি কাজ করতে পারে।

জিএনইউ সি / সি ++ (জিসিসি, ঝনঝন, এবং অন্যান্য যারা একই এক্সটেনশনগুলি সমর্থন করে) এর জন্য, বৈশিষ্ট্যটি রাখার জন্য বৈধ স্থানগুলির মধ্যে একটি হ'ল:

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

(উদাহরণস্বরূপ গডবোল্ট সংকলক এক্সপ্লোরারoffsetof(GPIO, b) = 7 বাইট দেখায় )

Question 6

@ ক্লিফোর্ড এবং @ অ্যাডাম কোটওয়াসিনস্কির উত্তরগুলিতে প্রসারিত করতে:

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

Question 7

ক্লিফোর্ডের উত্তরে প্রসারিত করতে আপনি বরাবর বেনামে বিটফিল্ডগুলি ম্যাক্রো করতে পারেন।

পরিবর্তে তাই

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যতগুলি বাইট রয়েছে তার জন্য আপনার যতগুলি বৈকল্পিক প্রয়োজন :( তবুও, এটি আপনাকে আপনার স্ট্রাক্টে একক ঘোষণার অনুমতি দেয়।

Question 8

একটি বড় স্পেসারকে 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)
};

Question 9

আমি মনে করি এটি আরও কিছু কাঠামো প্রবর্তন করা উপকারী হবে; যা পরিবর্তে স্পেসারদের সমস্যা সমাধান করতে পারে।

রূপগুলির নাম দিন

ফ্ল্যাট নেমস্পেসগুলি দুর্দান্ত হলেও, সমস্যাটি হল আপনি ক্ষেত্রগুলির মোটেল সংগ্রহ এবং সমস্ত সম্পর্কিত ক্ষেত্র একসাথে পাশ করার কোনও সহজ উপায় না দিয়েই শেষ করুন। তদ্ব্যতীত, বেনামে ইউনিয়নে বেনামে স্ট্রাক্ট ব্যবহার করে আপনি নিজেরাই স্ট্রাক্টের রেফারেন্সগুলি পাস করতে পারবেন না, বা সেগুলি টেমপ্লেট পরামিতি হিসাবে ব্যবহার করতে পারবেন না।

প্রথম পদক্ষেপ হিসাবে, আমি তাই ভাঙ্গার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;। হ্যাঁ, এটি বিদ্যমান 8 কে লাইনে কয়েকটি 100s লাইন যুক্ত করে, তবে প্রতিটি শিরোনাম স্বতন্ত্রভাবে ছোট হওয়ায় এটি ততটা খারাপ নাও হতে পারে।

আপনি আরও বহিরাগত সমাধান বিবেচনা করতে ইচ্ছুক থাকলেও, ...

পরিচয় করানো $।

এটি একটি সামান্য-পরিচিত সত্য যা $সি ++ শনাক্তকারীদের জন্য একটি কার্যকর চরিত্র; এটি এমনকি একটি ব্যবহার্য শুরুর অক্ষর (অঙ্কগুলির বিপরীতে)।

একটি $সোর্স কোড প্রদর্শনে সম্ভবত ভ্রু বাড়াতে হবে, এবং $$$$স্পষ্টভাবে কোড রিভিউ সময় মনোযোগ আকর্ষণ করতে যাচ্ছে। এটি এমন কিছু যা আপনি সহজেই নিতে পারেন:

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

এমনকি আপনি প্রাক-কমিট হুক হিসাবে বা আপনার সিআইতে একটি সাধারণ "লিন্ট" একসাথে রাখতে পারেন যা $$$$প্রতিশ্রুতিবদ্ধ সি ++ কোড সন্ধান করে এবং এই জাতীয় কমিটি প্রত্যাখ্যান করে।

Question 10

যদিও আমি সম্মত হয়েছি যে স্ট্রাইকগুলি এমসিইউ আই / ও পোর্ট অ্যাক্সেসের জন্য ব্যবহার করা উচিত নয়, মূল প্রশ্নের উত্তর এভাবে দেওয়া যেতে পারে:

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।

কোনও স্ট্রাক্টে বেসরকারী এবং পাবলিক সদস্যদের মিশ্রণ সাধারণত সেই মেমরি লেআউটে ফলাফল দেয় যা আর সি ++ স্ট্যান্ডার্ড দ্বারা গ্যারান্টিযুক্ত নয়। তবে যদি কোনও স্ট্রাক্টের সমস্ত অ স্থিতিশীল সদস্যগুলি ব্যক্তিগত হয় তবে এটি এখনও পড / মানক বিন্যাস হিসাবে বিবেচিত হয় এবং তাই স্ট্রাক্টগুলি যা সেগুলি এম্বেড করে।

কোনও কারণে জিসিসি একটি সতর্কতা তৈরি করে যদি কোনও বেনামি কাঠামোর সদস্য ব্যক্তিগত হয় তাই আমাকে এটির নাম দিতে হয়েছিল। বিকল্পভাবে, এটি অন্য একটি বেনামে কাঠামোতে মোড়ানো সতর্কতা থেকে মুক্তি পেয়েছে (এটি কোনও ত্রুটি হতে পারে)।

নোট করুন যে spacerসদস্যটি নিজেই ব্যক্তিগত নয়, সুতরাং এখনও এই উপায়ে অ্যাক্সেস করা যায়:

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

তবে এই জাতীয় অভিব্যক্তিটি একটি সুস্পষ্ট হ্যাকের মতো দেখাচ্ছে এবং আশা করি সত্যিকারের কোনও ভাল কারণ ব্যতীত ব্যবহার করা হবে না, ভুল হিসাবে ছেড়ে দেওয়া হোক।

Question 11

বিরোধী সমাধান।

এটি করবেন না: ব্যক্তিগত এবং সরকারী ক্ষেত্রগুলি মেশান।

সম্ভবত ইউনিট ভেরিয়েবলের নাম তৈরি করতে কাউন্টার সহ একটি ম্যাক্রো কার্যকর হবে?

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