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

64 bit math novice question

Hello,

I am new and I would highly appreciate help for a 64 Bit math question:
signed long long Off = 0;
signed long long u = 0;
unsigned int psensor_c2 = 0;
unsigned int psensor_c4 = 0;
signed int dT = 0;
int i = 0;

i = psensor_c2 << 16; // i = f.e. 0x012345

u = ((signed long long) (psensor_c4 * dT)) / 128; // u = 0x900000

line3: Off = (signed long long) 0x900000 + 0x012345;
line4: Off = (signed long long) i + u;

line3 gives me as result 0x912345
line4 gives me as result 0xffffffff00912345

My problem is: I have a signed integer with a maximum of 40 Bit length. So I need 64 Bit math. And I tell this the compiler with the hint (signed long long).
Why does exactly the same line of code give different results ? I expect the line3 result and don t understand why in line 4 the ffffffff are added for the high word.

Do the experts recommend me to write this in assembler, so that I can be sure that it is done exactly the way I want to have my 64 Bit math. Or are there compiler specialist, who know, how to tell the compiler, that he should add a signed 64 bit value to a 32 bit integer.

Any hints are welcome.

Parents
  • Line 3 involves only constants. Chances are that the compiler simply assigns the result to Off. If you know enough about ARM assembler to expect an SMULL instruction, why don't you tell us what the compiler generates instead? All I can tell is that the result seems fine here.

    signed long long mult64_32_32 (signed long a, signed long b)
    {
        return (signed long long)a * b; // same when casting both operators
    }
    

    mult64_32_32 PROC
            MOV      r2,r0
            SMULL    r0,r1,r2,r1
            BX       lr
            ENDP
    

    Regards
    Marcus
    http://www.doulos.com/arm/

Reply
  • Line 3 involves only constants. Chances are that the compiler simply assigns the result to Off. If you know enough about ARM assembler to expect an SMULL instruction, why don't you tell us what the compiler generates instead? All I can tell is that the result seems fine here.

    signed long long mult64_32_32 (signed long a, signed long b)
    {
        return (signed long long)a * b; // same when casting both operators
    }
    

    mult64_32_32 PROC
            MOV      r2,r0
            SMULL    r0,r1,r2,r1
            BX       lr
            ENDP
    

    Regards
    Marcus
    http://www.doulos.com/arm/

Children
  • Due to your help I could figure out my problem.
    It has been not, where I expected the problem.
    I used for my debugging purposes unfortunately just i (which simply has been declared as int).
    But that has been the root cause, for all followup failures.
    All math works fine, if I declare i in my code as unsigned int. (which it should be)
    I am sorry about such a novice mistake, which causes so much confusion to me.

    Thanks again for your goodwill to help me as novice.

  • The good thing is, hopefully, that you have learned a few things in the process?

    Particularly about the handling & representation of signed numbers?