Add comment to scatter-bit operation, make it faster and rename it.

[ruiu]

Summary

Also swap the parameter position to make it consistent with
__builtin_ia32_pdep_si.

[sidneym]

lld/ELF/Arch/Hexagon.cpp

57

The comment above is helpful but I'll be honest and say that the above line wouldn't be the first thing to pop into my head.

[ruiu]

• restore the original code
• renamed Result -> Ret for consistency with other functions

[ruiu]

• Actually, after I rename variables to be more lld-ish and rearranges so that it doesn't compute unnecessary temporary results, it looks similar to my code, but what this does is the same as your code.

lld/ELF/Arch/Hexagon.cpp

RelExpr getRelExpr(RelType Type, const Symbol &S,
                      const uint8_t *Loc) const override;
   void relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const override;
 };
 } // namespace
 
 // Support V60 only at the moment.
 uint32_t Hexagon::calcEFlags() const { return 0x60; }
 
-static uint32_t applyMask(uint32_t Mask, uint32_t Data) {
-  uint32_t Result = 0;
-  size_t Off = 0;
-
-  for (size_t Bit = 0; Bit != 32; ++Bit) {
-    uint32_t ValBit = (Data >> Off) & 1;
-    uint32_t MaskBit = (Mask >> Bit) & 1;
-    if (MaskBit) {
-      Result |= (ValBit << Bit);
-      ++Off;
-    }
-  }
-  return Result;
+// This function scatter Val's bits as instructed by Mask.
+// Here is an example:
+//
+//  Val:    abcd efgh ijkl mnop
+//  Mask:   1110 0001 1111 0001
+//  Result: hij0 000k lmno 000p
+//
+// Some CPUs support this operation as a single instruction.
+// For example, Intel BMI2 extension has this operation as PDEP.
+static inline uint32_t scatter(uint32_t Val, uint32_t Mask) {
+  uint32_t Ret = 0;
+  size_t I = 0;
+
+  for (size_t J = 0; J != 32; ++J)
+    if ((Mask >> J) & 1)
+      Ret |= ((Val >> I++) & 1) << J;
+  return Ret;
 }
 
 RelExpr Hexagon::getRelExpr(RelType Type, const Symbol &S,
                             const uint8_t *Loc) const {
   switch (Type) {
   case R_HEX_B22_PCREL:
     return R_PC;
   default:
     return R_ABS;
   }
 }
 
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 
 void Hexagon::relocateOne(uint8_t *Loc, RelType Type, uint64_t Val) const {
   switch (Type) {
   case R_HEX_NONE:
     break;
   case R_HEX_B22_PCREL:
-    or32le(Loc, applyMask(0x1ff3ffe, Val >> 2));
+    or32le(Loc, scatter(Val >> 2, 0x1ff3ffe));
     break;
   default:
     error(getErrorLocation(Loc) + "unrecognized reloc " + toString(Type));
     break;
   }
 }
 
 TargetInfo *elf::getHexagonTargetInfo() {
   static Hexagon Target;
   return &Target;
 }