Merge remote-tracking branch 'origin/main' into vplan-compute-iv-end-values

Author: fhahn

clang-tools-extra/clangd/index/SymbolCollector.cpp

@@ -550,9 +550,14 @@ bool SymbolCollector::shouldCollectSymbol(const NamedDecl &ND,
   // Avoid indexing internal symbols in protobuf generated headers.
   if (isPrivateProtoDecl(ND))
     return false;
+
+  // System headers that end with `intrin.h` likely contain useful symbols.
   if (!Opts.CollectReserved &&
       (hasReservedName(ND) || hasReservedScope(*ND.getDeclContext())) &&
-      ASTCtx.getSourceManager().isInSystemHeader(ND.getLocation()))
+      ASTCtx.getSourceManager().isInSystemHeader(ND.getLocation()) &&
+      !ASTCtx.getSourceManager()
+           .getFilename(ND.getLocation())
+           .ends_with("intrin.h"))
     return false;
 
   return true;

clang-tools-extra/clangd/unittests/SymbolCollectorTests.cpp

@@ -2111,6 +2111,20 @@ TEST_F(SymbolCollectorTest, Reserved) {
   EXPECT_THAT(Symbols, IsEmpty());
 }
 
+TEST_F(SymbolCollectorTest, ReservedSymbolInIntrinsicHeader) {
+  const char *Header = R"cpp(
+    #pragma once
+    void __foo();
+  )cpp";
+
+  TestHeaderName = "xintrin.h";
+  TestHeaderURI = URI::create(testPath(TestHeaderName)).toString();
+  InMemoryFileSystem = new llvm::vfs::InMemoryFileSystem;
+  CollectorOpts.FallbackDir = testRoot();
+  runSymbolCollector("#pragma GCC system_header\n" + std::string(Header), "");
+  EXPECT_THAT(Symbols, UnorderedElementsAre(qName("__foo")));
+}
+
 TEST_F(SymbolCollectorTest, Concepts) {
   const char *Header = R"cpp(
     template <class T>

libc/shared/rpc.h

@@ -44,9 +44,9 @@ namespace rpc {
 
 /// Generic codes that can be used whem implementing the server.
 enum Status {
-  SUCCESS = 0x0,
-  ERROR = 0x1000,
-  UNHANDLED_OPCODE = 0x1001,
+  RPC_SUCCESS = 0x0,
+  RPC_ERROR = 0x1000,
+  RPC_UNHANDLED_OPCODE = 0x1001,
 };
 
 /// A fixed size channel used to communicate between the RPC client and server.

libc/utils/gpu/loader/Loader.h

@@ -113,7 +113,7 @@ inline uint32_t handle_server(rpc::Server &server, uint32_t index,
     return 0;
   index = port->get_index() + 1;
 
-  int status = rpc::SUCCESS;
+  int status = rpc::RPC_SUCCESS;
   switch (port->get_opcode()) {
   case RPC_TEST_INCREMENT: {
     port->recv_and_send([](rpc::Buffer *buffer, uint32_t) {
@@ -186,7 +186,7 @@ inline uint32_t handle_server(rpc::Server &server, uint32_t index,
   }
 
   // Handle all of the `libc` specific opcodes.
-  if (status != rpc::SUCCESS)
+  if (status != rpc::RPC_SUCCESS)
     handle_error("Error handling RPC server");
 
   port->close();

libc/utils/gpu/server/rpc_server.cpp

@@ -437,10 +437,10 @@ rpc::Status handle_port_impl(rpc::Server::Port &port) {
     break;
   }
   default:
-    return rpc::UNHANDLED_OPCODE;
+    return rpc::RPC_UNHANDLED_OPCODE;
   }
 
-  return rpc::SUCCESS;
+  return rpc::RPC_SUCCESS;
 }
 
 namespace rpc {
@@ -455,7 +455,7 @@ rpc::Status handle_libc_opcodes(rpc::Server::Port &port, uint32_t num_lanes) {
   case 64:
     return handle_port_impl<64>(port);
   default:
-    return rpc::ERROR;
+    return rpc::RPC_ERROR;
   }
 }
 } // namespace rpc

llvm/lib/Transforms/Vectorize/LoopVectorize.cpp

@@ -8381,7 +8381,8 @@ VPHeaderPHIRecipe *VPRecipeBuilder::tryToOptimizeInductionPHI(
             [&](ElementCount VF) {
               return CM.isScalarAfterVectorization(Phi, VF);
             },
-            Range));
+            Range),
+        Phi->getDebugLoc());
   }
   return nullptr;
 }

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -2211,8 +2211,8 @@ class VPWidenPointerInductionRecipe : public VPHeaderPHIRecipe,
   /// Start.
   VPWidenPointerInductionRecipe(PHINode *Phi, VPValue *Start, VPValue *Step,
                                 const InductionDescriptor &IndDesc,
-                                bool IsScalarAfterVectorization)
-      : VPHeaderPHIRecipe(VPDef::VPWidenPointerInductionSC, Phi),
+                                bool IsScalarAfterVectorization, DebugLoc DL)
+      : VPHeaderPHIRecipe(VPDef::VPWidenPointerInductionSC, Phi, nullptr, DL),
         IndDesc(IndDesc),
         IsScalarAfterVectorization(IsScalarAfterVectorization) {
     addOperand(Start);
@@ -2224,7 +2224,7 @@ class VPWidenPointerInductionRecipe : public VPHeaderPHIRecipe,
   VPWidenPointerInductionRecipe *clone() override {
     return new VPWidenPointerInductionRecipe(
         cast<PHINode>(getUnderlyingInstr()), getOperand(0), getOperand(1),
-        IndDesc, IsScalarAfterVectorization);
+        IndDesc, IsScalarAfterVectorization, getDebugLoc());
   }
 
   VP_CLASSOF_IMPL(VPDef::VPWidenPointerInductionSC)

llvm/lib/Transforms/Vectorize/VPlanRecipes.cpp

@@ -3182,6 +3182,7 @@ void VPWidenPointerInductionRecipe::execute(VPTransformState &State) {
     NewPointerPhi = PHINode::Create(ScStValueType, 2, "pointer.phi",
                                     CanonicalIV->getIterator());
     NewPointerPhi->addIncoming(ScalarStartValue, VectorPH);
+    NewPointerPhi->setDebugLoc(getDebugLoc());
   } else {
     // The recipe has been unrolled. In that case, fetch the single pointer phi
     // shared among all unrolled parts of the recipe.

llvm/test/Transforms/LoopVectorize/preserve-dbg-loc-and-loop-metadata.ll

@@ -1,16 +1,19 @@
-; RUN: opt < %s -passes=loop-vectorize -S 2>&1 | FileCheck %s
-; RUN: opt < %s -passes=debugify,loop-vectorize -S | FileCheck %s -check-prefix DEBUGLOC
-; RUN: opt < %s -passes=debugify,loop-vectorize -S --try-experimental-debuginfo-iterators | FileCheck %s -check-prefix DEBUGLOC
+; RUN: opt < %s -passes=loop-vectorize -force-vector-width=4 -S 2>&1 | FileCheck %s
+; RUN: opt < %s -passes=debugify,loop-vectorize -force-vector-width=4 -S | FileCheck %s -check-prefix DEBUGLOC
+; RUN: opt < %s -passes=debugify,loop-vectorize -force-vector-width=4 -S --try-experimental-debuginfo-iterators | FileCheck %s -check-prefix DEBUGLOC
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; This test makes sure we don't duplicate the loop vectorizer's metadata
 ; while marking them as already vectorized (by setting width = 1), even
 ; at lower optimization levels, where no extra cleanup is done
 
-; DEBUGLOC-LABEL: define void @_Z3fooPf(
 ; Check that the phi to resume the scalar part of the loop
 ; has Debug Location.
 define void @_Z3fooPf(ptr %a) {
+; DEBUGLOC-LABEL: define void @_Z3fooPf(
+; DEBUGLOC: scalar.ph:
+; DEBUGLOC-NEXT:    %bc.resume.val = phi {{.*}} !dbg ![[RESUMELOC:[0-9]+]]
+;
 entry:
   br label %for.body
 
@@ -24,16 +27,38 @@ for.body:                                         ; preds = %for.body, %entry
   %exitcond = icmp eq i64 %indvars.iv.next, 1024
   br i1 %exitcond, label %for.end, label %for.body, !llvm.loop !0
 
-; DEBUGLOC: scalar.ph:
-; DEBUGLOC-NEXT:    %bc.resume.val = phi {{.*}} !dbg ![[DbgLoc:[0-9]+]]
+for.end:                                          ; preds = %for.body
+  ret void
+}
+
+define void @widen_ptr_induction_dbg(ptr %start, ptr %end) {
+; DEBUGLOC-LABEL: define void @widen_ptr_induction_dbg(
+; DEBUGLOC: vector.body:
+; DEBUGLOC-NEXT: = phi ptr {{.+}}, !dbg ![[PTRIVLOC:[0-9]+]]
+; DEBUGLOC: = phi i64
+;
+; DEBUGLOC: loop:
+; DEBUGLOC-NEXT: = phi ptr {{.+}}, !dbg ![[PTRIVLOC]]
 ;
-; DEBUGLOC: ![[DbgLoc]] = !DILocation(line: 2
+entry:
+  br label %loop
 
-for.end:                                          ; preds = %for.body
+loop:
+  %iv = phi ptr [ %start, %entry ], [ %iv.next, %loop ]
+  %iv.next = getelementptr inbounds ptr, ptr %iv, i64 1
+  store ptr %iv, ptr %iv, align 1
+  %cmp.not = icmp eq ptr %iv.next, %end
+  br i1 %cmp.not, label %exit, label %loop
+
+exit:
   ret void
 }
 
+
 !0 = !{!0, !1}
 !1 = !{!"llvm.loop.vectorize.width", i32 4}
 ; CHECK-NOT: !{metadata !"llvm.loop.vectorize.width", i32 4}
 ; CHECK: !{!"llvm.loop.isvectorized", i32 1}
+
+; DEBUGLOC: ![[RESUMELOC]] = !DILocation(line: 2
+; DEBUGLOC: ![[PTRIVLOC]] = !DILocation(line: 12

offload/plugins-nextgen/common/src/RPC.cpp

@@ -56,10 +56,10 @@ rpc::Status handle_offload_opcodes(plugin::GenericDeviceTy &Device,
     break;
   }
   default:
-    return rpc::UNHANDLED_OPCODE;
+    return rpc::RPC_UNHANDLED_OPCODE;
     break;
   }
-  return rpc::SUCCESS;
+  return rpc::RPC_SUCCESS;
 }
 
 static rpc::Status handle_offload_opcodes(plugin::GenericDeviceTy &Device,
@@ -72,7 +72,7 @@ static rpc::Status handle_offload_opcodes(plugin::GenericDeviceTy &Device,
   else if (NumLanes == 64)
     return handle_offload_opcodes<64>(Device, Port);
   else
-    return rpc::ERROR;
+    return rpc::RPC_ERROR;
 }
 
 RPCServerTy::RPCServerTy(plugin::GenericPluginTy &Plugin)
@@ -125,12 +125,12 @@ Error RPCServerTy::runServer(plugin::GenericDeviceTy &Device) {
 
   // Let the `libc` library handle any other unhandled opcodes.
 #ifdef LIBOMPTARGET_RPC_SUPPORT
-  if (Status == rpc::UNHANDLED_OPCODE)
+  if (Status == rpc::RPC_UNHANDLED_OPCODE)
     Status = handle_libc_opcodes(*Port, Device.getWarpSize());
 #endif
 
   Port->close();
-  if (Status != rpc::SUCCESS)
+  if (Status != rpc::RPC_SUCCESS)
     return createStringError("RPC server given invalid opcode!");
 
   return Error::success();