Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > __unaligned before and after the * (64bit)

Reply
Thread Tools

__unaligned before and after the * (64bit)

 
 
Udi
Guest
Posts: n/a
 
      03-19-2008
Hi All,
I'm not sure I understand the difference between placing the
__unaligned before or after the *:
I was trying to handle the C4366 warning - "The result of the unary
'&' operator may be unaligned") and used the '__unaligned' modifier as
suggested,
but ended up with C4090 - "different '__unaligned' qualifiers". (See
below)
However, moving the __unaligned keyword after the ' * '
solved the warning but I'm not sure I solved the probelm.


with no __unaligned keyword --> Warning C4366
`````````````````````````````````````````````````` `````````````````````
void List_Clear(List *pList) ;
:
List * pSubscribersList = NULL;

pSubscribersList = (List *)&(p->subscribersList); //C4366: The result
of the unary '&' operator may be unaligned
List_Clear(pSubscribersList);




__unaligned before the * --> warning C4090
`````````````````````````````````````````````````` `````````````
void List_Clear(List *pList) ;
:
List __unaligned * pSubscribersList = NULL;

pSubscribersList = (List __unaligned *)&(p->subscribersList);
List_Clear(pSubscribersList); //warning C4090: 'function' : different
'__unaligned' qualifiers


__unaligned after the * --> no warnings
`````````````````````````````````````````````````` ``````
void List_Clear(List *pList) ;
:
List * __unaligned pSubscribersList = NULL;

pSubscribersList = (List * __unaligned)&(p->subscribersList);
List_Clear(pSubscribersList); // OK - no warning



Can anyone explain what's the difference between the last two
examples?
I'm using VS2005 compiling to 64 bit.
Thanks!
 
Reply With Quote
 
 
 
 
Nick Keighley
Guest
Posts: n/a
 
      03-19-2008
On 19 Mar, 08:53, Udi <(E-Mail Removed)> wrote:

> I'm not sure I understand the difference between placing the
> __unaligned before or after the *:


<snip>

> I'm using VS2005 compiling to 64 bit.


__unaligned isn't part of standard C. You needd to ask ona compler
specific news group. Try I Microsoft related ng.


--
Nick Keighley


 
Reply With Quote
 
 
 
 
Keith Thompson
Guest
Posts: n/a
 
      03-19-2008
Nick Keighley <(E-Mail Removed)> writes:
> On 19 Mar, 08:53, Udi <(E-Mail Removed)> wrote:
>
>> I'm not sure I understand the difference between placing the
>> __unaligned before or after the *:

>
> <snip>
>
>> I'm using VS2005 compiling to 64 bit.

>
> __unaligned isn't part of standard C. You needd to ask ona compler
> specific news group. Try I Microsoft related ng.


Better yet, re-write the code to avoid the need to use __unaligned.
The original poster appears to be writing code for a linked list.
There's no need to use any implementation-specific extensions for such
a relatively straightforward task.

Apparently the compiler's warning "The result of the unary '&'
operator may be unaligned" included a suggestion to use __unaligned.
I strongly suspect that suggestion was a poor one.

--
Keith Thompson (The_Other_Keith) <(E-Mail Removed)>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
 
Reply With Quote
 
Ulrich Eckhardt
Guest
Posts: n/a
 
      03-19-2008
Udi wrote:
> I'm not sure I understand the difference between placing the
> __unaligned before or after the *:


I guess, it works like 'const', which applies to the left unless it is at
the leftmost side, then it applies to the right. However, it is, as others
pointed out, non-standard, so you have to consult the compiler docs.

> I was trying to handle the C4366 warning - "The result of the unary
> '&' operator may be unaligned") and used the '__unaligned' modifier as
> suggested, but ended up with C4090 - "different '__unaligned' qualifiers".
> (See below)
> However, moving the __unaligned keyword after the ' * '
> solved the warning but I'm not sure I solved the probelm.


I don't think so...

>


> void List_Clear(List *pList) ;
> :
> List * pSubscribersList = NULL;
>
> pSubscribersList = (List *)&(p->subscribersList); //C4366: The result
> of the unary '&' operator may be unaligned


Well, the first problem here is that you are using casts, which is typically
a sign that something's wrong. Remove those, and you won't need any
unaligned attributes. If it doesn't compile then, your types simply don't
match, but adding them doesn't change that. If you can't do it yourself or
want to verify the solution is correct, please boil your problem down to a
minimal but complete example, in particular guessing
what 'p->subscribersList' could be is pretty hart.

Uli

 
Reply With Quote
 
Udi
Guest
Posts: n/a
 
      03-23-2008
On Mar 19, 11:18*pm, Ulrich Eckhardt <(E-Mail Removed)> wrote:
> Udiwrote:
> > I'm not sure I understand the difference between placing the
> > __unaligned before or after the *:

>
> I guess, it works like 'const', which applies to the left unless it is at
> the leftmost side, then it applies to the right. However, it is, as others
> pointed out, non-standard, so you have to consult the compiler docs.
>
> > I was trying to handle the C4366 warning - "The result of the unary
> > '&' operator may be unaligned") and used the '__unaligned' modifier as
> > suggested, but ended up with C4090 - "different '__unaligned' qualifiers".
> > (See below)
> > However, moving the __unaligned keyword after the ' * '
> > solved the warning but I'm not sure I solved the probelm.

>
> I don't think so...
>
>
>
> > void List_Clear(List *pList) ;
> > :
> > List ** pSubscribersList = NULL;

>
> > pSubscribersList = (List *)&(p->subscribersList); //C4366: The result
> > of the unary '&' operator may be unaligned

>
> Well, the first problem here is that you are using casts, which is typically
> a sign that something's wrong. Remove those, and you won't need any
> unaligned attributes. If it doesn't compile then, your types simply don't
> match, but adding them doesn't change that. If you can't do it yourself or
> want to verify the solution is correct, please boil your problem down to a
> minimal but complete example, in particular guessing
> what 'p->subscribersList' could be is pretty hart.
>
> Uli


Thanks All,
I agree I shouldn't use the __unaligned, that's why I'm writing to
figure out how.

Here are the full types and example:

typedef struct
{
HANDLE hAccess; // Mutex
HANDLE hCanRead; // Event
HANDLE hCanWrite; // Event
HANDLE hWriterMutex; // Mutex
DWORD dwTlsSlot;

DWORD dwTotalReaderThreads;
DWORD dwTotalWriterThreads;
} tReadWriteLock;

typedef struct _ListItem
{
void *pData;
struct _ListItem *pNextItem;
} ListItem;

typedef struct
{
ListItem *pHead;
DWORD dwLength;
tReadWriteLock *pLock;
} List;

typedef struct
{
DWORD id;
List subscribersList;
} IndicatorSubscribers;


with no __unaligned keyword --> Warning C4366
`````````````````````````````````````````````````` `````````````````````
void List_Clear(List *pList) ;
:
List * pSubscribersList = NULL;


pSubscribersList = (List *)&(p->subscribersList); //C4366: The result
of the unary '&' operator may be unaligned
List_Clear(pSubscribersList);


__unaligned before the * --> warning C4090
`````````````````````````````````````````````````` `````````````
void List_Clear(List *pList) ;
:
List __unaligned * pSubscribersList = NULL;


pSubscribersList = (List __unaligned *)&(p->subscribersList);
List_Clear(pSubscribersList); //warning C4090: 'function' : different
'__unaligned' qualifiers


__unaligned after the * --> no warnings
`````````````````````````````````````````````````` ``````
void List_Clear(List *pList) ;
:
List * __unaligned pSubscribersList = NULL;


pSubscribersList = (List * __unaligned)&(p->subscribersList);
List_Clear(pSubscribersList); // OK - no warning




As you can see these are all pretty simple typedefs.
So the 'p' in 'p->subscribersList' is of type 'IndicatorSubscribers'.

Any ideas now?
(Still I didn't get the difference between placing the __unaligned
before and after the *.)

Thanks,
Udi


 
Reply With Quote
 
Flash Gordon
Guest
Posts: n/a
 
      03-23-2008
Udi wrote, On 23/03/08 07:11:

<snip>

> typedef struct
> {
> ListItem *pHead;
> DWORD dwLength;
> tReadWriteLock *pLock;
> } List;
>
> typedef struct
> {
> DWORD id;
> List subscribersList;
> } IndicatorSubscribers;
>
>
> with no __unaligned keyword --> Warning C4366
> `````````````````````````````````````````````````` `````````````````````
> void List_Clear(List *pList) ;
> :
> List * pSubscribersList = NULL;
>
>
> pSubscribersList = (List *)&(p->subscribersList); //C4366: The result
> of the unary '&' operator may be unaligned
> List_Clear(pSubscribersList);


<snip>

> Any ideas now?
> (Still I didn't get the difference between placing the __unaligned
> before and after the *.)


Start off by getting rid of ALL of the casts. Doing the sort of thing it
looks like you are trying to do does not require casts if you do it
correctly. Then produce a small *complete* compilable example that gives
the warning, preferably without using "//" style comments as they do not
survive line wrapping. Your example obviously is not complete as you
have code that is not inside a function.
--
Flash Gordon
 
Reply With Quote
 
Ben Bacarisse
Guest
Posts: n/a
 
      03-23-2008
Udi <(E-Mail Removed)> writes:

> On Mar 19, 11:18*pm, Ulrich Eckhardt <(E-Mail Removed)> wrote:

<snip>
>> Well, the first problem here is that you are using casts, which is typically
>> a sign that something's wrong. Remove those, and you won't need any
>> unaligned attributes.

<snip>
> I agree I shouldn't use the __unaligned, that's why I'm writing to
> figure out how.


But you left the cast.

> typedef struct
> {
> DWORD id;
> List subscribersList;
> } IndicatorSubscribers;
>
>
> with no __unaligned keyword --> Warning C4366
> `````````````````````````````````````````````````` `````````````````````
> void List_Clear(List *pList) ;
> :
> List * pSubscribersList = NULL;
>
>
> pSubscribersList = (List *)&(p->subscribersList); //C4366: The result
> of the unary '&' operator may be unaligned

<snip>
> As you can see these are all pretty simple typedefs.
> So the 'p' in 'p->subscribersList' is of type
> 'IndicatorSubscribers'.


You did not show the definition of p. If it is of type pointer to
IndicatorSubscribers, and the line in question gives you an error when
you remove the cast (it is not needed -- trust me!) then the problem
is elsewhere.

Most likely, something like a #pragma elsewhere or a compiler option
is causing the compiler to pack the structure in a way that violates
the assurances given by the language standard. If that is the case
(and you can't change it) you will have to use something non-standard
to solve the problem.

--
Ben.
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
use of __unaligned on a pointer to pointer Zorro C++ 5 07-26-2008 06:00 PM
is there a hardware / driver combination out there the lets win2k connect to the network before login?? christiane kewitz Wireless Networking 1 02-13-2005 01:08 AM
Before Sunset & Before Sunrise matt r DVD Video 2 11-25-2004 08:37 AM
Re: custom back button before and after postback Natty Gur ASP .Net 0 05-12-2004 06:57 AM
Identifying the data difference before and After PostBack Dinesh Upare ASP .Net 0 11-07-2003 10:37 AM



Advertisments