• State Not Answered
  • Locked Locked
  • Replies 36 replies
  • Subscribers 21 subscribers
  • Views 20985 views
  • Users 0 members are here
2025 survey

We are running a survey to help us improve the experience for all of our members. If you see the survey appear, please take the time to tell us about your experience if you can.

Options
Related
How was your experience today?
This discussion has been locked.
You can no longer post new replies to this discussion. If you have a question you can start a new discussion

Hard fault at misaligned memcpy memset

Werner Meier

we made some simple tests with STM32F100 Value Line Eval Board:

//------------------------------------------------------------------------------
// Variables
static unsigned char sDstBuf[1024]; // 1KiB
static unsigned char sSrcBuf[sizeof(sDstBuf)];

printf("Copying words from misaligned src to aligned dst buffer... ");
memset(sDstBuf, 0xcd, sizeof(sDstBuf));

with optimize Level 3, optimize for time this takes
120usec

with optimize Level 0
155usec

almost the same if memcpy is used:
memcpy(sDstBuf, (const void *)0xcd, sizeof(sDstBuf));

It runs into hard fault, if optimize Level >=1 and optimise for time is not set.

I think this is a compiler error..

We ran into this before with MDK 4.60, now we use 4.70A

Werner

Parents
  • 0 in reply to Werner Meier

    with optimise >=1 it produces the first (offending code)
    with optimise 0 the second code is produced (which works fine)

    Optimisation very often breaks flawed code.

    the offending code is

        for (pDstWord = (unsigned int*) (sDstBuf + 0), // Aligned!
    pSrcWord = (unsigned int*) (sSrcBuf + 1);
        // Misaligned!
        pSrcWord
            < (unsigned int*) (sSrcBuf + sizeof(sSrcBuf) - sizeof(*pSrcWord));
        pSrcWord++)
    {
        *pDstWord = *pSrcWord;
    }

    How are you sure that those casts don't end up giving you unaligned addresses...?

Reply
  • 0 in reply to Werner Meier

    with optimise >=1 it produces the first (offending code)
    with optimise 0 the second code is produced (which works fine)

    Optimisation very often breaks flawed code.

    the offending code is

        for (pDstWord = (unsigned int*) (sDstBuf + 0), // Aligned!
    pSrcWord = (unsigned int*) (sSrcBuf + 1);
        // Misaligned!
        pSrcWord
            < (unsigned int*) (sSrcBuf + sizeof(sSrcBuf) - sizeof(*pSrcWord));
        pSrcWord++)
    {
        *pDstWord = *pSrcWord;
    }

    How are you sure that those casts don't end up giving you unaligned addresses...?

Children