[IR] Add function pointer alignment to DataLayout

[miyuki]

Summary

The value tracking analysis uses function alignment to infer that the
least significant bits of function pointers are known to be zero.
Unfortunately, this is not correct for ARM targets: the least
significant bit of a function pointer stores the ARM/Thumb state
information (i.e., the LSB is set for Thumb functions and cleared for
ARM functions).

It is still desirable to be able to control the alignment of
functions' code (for example, aligning functions to cache line size
improves I-cache utilization), independently of function pointer
alignment.

This patch adds a new field to the DataLayout structure that stores
the ABI alignment of function pointers and uses it when querying the
alignment.

[miyuki]

I am not entirely sure, if this should be added to the DataLayout class itself or to PointerAlignElem. I decided to go with the former because function pointers are only relevant to program address space (rather than each address space).

[miyuki]

ping

[miyuki]

ping^2

[miyuki]

ping^3

[miyuki]

ping^4

[rogfer01]

docs/LangRef.rst

1948

Perhaps we want to clarify that if it is not specified (or it is zero) function pointers will be aligned as regular pointers ("p" above). Is my interpretation correct here?

[efriedma]

Tracking the alignment of function pointers seems very unlikely to be beneficial in practice; I would rather just assume function pointers are always unaligned.

[miyuki]

Abandoning (https://reviews.llvm.org/D46110 has been committed instead)

docs/LangRef.rst

 ``f<size>:<abi>:<pref>``
     This specifies the alignment for a floating point type of a given bit
     ``<size>``. Only values of ``<size>`` that are supported by the target
     will work. 32 (float) and 64 (double) are supported on all targets; 80
     or 128 (different flavors of long double) are also supported on some
     targets.
 ``a:<abi>:<pref>``
     This specifies the alignment for an object of aggregate type.
+``F<abi>``
+    This specifies the alignment for function pointers.
 ``m:<mangling>``
     If present, specifies that llvm names are mangled in the output. Symbols
     prefixed with the mangling escape character ``\01`` are passed through
     directly to the assembler without the escape character. The mangling style
     options are
 
     * ``e``: ELF mangling: Private symbols get a ``.L`` prefix.
     * ``m``: Mips mangling: Private symbols get a ``$`` prefix.

include/llvm/IR/DataLayout.h

 /// target being codegen'd to.
 class DataLayout {
 private:
   /// Defaults to false.
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
   unsigned StackNaturalAlign;
+  unsigned FunctionPtrAlign;
   unsigned ProgramAddrSpace;
 
   enum ManglingModeT {
     MM_None,
     MM_ELF,
     MM_MachO,
     MM_WinCOFF,
     MM_WinCOFFX86,
public:
   ~DataLayout(); // Not virtual, do not subclass this class
 
   DataLayout &operator=(const DataLayout &DL) {
     clear();
     StringRepresentation = DL.StringRepresentation;
     BigEndian = DL.isBigEndian();
     AllocaAddrSpace = DL.AllocaAddrSpace;
     StackNaturalAlign = DL.StackNaturalAlign;
+    FunctionPtrAlign = DL.FunctionPtrAlign;
     ProgramAddrSpace = DL.ProgramAddrSpace;
     ManglingMode = DL.ManglingMode;
     LegalIntWidths = DL.LegalIntWidths;
     Alignments = DL.Alignments;
     Pointers = DL.Pointers;
     NonIntegralAddressSpaces = DL.NonIntegralAddressSpaces;
     return *this;
   }
public:
   bool isIllegalInteger(uint64_t Width) const { return !isLegalInteger(Width); }
 
   /// Returns true if the given alignment exceeds the natural stack alignment.
   bool exceedsNaturalStackAlignment(unsigned Align) const {
     return (StackNaturalAlign != 0) && (Align > StackNaturalAlign);
   }
 
   unsigned getStackAlignment() const { return StackNaturalAlign; }
+  unsigned getFunctionPtrAlign() const { return FunctionPtrAlign; }
   unsigned getAllocaAddrSpace() const { return AllocaAddrSpace; }
 
   unsigned getProgramAddressSpace() const { return ProgramAddrSpace; }
 
   bool hasMicrosoftFastStdCallMangling() const {
     return ManglingMode == MM_WinCOFFX86;
   }
 

lib/IR/DataLayout.cpp

 
 void DataLayout::reset(StringRef Desc) {
   clear();
 
   LayoutMap = nullptr;
   BigEndian = false;
   AllocaAddrSpace = 0;
   StackNaturalAlign = 0;
+  FunctionPtrAlign = 0;
   ProgramAddrSpace = 0;
   ManglingMode = MM_None;
   NonIntegralAddressSpaces.clear();
 
   // Default alignments
   for (const LayoutAlignElem &E : DefaultAlignments) {
     setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
                  E.TypeBitWidth);
case 'n':  // Native integer types.
           break;
         Split = split(Rest, ':');
       }
       break;
     case 'S': { // Stack natural alignment.
       StackNaturalAlign = inBytes(getInt(Tok));
       break;
     }
+    case 'F': {
+      FunctionPtrAlign = inBytes(getInt(Tok));
+      break;
+    }
     case 'P': { // Function address space.
       ProgramAddrSpace = getAddrSpace(Tok);
       break;
     }
     case 'A': { // Default stack/alloca address space.
       AllocaAddrSpace = getAddrSpace(Tok);
       break;
     }

 }
 
 void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
 
 bool DataLayout::operator==(const DataLayout &Other) const {
   bool Ret = BigEndian == Other.BigEndian &&
              AllocaAddrSpace == Other.AllocaAddrSpace &&
              StackNaturalAlign == Other.StackNaturalAlign &&
+             FunctionPtrAlign == Other.FunctionPtrAlign &&
              ProgramAddrSpace == Other.ProgramAddrSpace &&
              ManglingMode == Other.ManglingMode &&
              LegalIntWidths == Other.LegalIntWidths &&
              Alignments == Other.Alignments && Pointers == Other.Pointers;
   // Note: getStringRepresentation() might differs, it is not canonicalized
   return Ret;
 }
 

lib/IR/Value.cpp

uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
   return DerefBytes;
 }
 
 unsigned Value::getPointerAlignment(const DataLayout &DL) const {
   assert(getType()->isPointerTy() && "must be pointer");
 
   unsigned Align = 0;
   if (auto *GO = dyn_cast<GlobalObject>(this)) {
+    if (isa<Function>(GO))
+      Align = DL.getFunctionPtrAlign();
+    if (Align == 0)
       Align = GO->getAlignment();
     if (Align == 0) {
       if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
         Type *ObjectType = GVar->getValueType();
         if (ObjectType->isSized()) {
           // If the object is defined in the current Module, we'll be giving
           // it the preferred alignment. Otherwise, we have to assume that it
           // may only have the minimum ABI alignment.
           if (GVar->isStrongDefinitionForLinker())

lib/Target/ARM/ARMTargetMachine.cpp

else
     // Big endian.
     Ret += "E";
 
   Ret += DataLayout::getManglingComponent(TT);
 
   // Pointers are 32 bits and aligned to 32 bits.
   Ret += "-p:32:32";
 
+  // Function pointers are aligned to 8 bits (because the LSB stores the
+  // ARM/Thumb state).
+  Ret += "-F8";
+
   // ABIs other than APCS have 64 bit integers with natural alignment.
   if (ABI != ARMBaseTargetMachine::ARM_ABI_APCS)
     Ret += "-i64:64";
 
   // We have 64 bits floats. The APCS ABI requires them to be aligned to 32
   // bits, others to 64 bits. We always try to align to 64 bits.
   if (ABI == ARMBaseTargetMachine::ARM_ABI_APCS)
     Ret += "-f64:32:64";

test/Analysis/ValueTracking/func-ptr-lsb.ll

+; RUN: opt -instcombine -S < %s | FileCheck %s
+
+target datalayout = "e-p:32:32-n32-S64-F8"
+
+; CHECK-LABEL: @foo_ptr
+; CHECK: and
+define i32 @foo_ptr() {
+entry:
+  ret i32 and (i32 ptrtoint (void ()* @foo to i32), i32 -4)
+}
+
+define internal void @foo() align 16 {
+entry:
+  ret void
+}