How to detect stack alignment at runtime?

Question

4.50/5 (2 votes)

See more:

I'm looking to detect whether the stack is 8-byte or 16-byte aligned with some portable code. I know it will be 16-byte aligned on 64bit OS and on recent versions of Linux/BSD/OSX but I'd rather have a reliable empirical way of determining it than rely on an OS based heuristic or lookup. No per-new-OS changes are allowed in the module I'm currently working on.

So far:

bool isStack16ByteAligned()
{
  bool bResult = ( sizeof( Cmp_uint_ptr ) == 8 ) ? true : false;

  //...

  return bResult;
}

Any solution that gets used will be credited in my next QOR series article :-)

Posted 14-Mar-13 5:19am

Matthew Faithfull

Add a Solution

Comments

Sergey Alexandrovich Kryukov 14-Mar-13 12:24pm

Pretty interesting tricky question, but the idea to write code depending on such things is quite questionable. So, I voted 4 for the question. :-)
—SA

3 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Accepted Answer · 2013-03-14T06:21:00

Here is the simple idea: declare some local variables of primitive types (I would suggest a single byte followed by a 16- or 32-bit integer, please see below), so the memory for them will be reserved on a current stack frame. Get pointers to those objects, cast the pointers to unsigned integer type and compare the numbers.

This may be not so simple though. First, those variables may be optimized out, you should prevent it. As you may need this code working even if optimization is applied, you will need to prevent optimizing the variables out by using them somehow. The problem can be more difficult if the optimizer tries to violate ("optimize") 16-bit alignment by packing some memory area (for example, if several separate byte-size stack variables are detected) as it was 8-bit alignment. I don't really know if some compilers do such things, so this is a potential danger to your method portability. You can easily find it out if you experimenting with each particular compiler, but you cannot predict the behavior of any unknown compiler. You also should understand that optimization can reorder the location of objects on stack. I really don't know how likely such behavior might be. Only I remember that when C++ compilers worked not in modern flat model but used real-mode segments/offsets, they did much more complex memory tricks in certain data presentation modes.

To prevent the effect of such byte packing I speculated about above, you could combine the sized of objects. A byte followed by integer as I mentioned in the first paragraph should be a candidate to do the trick, but you should analyze it all more thoroughly them I did and learn disassembled code with or without optimization and other options, so you may want to think of something more reliable. If the optimization reorders object locations on stack, you need take this possibility into account. Just think thoroughly about it.

As a final note, I would say that any technique relying on stack alignment is potentially dangerous in principle and generally should not be used. The issue is not how to determine the alignment type option, but what you are going to do with this result, and how reliable this technique could be. So, I'm just curious about your idea.

—SA

nv3 · Accepted Answer · 2013-03-14T08:59:00

Matthew, from your answers in this forum I recall that you are one of the experienced guys around here. So, please treat my answer just as a suggestion and it might just complement what you found out yourself so far.

Let's first clarify, what exactly is meant by stack alignment. I'd define it as:

The minimum size the CPU uses for a push operation.

By that definition, I would stay away from comparing the addresses of stack-based variables. A compiler generally allocates the local variables of a function by just subtracting the required total size from the stack pointer. Inside that memory contingent it arranges variables just as it likes, using packing, reordering, etc. So, the address difference of two single-byte variables might very well be 1, or -1, or anything else.

What I would try to use is the sequence in which the compiler pushed arguments on the stack. Usually that will be either left to right or right to left, but in any case in strict sequence. That you can build upon, because otherwise the var_args mechanism would not work or at least would be very hard to implement.

So I'd write a little function like this:

C++

UINT ArgAddressDiff (char arg1, char arg2, ...)
{
    return abs (&arg1 - &arg2);
}

Optimization might put the arguments into registers, though. That's the reason I included the "..." varg_args declarator. That might prevent such an optimization, but I am not sure.

You could also try to pass the two arguments as the variable arguments of the function, in which the compiler has no chance to optimize them away. That would require some tweeking with the va_list and va_start macros. I haven't tried that yet, though.

I hope that contributes somewhat to your solution.

Matthew Faithfull · Accepted Answer · 2013-03-14T10:46:00

It turns out that although the stack alignment is controlled by the compiler it is determined ultimately by the target OS. Not entirely surprising when you think about it as this is a process under that OS that has to call and be called by the OS.
It would seem then that the only 'correct' solution is an interface on the OS support library to retrieve the correct value for stack alignment rather then trying to calculate it. Not the solution that I wanted but one at least that will work without breaking the design.

How to detect stack alignment at runtime?

3 solutions

Solution 1

Solution 2

Solution 3

Add your solution here

Preview 0