[𝘀𝗽𝗿] changes introduced through rebase

Created using spr 1.3.6

[skip ci]

Author: vitalybuka

clang-tools-extra/clang-tidy/.clang-tidy

@@ -16,7 +16,6 @@ Checks: >
   performance-*,
   -performance-enum-size,
   -performance-no-int-to-ptr,
-  -performance-type-promotion-in-math-fn,
   -performance-unnecessary-value-param,
   readability-*,
   -readability-avoid-nested-conditional-operator,

clang-tools-extra/clang-tidy/altera/StructPackAlignCheck.cpp

@@ -76,9 +76,9 @@ void StructPackAlignCheck::check(const MatchFinder::MatchResult &Result) {
   CharUnits CurrSize = Result.Context->getASTRecordLayout(Struct).getSize();
   CharUnits MinByteSize =
       CharUnits::fromQuantity(std::max<clang::CharUnits::QuantityType>(
-          ceil(static_cast<float>(TotalBitSize) / CharSize), 1));
+          std::ceil(static_cast<float>(TotalBitSize) / CharSize), 1));
   CharUnits MaxAlign = CharUnits::fromQuantity(
-      ceil((float)Struct->getMaxAlignment() / CharSize));
+      std::ceil((float)Struct->getMaxAlignment() / CharSize));
   CharUnits CurrAlign =
       Result.Context->getASTRecordLayout(Struct).getAlignment();
   CharUnits NewAlign = computeRecommendedAlignment(MinByteSize);

clang-tools-extra/clang-tidy/altera/UnrollLoopsCheck.cpp

@@ -208,18 +208,20 @@ bool UnrollLoopsCheck::hasLargeNumIterations(const Stmt *Statement,
       return true;
     switch (Op->getOpcode()) {
     case (BO_AddAssign):
-      Iterations = ceil(float(EndValue - InitValue) / ConstantValue);
+      Iterations = std::ceil(float(EndValue - InitValue) / ConstantValue);
       break;
     case (BO_SubAssign):
-      Iterations = ceil(float(InitValue - EndValue) / ConstantValue);
+      Iterations = std::ceil(float(InitValue - EndValue) / ConstantValue);
       break;
     case (BO_MulAssign):
-      Iterations = 1 + (log((double)EndValue) - log((double)InitValue)) /
-                           log((double)ConstantValue);
+      Iterations =
+          1 + (std::log((double)EndValue) - std::log((double)InitValue)) /
+                  std::log((double)ConstantValue);
       break;
     case (BO_DivAssign):
-      Iterations = 1 + (log((double)InitValue) - log((double)EndValue)) /
-                           log((double)ConstantValue);
+      Iterations =
+          1 + (std::log((double)InitValue) - std::log((double)EndValue)) /
+                  std::log((double)ConstantValue);
       break;
     default:
       // All other operators are not handled; assume large bounds.

clang/lib/AST/ByteCode/ByteCodeEmitter.cpp

@@ -24,15 +24,13 @@ void ByteCodeEmitter::compileFunc(const FunctionDecl *FuncDecl,
                                   Function *Func) {
   assert(FuncDecl);
   assert(Func);
+  assert(FuncDecl->isThisDeclarationADefinition());
 
   // Manually created functions that haven't been assigned proper
   // parameters yet.
   if (!FuncDecl->param_empty() && !FuncDecl->param_begin())
     return;
 
-  if (!FuncDecl->isDefined())
-    return;
-
   // Set up lambda captures.
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FuncDecl);
       MD && isLambdaCallOperator(MD)) {
@@ -87,7 +85,7 @@ void ByteCodeEmitter::compileFunc(const FunctionDecl *FuncDecl,
   }
 
   // Set the function's code.
-  Func->setCode(NextLocalOffset, std::move(Code), std::move(SrcMap),
+  Func->setCode(FuncDecl, NextLocalOffset, std::move(Code), std::move(SrcMap),
                 std::move(Scopes), FuncDecl->hasBody());
   Func->setIsFullyCompiled(true);
 }

clang/lib/AST/ByteCode/Function.h

@@ -236,9 +236,10 @@ class Function final {
            bool HasRVO, bool IsLambdaStaticInvoker);
 
   /// Sets the code of a function.
-  void setCode(unsigned NewFrameSize, llvm::SmallVector<std::byte> &&NewCode,
-               SourceMap &&NewSrcMap, llvm::SmallVector<Scope, 2> &&NewScopes,
-               bool NewHasBody) {
+  void setCode(FunctionDeclTy Source, unsigned NewFrameSize,
+               llvm::SmallVector<std::byte> &&NewCode, SourceMap &&NewSrcMap,
+               llvm::SmallVector<Scope, 2> &&NewScopes, bool NewHasBody) {
+    this->Source = Source;
     FrameSize = NewFrameSize;
     Code = std::move(NewCode);
     SrcMap = std::move(NewSrcMap);

clang/lib/AST/ByteCode/Interp.cpp

@@ -1493,9 +1493,12 @@ bool CheckDestructor(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {
 }
 
 static void compileFunction(InterpState &S, const Function *Func) {
+  const FunctionDecl *Definition = Func->getDecl()->getDefinition();
+  if (!Definition)
+    return;
+
   Compiler<ByteCodeEmitter>(S.getContext(), S.P)
-      .compileFunc(Func->getDecl()->getMostRecentDecl(),
-                   const_cast<Function *>(Func));
+      .compileFunc(Definition, const_cast<Function *>(Func));
 }
 
 bool CallVar(InterpState &S, CodePtr OpPC, const Function *Func,

clang/test/Modules/lambda-merge.cpp

@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -fmodules -std=c++17 -emit-llvm %s -o - -triple x86_64-linux-gnu | FileCheck %s
+// RUN: %clang_cc1 -fmodules -std=c++17 -emit-llvm %s -o - -triple x86_64-linux-gnu -fexperimental-new-constant-interpreter | FileCheck %s
 
 #pragma clang module build A
 module A {}

lldb/tools/lldb-dap/package.json

@@ -409,7 +409,7 @@
                 "anyOf": [
                   {
                     "type": "object",
-                    "markdownDescription": "Additional environment variables to set when launching the debug adapter executable. E.g. `{ \"FOO\": \"1\" }`",
+                    "markdownDescription": "Additional environment variables to set when launching the debug adapter executable. For example `{ \"FOO\": \"1\" }`",
                     "patternProperties": {
                       ".*": {
                         "type": "string"
@@ -419,10 +419,10 @@
                   },
                   {
                     "type": "array",
-                    "markdownDescription": "Additional environment variables to set when launching the debug adapter executable. E.g. `[\"FOO=1\", \"BAR\"]`",
+                    "markdownDescription": "Additional environment variables to set when launching the debug adapter executable. For example `[\"FOO=1\", \"BAR\"]`",
                     "items": {
                       "type": "string",
-                      "pattern": "^((\\w+=.*)|^\\w+)$"
+                      "pattern": "^\\w+(=.*)?$"
                     },
                     "default": []
                   }
@@ -672,6 +672,29 @@
                 },
                 "markdownDescription": "The list of additional arguments used to launch the debug adapter executable. Overrides any user or workspace settings."
               },
+              "debugAdapterEnv": {
+                "anyOf": [
+                  {
+                    "type": "object",
+                    "markdownDescription": "Additional environment variables to set when launching the debug adapter executable. For example `{ \"FOO\": \"1\" }`",
+                    "patternProperties": {
+                      ".*": {
+                        "type": "string"
+                      }
+                    },
+                    "default": {}
+                  },
+                  {
+                    "type": "array",
+                    "markdownDescription": "Additional environment variables to set when launching the debug adapter executable. For example `[\"FOO=1\", \"BAR\"]`",
+                    "items": {
+                      "type": "string",
+                      "pattern": "^\\w+(=.*)?$"
+                    },
+                    "default": []
+                  }
+                ]
+              },
               "program": {
                 "type": "string",
                 "description": "Path to the program to attach to."

lldb/tools/lldb-dap/src-ts/debug-adapter-factory.ts

@@ -92,7 +92,7 @@ function validateDAPEnv(debugConfigEnv: any): boolean {
     Array.isArray(debugConfigEnv) &&
     debugConfigEnv.findIndex(
       (entry) =>
-        typeof entry !== "string" || !/^((\\w+=.*)|^\\w+)$/.test(entry),
+        typeof entry !== "string" || !/^\w+(=.*)?$/.test(entry),
     ) !== -1
   ) {
     return false;

llvm/include/llvm/ADT/IndexedMap.h

@@ -20,67 +20,56 @@
 #ifndef LLVM_ADT_INDEXEDMAP_H
 #define LLVM_ADT_INDEXEDMAP_H
 
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/identity.h"
 #include <cassert>
 
 namespace llvm {
 
-template <typename T, typename ToIndexT = identity<unsigned>>
-  class IndexedMap {
-    using IndexT = typename ToIndexT::argument_type;
-    // Prefer SmallVector with zero inline storage over std::vector. IndexedMaps
-    // can grow very large and SmallVector grows more efficiently as long as T
-    // is trivially copyable.
-    using StorageT = SmallVector<T, 0>;
-
-    StorageT storage_;
-    T nullVal_;
-    ToIndexT toIndex_;
-
-  public:
-    IndexedMap() : nullVal_(T()) {}
-
-    explicit IndexedMap(const T& val) : nullVal_(val) {}
-
-    typename StorageT::reference operator[](IndexT n) {
-      assert(toIndex_(n) < storage_.size() && "index out of bounds!");
-      return storage_[toIndex_(n)];
-    }
-
-    typename StorageT::const_reference operator[](IndexT n) const {
-      assert(toIndex_(n) < storage_.size() && "index out of bounds!");
-      return storage_[toIndex_(n)];
-    }
-
-    void reserve(typename StorageT::size_type s) {
-      storage_.reserve(s);
-    }
-
-    void resize(typename StorageT::size_type s) {
-      storage_.resize(s, nullVal_);
-    }
-
-    void clear() {
-      storage_.clear();
-    }
-
-    void grow(IndexT n) {
-      unsigned NewSize = toIndex_(n) + 1;
-      if (NewSize > storage_.size())
-        resize(NewSize);
-    }
-
-    bool inBounds(IndexT n) const {
-      return toIndex_(n) < storage_.size();
-    }
-
-    typename StorageT::size_type size() const {
-      return storage_.size();
-    }
-  };
-
-} // end namespace llvm
+template <typename T, typename ToIndexT = identity<unsigned>> class IndexedMap {
+  using IndexT = typename ToIndexT::argument_type;
+  // Prefer SmallVector with zero inline storage over std::vector. IndexedMaps
+  // can grow very large and SmallVector grows more efficiently as long as T
+  // is trivially copyable.
+  using StorageT = SmallVector<T, 0>;
+
+  StorageT storage_;
+  T nullVal_;
+  ToIndexT toIndex_;
+
+public:
+  IndexedMap() : nullVal_(T()) {}
+
+  explicit IndexedMap(const T &val) : nullVal_(val) {}
+
+  typename StorageT::reference operator[](IndexT n) {
+    assert(toIndex_(n) < storage_.size() && "index out of bounds!");
+    return storage_[toIndex_(n)];
+  }
+
+  typename StorageT::const_reference operator[](IndexT n) const {
+    assert(toIndex_(n) < storage_.size() && "index out of bounds!");
+    return storage_[toIndex_(n)];
+  }
+
+  void reserve(typename StorageT::size_type s) { storage_.reserve(s); }
+
+  void resize(typename StorageT::size_type s) { storage_.resize(s, nullVal_); }
+
+  void clear() { storage_.clear(); }
+
+  void grow(IndexT n) {
+    unsigned NewSize = toIndex_(n) + 1;
+    if (NewSize > storage_.size())
+      resize(NewSize);
+  }
+
+  bool inBounds(IndexT n) const { return toIndex_(n) < storage_.size(); }
+
+  typename StorageT::size_type size() const { return storage_.size(); }
+};
+
+} // namespace llvm
 
 #endif // LLVM_ADT_INDEXEDMAP_H