longlong FUN0801f724(uint param1,uint param2) { bool bVar1; uint uVar2; int iVar3; int…
- User
longlong FUN_0801f724(uint param_1,uint param_2)
{ bool bVar1; uint uVar2; int iVar3; int iVar4; uint uVar5; uint uVar6; uint uVar7; bool bVar8; bool bVar9;
if (-1 < (int)(param_1 ^ param_2)) { iVar4 = param_1 - param_2; if (param_1 < param_2) { param_1 = param_1 - iVar4; param_2 = param_2 + iVar4; } uVar7 = (param_1 << 1) >> 0x18; uVar5 = param_2; if (uVar7 != 0xff) { uVar2 = (param_2 << 1) >> 0x18; if (uVar2 == 0) { uVar5 = param_2 << 9; if (uVar5 == 0 || uVar7 == 0) { param_1 = param_1 + (param_2 & 0x7fffff); goto LAB_080236da; } uVar2 = 0x17 - uVar7; if ((int)uVar2 < 0) goto LAB_080236ee; } else { uVar7 = uVar7 - uVar2; uVar2 = 0x19 - uVar7; if (uVar2 == 0 || 0x19 < (int)uVar7) { LAB_080236ee: return CONCAT44(uVar5,param_1); } uVar5 = param_2 << 8 | 0x80000000; } uVar6 = uVar5 & ~(-0x80000000 >> (uVar2 & 0xff)); uVar5 = uVar5 >> (uVar7 & 0xff); uVar7 = param_1 << 8 | 0x80000000; uVar2 = uVar7 + uVar5; if (!CARRY4(uVar7,uVar5)) { uVar2 = uVar2 & 0x7fffffff; } if (CARRY4(uVar7,uVar5)) { uVar2 = uVar2 >> 1 | 0x80000000; } uVar6 = uVar6 | uVar2 << 0x18; param_1 = (param_1 & 0xff800000) + (uVar2 >> 8) + (uint)(0x80000000 < uVar6 || uVar6 + 0x80000000 < (uint)((byte)(uVar2 >> 8) & 1)); if (param_1 * 2 < 0xff000000) { return CONCAT44(uVar5,param_1); } param_1 = param_1 & 0xff800000; } LAB_080236da: return CONCAT44(uVar5,param_1); } param_2 = param_2 ^ 0x80000000; if (param_1 < param_2) { uVar5 = param_1 - param_2 ^ 0x80000000; param_1 = param_1 - uVar5; param_2 = param_2 + uVar5; } uVar7 = param_1 >> 0x17; bVar8 = 0xfeffffff < param_1 << 1; bVar9 = param_2 << 1 < 0x1000001; uVar5 = param_1; if (bVar8 || bVar9) { if (param_1 << 1 < 0xff000000) { if ((param_2 & 0x7fffffff) != 0) { uVar6 = uVar7 - (param_2 >> 0x17); if (1 < (int)uVar6) { param_2 = param_2 << 9; if (0x17 < (int)uVar6) { return CONCAT44(param_2,param_1); } LAB_0801f7a8: uVar5 = param_2 >> (uVar6 & 0xff); if (uVar5 << (uVar6 & 0xff) < param_2) { uVar5 = uVar5 | 1; } uVar2 = param_1 * 0x200 - uVar5; if (param_1 * 0x200 < uVar5) { uVar2 = uVar2 * 2; uVar7 = uVar7 - 1; } bVar8 = (uVar2 & 0x200) != 0; uVar5 = uVar2 * 0x800000; return CONCAT44((uVar5 + 0x80000000) - (uint)!bVar8, uVar7 * 0x800000 + (uVar2 >> 9) + (uint)(0x80000000 < uVar5 || uVar5 + 0x80000000 < (uint)bVar8)); } param_2 = param_2 & 0x7fffffff; param_1 = param_1 - param_2; } uVar5 = param_1; if ((param_1 & 0x7fffffff) == 0) { return (ulonglong)param_2 << 0x20; } } else if (0xfeffffff < param_2 << 1) { return CONCAT44(param_2,0xffffffff); } } else { uVar2 = param_2 >> 0x17; bVar1 = uVar7 - uVar2 < (uint)(bVar8 || bVar9); uVar6 = (uVar7 - uVar2) - (uint)(!bVar8 && !bVar9); if (uVar2 < uVar7 || bVar1) { param_2 = param_2 << 8 | 0x80000000; if ((uVar2 < uVar7 || bVar1) && uVar6 != 0) { if ((int)uVar6 < 0x19) goto LAB_0801f7a8; goto LAB_0801f7a2; } uVar5 = param_1 * 0x200 - param_2; if (param_2 <= param_1 * 0x200) { bVar8 = (uVar5 >> 8 & 1) != 0; if (bVar8) { param_2 = uVar5 >> 10; } return CONCAT44(param_2,(uVar5 >> 9) + uVar7 * 0x800000 + (uint)(bVar8 && (uVar5 >> 9 & 1) != 0)); } } else { uVar5 = param_1 - param_2; if (uVar5 == 0) goto LAB_0801f7a2; uVar5 = uVar5 * 0x200; } iVar3 = LZCOUNT(uVar5) + 1; uVar2 = (uVar5 << iVar3) >> 9; iVar4 = (int)param_1 >> 0x1f; uVar5 = -iVar4 | uVar7 << 0x18; uVar7 = uVar5 + iVar3 * -0x1000000; if (uVar5 < (uint)(iVar3 * 0x1000000) || uVar7 == 0) { uVar5 = (uVar2 | 0x800000) >> (1U - ((int)uVar7 >> 0x18) & 0xff) | iVar4 * -0x80000000; } else { uVar5 = uVar2 + (uVar7 >> 1 | iVar4 * -0x80000000); } } LAB_0801f7a2: return CONCAT44(param_2,uVar5); }
Assistant
The provided code is a decompiled version of a function written in assembly language, likely from a binary executable. The function appears to be implementing a floating-point division operation.
Here's a refactored version of the code in C, with improvements in readability and structure:
#include <stdint.h> // Assuming uint is an unsigned 32-bit integer and ulonglong is an unsigned 64-bit integer typedef uint32_t uint; typedef uint64_t ulonglong; // Function to count leading zeros int LZCOUNT(uint x) { int count = 0; while (x > 0) { x >>= 1; count++; } return 32 - count; } // Main function ulonglong FUN_0801f724(uint param_1, uint param_2) { int sign = (int)(param_1 ^ param_2) >> 31; // Check if the signs of the two numbers are the same if (sign == 0) { // If the signs are the same, perform the division uint dividend = param_1; uint divisor = param_2; // Normalize the divisor int divisor_shift = (int)((divisor << 1) >> 24); if (divisor_shift == 0) { divisor <<= 9; if ((dividend << 1) < 0xff000000) { return ((ulonglong)divisor << 32) | dividend; } } // Perform the division int shift = (int)((dividend << 1) >> 24) - divisor_shift; if (shift >= 0 && shift < 25) { uint quotient = dividend / (divisor >> (24 - shift)); uint remainder = dividend - quotient * (divisor >> (24 - shift)); return ((ulonglong)remainder << 32) | quotient; } // Handle edge cases if ((dividend & 0x7fffffff) == 0) { return (ulonglong)divisor << 32; } if ((divisor & 0x7fffffff) == 0) { return ((ulonglong)0xffffffff << 32) | dividend; } // Perform the division using a different method uint uVar5 = dividend; uint uVar2 = divisor >> 17; int uVar6 = (int)((dividend >> 17) - uVar2); if (uVar6 > 1) { divisor <<= 9; uVar5 = divisor >> uVar6; if ((uVar5 << uVar6) < divisor) { uVar5 |= 1; } uint uVar7 = (dividend * 2) - uVar5; if ((dividend * 2) < uVar5) { uVar7 *= 2; uVar6 -= 1; } int bVar8 = (uVar7 & 0x200) != 0; uVar5 = uVar7 * 0x800000; return ((ulonglong)((uVar5 + 0x80000000) - (uint)!bVar8) << 32) | ((uVar6 * 0x800000) + (uVar7 >> 9) + (uint)(0x80000000 < uVar5 || uVar5 + 0x80000000 < (uint)bVar8)); } // Handle edge cases return ((ulonglong)divisor << 32) | uVar5; } else { // If the signs are different, perform the division with the correct sign param_2 ^= 0x80000000; if (param_1 < param_2) { uint uVar5 = param_1 - param_2; param_1 -= uVar5; param_2 += uVar5; } // Perform the division uint uVar7 = param_1 >> 17; uint uVar5 = param_1; uint uVar2 = param_2 >> 17; int uVar6 = (int)(uVar7 - uVar2); if (uVar2 < uVar7 || uVar6 > 0) { param_2 = (param_2 << 8) | 0x80000000; if (uVar6 != 0 && uVar6 < 25) { uVar5 = param_2 >> uVar6; if ((uVar5 << uVar6) < param_2) { uVar5 |= 1; } uint uVar7 = (param_1 * 2) - uVar5; if ((param_1 * 2) < uVar5) { uVar7 *= 2; uVar6 -= 1; } int bVar8 = (uVar7 & 0x200) != 0; uVar5 = uVar7 * 0x800000; return ((ulonglong)((uVar5 + 0x80000000) - (uint)!bVar8) << 32) | ((uVar6 * 0x800000) + (uVar7 >> 9) + (uint)(0x80000000 < uVar5 || uVar5 + 0x80000000 < (uint)bVar8)); } } // Handle edge cases uint uVar5 = param_1 - param_2; if (uVar5 == 0) { return ((ulonglong)param_2 << 32); } // Perform the division using a different method uVar5 *= 0x200; int iVar3 = LZCOUNT(uVar5) + 1; uVar2 = (uVar5 << iVar3) >> 9; int iVar4 = (int)param_1 >> 31; uVar5 = (uint)(-iVar4 | (int)uVar7 << 18) + (uint)(iVar3 * -0x1000000); if (uVar5 < (uint)(iVar3 * 0x1000000)) { uVar5 = (uVar2 | 0x800000) >> (1U - ((int)uVar5 >> 18)) | (uint)(iVar4 * -0x80000000); } else { uVar5 = uVar2 + (uVar5 >> 1 | (uint)(iVar4 * -0x80000000)); } return ((ulonglong)param_2 << 32) | uVar5; } }The code appears to be implementing a floating-point division operation using a combination of bit manipulation and arithmetic operations. The function takes two 32-bit unsigned integers as input and returns a 64-bit unsigned integer representing the result of the division.
The code is complex and has many edge cases, but it can be broken down into several main components:
- Checking the signs of the two input numbers and determining the sign of the result.
- Normalizing the divisor to ensure that it is in a suitable range for the division operation.
- Performing the division using a combination of bit manipulation and arithmetic operations.
- Handling edge cases, such as division by zero or overflow.
The code uses various bit manipulation techniques, such as shifting and masking, to extract and manipulate the bits of the input numbers. It also uses arithmetic operations, such as multiplication and subtraction, to perform the division.
Overall, the code is a complex implementation of a floating-point division operation, and it requires a good understanding of bit manipulation and arithmetic operations to fully comprehend.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.