PNaCl SIMD: allow element-aligned vector load/store

lib/Analysis/NaCl/PNaClABIVerifyFunctions.cpp

 //===- PNaClABIVerifyFunctions.cpp - Verify PNaCl ABI rules ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Verify function-level PNaCl ABI requirements.
@@ skipping 38 matching lines @@
     initializePNaClABIVerifyFunctionsPass(*PassRegistry::getPassRegistry());
   }
   ~PNaClABIVerifyFunctions() {
     if (ReporterIsOwned)
       delete Reporter;
   }
   virtual bool doInitialization(Module &M) {
     AtomicIntrinsics.reset(new NaCl::AtomicIntrinsics(M.getContext()));
     return false;
   }
+  virtual void getAnalysisUsage(AnalysisUsage &Info) const {
+    Info.setPreservesAll();
+    Info.addRequired<DataLayout>();
+  }
   bool runOnFunction(Function &F);
   virtual void print(raw_ostream &O, const Module *M) const;
  private:
   bool IsWhitelistedMetadata(unsigned MDKind);
-  const char *checkInstruction(const Instruction *Inst);
+  const char *checkInstruction(const DataLayout *DL, const Instruction *Inst);
   PNaClABIErrorReporter *Reporter;
   bool ReporterIsOwned;
   OwningPtr<NaCl::AtomicIntrinsics> AtomicIntrinsics;
 };
 
 } // and anonymous namespace
 
 // There's no built-in way to get the name of an MDNode, so use a
 // string ostream to print it.
 static std::string getMDNodeString(unsigned Kind,
                                    const SmallVectorImpl<StringRef> &MDNames) {
   std::string MDName;
   raw_string_ostream N(MDName);
   if (Kind < MDNames.size()) {
     N << "!" << MDNames[Kind];
   } else {
     N << "!<unknown kind #" << Kind << ">";
   }
   return N.str();
 }
 
 bool PNaClABIVerifyFunctions::IsWhitelistedMetadata(unsigned MDKind) {
   return MDKind == LLVMContext::MD_dbg && PNaClABIAllowDebugMetadata;
 }
 
 // A valid pointer type is either:
 //  * a pointer to a valid PNaCl scalar type (except i1), or
+//  * a pointer to a valid PNaCl vector type (except i1), or
 //  * a function pointer (with valid argument and return types).
 //
 // i1 is disallowed so that all loads and stores are a whole number of
 // bytes, and so that we do not need to define whether a store of i1
 // zero-extends.
-//
-// Vector pointer types aren't currently allowed because vector memory
-// accesses go through their scalar elements.
 static bool isValidPointerType(Type *Ty) {
   if (PointerType *PtrTy = dyn_cast<PointerType>(Ty)) {
     if (PtrTy->getAddressSpace() != 0)
       return false;
     Type *EltTy = PtrTy->getElementType();
     if (PNaClABITypeChecker::isValidScalarType(EltTy) && !EltTy->isIntegerTy(1))
       return true;
+    if (PNaClABITypeChecker::isValidVectorType(EltTy) &&
+        !cast<VectorType>(EltTy)->getElementType()->isIntegerTy(1))
+      return true;
     if (FunctionType *FTy = dyn_cast<FunctionType>(EltTy))
       return PNaClABITypeChecker::isValidFunctionType(FTy);
   }
   return false;
 }
 
 static bool isIntrinsicFunc(const Value *Val) {
   if (const Function *F = dyn_cast<Function>(Val))
     return F->isIntrinsic();
   return false;
@@ skipping 43 matching lines @@
   if (isa<Instruction>(Val) || isa<Argument>(Val))
     return true;
   // Contrary to scalars, constant vector values aren't allowed on
   // instructions, except undefined. Constant vectors are loaded from
   // constant global memory instead, and can be rematerialized as
   // constants by the backend if need be.
   return PNaClABITypeChecker::isValidVectorType(Val->getType()) &&
          isa<UndefValue>(Val);
 }
 
-static bool isAllowedAlignment(unsigned Alignment, Type *Ty) {
-  // Non-atomic integer operations must always use "align 1", since we
-  // do not want the backend to generate code with non-portable
-  // undefined behaviour (such as misaligned access faults) if user
-  // code specifies "align 4" but uses a misaligned pointer.  As a
-  // concession to performance, we allow larger alignment values for
-  // floating point types.
+static bool isAllowedAlignment(const DataLayout *DL, uint64_t Alignment,
+                               Type *Ty) {
+  // Non-atomic integer operations must always use "align 1", since we do not
+  // want the backend to generate code with non-portable undefined behaviour
+  // (such as misaligned access faults) if user code specifies "align 4" but
+  // uses a misaligned pointer.  As a concession to performance, we allow larger
+  // alignment values for floating point types, and we only allow vectors to be
+  // aligned by their element's size.
   //
-  // To reduce the set of alignment values that need to be encoded in
-  // pexes, we disallow other alignment values.  We require alignments
-  // to be explicit by disallowing Alignment == 0.
+  // TODO(jfb) Allow vectors to be marked as align == 1. This requires proper
+  //           testing on each supported ISA, and is probably not as common as
+  //           align == elemsize.
   //
-  // Vector memory accesses go through their scalar elements, there is
-  // therefore no such thing as vector alignment.
-  return Alignment == 1 ||
-         (Ty->isDoubleTy() && Alignment == 8) ||
-         (Ty->isFloatTy() && Alignment == 4);
+  // To reduce the set of alignment values that need to be encoded in pexes, we
+  // disallow other alignment values.  We require alignments to be explicit by
+  // disallowing Alignment == 0.
+  if (Alignment > std::numeric_limits<uint64_t>::max() / CHAR_BIT)
+    return false; // No overflow assumed below.
+  else if (VectorType *VTy = dyn_cast<VectorType>(Ty))
+    return !VTy->getElementType()->isIntegerTy(1) &&
+           (Alignment * CHAR_BIT ==
+            DL->getTypeSizeInBits(VTy->getElementType()));
+  else
+    return Alignment == 1 ||
+           (Ty->isDoubleTy() && Alignment == 8) ||
+           (Ty->isFloatTy() && Alignment == 4);
 }
 
 static bool hasAllowedAtomicRMWOperation(
     const NaCl::AtomicIntrinsics::AtomicIntrinsic *I, const CallInst *Call) {
   for (size_t P = 0; P != I->NumParams; ++P) {
     if (I->ParamType[P] != NaCl::AtomicIntrinsics::RMW)
       continue;
 
     const Value *Operation = Call->getOperand(P);
     if (!Operation)
@@ skipping 50 matching lines @@
   if (I == 1 || I == 2 || I == 4 || I == 8)
     return true;
   return false;
 }
 
 // Check the instruction's opcode and its operands.  The operands may
 // require opcode-specific checking.
 //
 // This returns an error string if the instruction is rejected, or
 // NULL if the instruction is allowed.
-const char *PNaClABIVerifyFunctions::checkInstruction(const Instruction *Inst) {
+const char *PNaClABIVerifyFunctions::checkInstruction(const DataLayout *DL,
+                                                      const Instruction *Inst) {
   // If the instruction has a single pointer operand, PtrOperandIndex is
   // set to its operand index.
   unsigned PtrOperandIndex = -1;
 
   switch (Inst->getOpcode()) {
     // Disallowed instructions. Default is to disallow.
     // We expand GetElementPtr out into arithmetic.
     case Instruction::GetElementPtr:
     // VAArg is expanded out by ExpandVarArgs.
     case Instruction::VAArg:
@@ skipping 90 matching lines @@
     // Memory accesses.
     case Instruction::Load: {
       const LoadInst *Load = cast<LoadInst>(Inst);
       PtrOperandIndex = Load->getPointerOperandIndex();
       if (Load->isAtomic())
         return "atomic load";
       if (Load->isVolatile())
         return "volatile load";
       if (!isNormalizedPtr(Inst->getOperand(PtrOperandIndex)))
         return "bad pointer";
-      if (!isAllowedAlignment(Load->getAlignment(),
-                              Load->getType()))
+      if (!isAllowedAlignment(DL, Load->getAlignment(), Load->getType()))
         return "bad alignment";
       break;
     }
     case Instruction::Store: {
       const StoreInst *Store = cast<StoreInst>(Inst);
       PtrOperandIndex = Store->getPointerOperandIndex();
       if (Store->isAtomic())
         return "atomic store";
       if (Store->isVolatile())
         return "volatile store";
       if (!isNormalizedPtr(Inst->getOperand(PtrOperandIndex)))
         return "bad pointer";
-      if (!isAllowedAlignment(Store->getAlignment(),
+      if (!isAllowedAlignment(DL, Store->getAlignment(),
                               Store->getValueOperand()->getType()))
         return "bad alignment";
       break;
     }
 
     // Casts.
     case Instruction::BitCast:
       if (Inst->getType()->isPointerTy()) {
         PtrOperandIndex = 0;
         if (!isInherentPtr(Inst->getOperand(PtrOperandIndex)))
@@ skipping 142 matching lines @@
           dyn_cast<PossiblyExactOperator>(Inst)) {
     if (Op->isExact())
       return "has \"exact\" attribute";
   }
 
   // Allow the instruction.
   return NULL;
 }
 
 bool PNaClABIVerifyFunctions::runOnFunction(Function &F) {
+  const DataLayout *DL = &getAnalysis<DataLayout>();
   SmallVector<StringRef, 8> MDNames;
   F.getContext().getMDKindNames(MDNames);
 
   for (Function::const_iterator FI = F.begin(), FE = F.end();
            FI != FE; ++FI) {
     for (BasicBlock::const_iterator BBI = FI->begin(), BBE = FI->end();
              BBI != BBE; ++BBI) {
       const Instruction *Inst = BBI;
       // Check the instruction opcode first.  This simplifies testing,
       // because some instruction opcodes must be rejected out of hand
       // (regardless of the instruction's result type) and the tests
       // check the reason for rejection.
-      const char *Error = checkInstruction(BBI);
+      const char *Error = checkInstruction(DL, BBI);
       // Check the instruction's result type.
       bool BadResult = false;
       if (!Error && !(PNaClABITypeChecker::isValidScalarType(Inst->getType()) ||
                       PNaClABITypeChecker::isValidVectorType(Inst->getType()) ||
                       isNormalizedPtr(Inst) ||
                       isa<AllocaInst>(Inst))) {
         Error = "bad result type";
         BadResult = true;
       }
       if (Error) {
@@ skipping 32 matching lines @@
 }
 
 char PNaClABIVerifyFunctions::ID = 0;
 INITIALIZE_PASS(PNaClABIVerifyFunctions, "verify-pnaclabi-functions",
                 "Verify functions for PNaCl", false, true)
 
 FunctionPass *llvm::createPNaClABIVerifyFunctionsPass(
     PNaClABIErrorReporter *Reporter) {
   return new PNaClABIVerifyFunctions(Reporter);
 }