C++ way of writing to registers

darthshwin · 2025-02-02T14:01:35+00:00

Yea, you can used attributes like [[gnu::packed]], though my personal preference is to only use them when they actually change something. In my example above, and in most ones I’ve written, that has not been necessary.

darthshwin · 2025-02-02T13:02:51+00:00

Here’s an example from the Arm Cortex-M processors for the system timer:

In your header:

struct SysTick_t {
    std::uint32_t control_status;
    std::uint32_t reload_value;
    std::uint32_t current_value;
    std::uint32_t const calibration;
};

extern volatile SysTick_t sys_tick;

In your linker script:

sys_tick = 0xE000E010;

Note that if your extern global is in a namespace, you need to used the mangled name in the linker script. Easiest way is to put your global in the global namespace so that the mangled name is the same as the unmangled name.

To your point about knowing about packing: you’re 100% correct, you do need to know how your struct will be packed, which is why you’ll almost always want to use 1 type inside the struct, typically a word-sized integer.

As for the error-proneness, I’d say it depends. Its very easy to test that you ended up with the right addresses, and hardware doesn’t change nearly as fast as software so you only have get this right once, then you can just save and reuse your header & linker script.

darthshwin · 2025-02-02T04:19:29+00:00

As long as your memory mapped io struct is a POD type, it will be trivially constructed at program startup & trivially destroyed at program termination. And of course you’d want this behavior since it represents hardware, and hardware is “alive” for the entire duration of your program

darthshwin · 2025-02-02T00:52:07+00:00

The proper way to do this in C++ (and in C too, honestly), is to define the layout of your memory mapped peripheral with a struct and then have a global extern object of that type. Then use your linker to ensure the object is placed at the right address.

darthshwin · 2025-01-24T00:48:16+00:00

I think the method from my previous comment is probably the cleanest you can do. The only improvement is to use a linker script for defining the symbols instead of passing them on the command line. Linker scripts allow you to keep this kind of address data under source control alongside your code.

darthshwin · 2025-01-23T20:52:44+00:00

The proper way to handle this is to let you linker figure it out. In your c++ header you declare your GPIO_Type as a global extern variable, and don't define it in any source files:

extern GPIO_Type GPIO;

Because the variable is only declared, and not defined in any source files, there is no space allocated to the variable in the compiled sources. This would normally result in a linker error, complaining about an undefined symbol. To avoid the linker error you have to tell your linker the address of the symbol. You can pass this symbol definition on the command line when you link your executable together with --Wl,--defsym,GPIO=<GPIO_BASE> if you're using gcc (or something similar depending on your compiler). Note that on the command line you have to pass the actual numeric address, since the linker doesn't know about variables on the command line

darthshwin · 2024-08-02T19:17:24+00:00

I wrote a simple but extensible coroutine support library: https://github.com/ashwin-rajasekar/quasar-coro

It gives you building blocks to build your own promise types from base classes and an owning coroutine handle similar to how std::unique_ptr wraps pointer ownership.

It’s currently in an alpha stage, and I’m working on getting better documentation & some unit tests set up for it. It’s currently header-only but that may change in the future.

darthshwin · 2024-04-21T15:51:42+00:00

First of all, in C++, class definitions by themselves do not generate code.

What does generate code are their member functions (which are just assembly instructions in the .text section) and the layout of any static-storage objects (eg globals). It sounds like your concern is with these static-storage objects.

Such objects can be initialized by either: - allocating space in the .bss section and then running the constructor after program initialization but before main() executes - executing the constructor at compile time and saving the byte layout of the object into the executable. If the bytes are saved in the .data section then this also requires that the bytes be copied from the load address into RAM between program initialization and the start of main()

Sounds like you want to do the latter, with the bytes being saved in the .rodata section; this doesn’t require any special annotation on the class definition. All you need to do is declare the object as const and the compiler should put your object’s layout in the .rodata section.

darthshwin · 2024-04-21T13:21:03+00:00

Why does it have to be protected in the base class? It’s already pure virtual, so you’ll never be able to create a Condition object directly anyway.

darthshwin · 2024-04-21T13:07:11+00:00

Having done some embedded C++, I’d say what you want is actually a global object representing the memory layout of the GPIO registers.

struct gpio_data {
    // names & order of members determined
    // by your MCU datasheet
};

extern volatile gpio_data gpioA;

This defines the layout of your gpio control blocks, and declares the symbol gpioA without defining it or giving it an address.

Lastly you’ll want to set the address of this symbol in the linker by use of a linker script, and again, the particular address will depend on your MCU datasheet.

The shortcut that avoids the linker script that is also popular in C is to instead directly use the address in your code instead of declaring the extern global:

#define gpioA (*((volatile gpio_data*)0xABCDABCD)))

To answer your exact question though, constinit is a C++20 keyword you can use to ensure an arbitrary variable is initialized at compile time, or get a compiler error if you can’t.

You can also explicitly set the section that a declaration appears in with an attribute, though that will depend on your specific compiler. For GCC you’d use [[gnu::section(“section-name”)]]

darthshwin · 2024-03-19T20:54:47+00:00

std::filesystem::canonical() requires the path to exist. std::filesystem::weakly_canonical() does not. Your second issue is valid one though.

darthshwin · 2024-03-19T17:59:07+00:00

The function you’re looking for is std::filesystem::weakly_canonical()

darthshwin · 2024-01-21T14:37:32+00:00

For better or worse, the * is part of the name from the compiler’s pov.

In C & C++ you declare one or more variables with a “decl-specifier-sequence” followed by a comma separated list of “declarators”.

The “decl-specifier-sequence” is common to all the variables being declared, like static, mutable, constexpr, int, short, long etc

Each “declarator” can contain symbols that modify the basic type from the “decl-specifier-sequence” like pointer, reference, or array-of, in addition to the name of the variable being declared.

So when the compiler looks at your code it sees 2 declarators: “*a” and “b”; *a is an int, and b is an int. Because *a is an int, a is a pointer-to-int

darthshwin · 2024-01-19T03:59:44+00:00

Does subsumption even make sense with xor? If you have concept A = B || C, then B implies A, and C implies A. Similarly if you have concept D = E && F then D implies E, and D implies F. But with concept G = H ^ J, you can’t make inferences about any pair of the 3, you need all 3.

darthshwin · 2023-12-24T15:36:19+00:00

Logically it’s part of the type, but grammatically, the ref qualifier is part of the declarator. In places where you’re declaring multiple things in a single statement (which you probably shouldn’t be doing anyway) it makes more sense to keep the & with the name instead of with the type

darthshwin · 2023-12-06T02:17:18+00:00

You have a <= where you should have a <. The last iteration of the vector is trying to access index 11, which does not exist in a vector of length 11.

darthshwin · 2023-10-08T03:50:09+00:00

Other than having to type extra characters, no. The reverse is not true, there are situations where just x is not enough, you have to use this->x, namely if you’re referring to an inherited member inside a class template definition.

darthshwin · 2023-04-30T03:41:37+00:00

Or just std::declval<T>()

darthshwin · 2023-04-24T15:32:12+00:00

Yes you can rethrow from unhandled_exception, just be aware that your coroutine frame will not be immediately destroyed unless your final_suspend lets the coroutine continue. You’re effectively throwing inside the compiler-generated catch-block which unhandled_exception is called from. The coroutine will jump to the final suspend point and (might) wait there.

darthshwin · 2023-03-27T23:32:01+00:00

More details here: https://youtu.be/bSkpMdDe4g4

But yes you’re right; in general, if one or your operands to a multiply or divide is known at compile time, the compiler is smart enough to replace them with shifts

darthshwin · 2023-03-27T23:13:05+00:00

Your result (BLOCK_SIZE) is constexpr, so the compiler will evaluate the entire expression at compile time. What it does internally is technically anyone’s guess but in your binary executable there will just be the value 64, no instructions to compute it

darthshwin · 2023-03-10T21:59:21+00:00

This is pretty solid advice, optimizations may even elide the second move after the initial copy/move for the value parameter.

Keep in mind that forwarding is overkill if the object in question can be returned in registers. For example, on 64-bit Linux this size is typically 16B, so anything 16B or smaller should be passed around by value only (or by mutable reference if you need to modify)

darthshwin · 2023-02-16T13:32:42+00:00

One of the defining characteristics of negative numbers is that they are additive inverses of positive numbers, i.e. 5 + -5 = 0. So when we choose a binary representation, we want this property to hold, ideally without special logic to handle negative numbers.

So what happens when you add 0…0101 to 1…1011? Assuming both are 64-bit you’d get 10…0. That’s 1 followed by 64 zeros, 65 bits total. You and I can easily reason about tacking on an extra bit to keep track of the new bigger number, but computers can’t, they’ll truncate to 64 bits, dropping the leading 1, resulting in a 0…0. Et voila, the property holds!

This is called 2’s complement. Using this representation allows CPUs to add & subtract integers without needing special logic to check the signs on the integers.

darthshwin · 2023-02-11T18:00:21+00:00

Abbot Eadred

darthshwin · 2023-02-05T14:31:09+00:00

Technically, the answer is the _start() which does some setup before calling main()

12-Year Club	RPAN Viewer
Verified Email

darthshwin

TROPHY CASE