Thread overview |
---|
November 28, 2009 Access to fixed memory locations, head const, ... | ||||
---|---|---|---|---|
| ||||
Hi, I'm contemplating using D for an embedded project where system configuration registers have fixed memory locations. One way of doing it would be to have a constant pointer to a structure with manually aligned members that match the register map, and access them like that. This becomes cumbersome, as all accesses look like struct Regs { ... }; Regs* cfg = cast(Regs*)0xF00; cfg.reg0 = ... This is also where D's const-transitivity becomes problematic. Since the configuration registers are not going anywhere, ideally you'd want a way of telling the compiler that the *pointer* is constant, but not the pointed-to stuff. For a systems language, this seems like a serious drawback. Why can't I tell the compiler that noone should muck with the cfg pointer's value? I presume there can be ways around it via delegates, but this seems like a C++ approach: instead of making it simple, it becomes convoluted... OTOH, there's a C hack that allows you to access variables at fixed memory locations "directly": #define CFGREG0 (*(unsigned short*)0xBEEF) I'm an absolute noob to D, and so far I found no way of approximating this behavior -- of bringing the configuration registers at a fixed memory location into the scope as an identifier that can be used naked, like CFGREG0 = 0xFF; if (CFGREG0 != 3) { ... } Any hints? Cheers, Kuba |
November 28, 2009 Re: Access to fixed memory locations, head const, ... | ||||
---|---|---|---|---|
| ||||
Posted in reply to Kuba Ober | > Hi, > > I'm contemplating using D for an embedded project where system configuration registers have fixed memory locations. > > One way of doing it would be to have a constant pointer to a structure with manually aligned members that match the register map, and access them like that. This becomes cumbersome, as all accesses look like > > struct Regs { > ... > }; > > Regs* cfg = cast(Regs*)0xF00; > > cfg.reg0 = ... > > This is also where D's const-transitivity becomes problematic. Since > the configuration registers are not going anywhere, ideally you'd want > a way of telling the compiler that the *pointer* is constant, but not > the pointed-to stuff. > > For a systems language, this seems like a serious drawback. Why can't > I tell the compiler that noone should muck with the cfg pointer's > value? I presume there can be ways around it via delegates, but this > seems like a C++ approach: instead of making it simple, it becomes > convoluted... > > > OTOH, there's a C hack that allows you to access variables at fixed > memory locations "directly": > > #define CFGREG0 (*(unsigned short*)0xBEEF) > > I'm an absolute noob to D, and so far I found no way of approximating > this behavior -- of bringing the configuration registers at a fixed > memory location into the scope as an identifier that can be used naked, like > > CFGREG0 = 0xFF; > if (CFGREG0 != 3) { ... } > > > Any hints? > > Cheers, Kuba Hi Kuba, i think you should be able to do what you want with the linker (ld). i did this one time to fix my page directory address, inserting a symbol at a certain address. . = ALIGN(4K); .data.pd : { _pdpr = .; . = . + 0x1000; } And then doing something like: struct PageDirectory { ... } extern (C) char _pdpr; auto pdtr = cast (PageDirectory*) &_pdpr; This was working... Even if it does not resolve your problem completly maybe you can do something like: extern (C) PageDirectory _pdpr; But i did not test it... tell me if it works. -- AF |
November 30, 2009 Re: Access to fixed memory locations, head const, ... | ||||
---|---|---|---|---|
| ||||
Posted in reply to wakko | >> I'm contemplating using D for an embedded project where system configuration registers have fixed memory locations. >> >> One way of doing it would be to have a constant pointer to a structure with manually aligned members that match the register map, and access them like that. This becomes cumbersome, as all accesses look like >> >> struct Regs { >> ... >> }; >> >> Regs* cfg = cast(Regs*)0xF00; >> >> cfg.reg0 = ... >> >> This is also where D's const-transitivity becomes problematic. Since >> the configuration registers are not going anywhere, ideally you'd want >> a way of telling the compiler that the *pointer* is constant, but not >> the pointed-to stuff. >> >> For a systems language, this seems like a serious drawback. Why can't >> I tell the compiler that noone should muck with the cfg pointer's >> value? I presume there can be ways around it via delegates, but this >> seems like a C++ approach: instead of making it simple, it becomes >> convoluted... >> >> >> OTOH, there's a C hack that allows you to access variables at fixed >> memory locations "directly": >> >> #define CFGREG0 (*(unsigned short*)0xBEEF) >> >> I'm an absolute noob to D, and so far I found no way of approximating >> this behavior -- of bringing the configuration registers at a fixed >> memory location into the scope as an identifier that can be used naked, like >> >> CFGREG0 = 0xFF; >> if (CFGREG0 != 3) { ... } > i think you should be able to do what you want with the linker (ld). > i did this one time to fix my page directory address, inserting a symbol at a certain address. > > . = ALIGN(4K); > .data.pd : > { > _pdpr = .; > . = . + 0x1000; > } > > And then doing something like: > > struct PageDirectory > { > ... > } > > extern (C) char _pdpr; > auto pdtr = cast (PageDirectory*) &_pdpr; > > This was working... > > Even if it does not resolve your problem completly maybe you can do something like: > > extern (C) PageDirectory _pdpr; The main reason I'm looking at D is to avoid hacks like this. So the short answer is: no, D does not support it "natively", without some extra syntactic sugar. And all I was really after is to avoid needless sugar in the first place... Cheers, Kuba |
Copyright © 1999-2021 by the D Language Foundation