Merge pull request #4951 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

cmake/modules/AddSwift.cmake

@@ -581,7 +581,12 @@ function(_add_swift_runtime_link_flags target relpath_to_lib_dir bootstrapping)
           target_link_directories(${target} PRIVATE "${sdk_dir}")
 
           # Include the abi stable system stdlib in our rpath.
-         set(swift_runtime_rpath "/usr/lib/swift")
+          set(swift_runtime_rpath "/usr/lib/swift")
+
+          # Add in the toolchain directory so we can grab compatibility libraries
+          get_filename_component(TOOLCHAIN_BIN_DIR ${SWIFT_EXEC_FOR_SWIFT_MODULES} DIRECTORY)
+          get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}" ABSOLUTE)
+          target_link_directories(${target} PUBLIC ${TOOLCHAIN_LIB_DIR})
         endif()
       endif()
     endif()

include/swift/AST/DiagnosticsParse.def

@@ -1342,12 +1342,12 @@ ERROR(legacy_object_literal,none,
 ERROR(unknown_pound_expr,none,
       "use of unknown directive '#%0'", (StringRef))
 
-// If expressions
-ERROR(expected_expr_after_if_question,none,
+// Ternary expressions
+ERROR(expected_expr_after_ternary_question,none,
       "expected expression after '?' in ternary expression", ())
-ERROR(expected_colon_after_if_question,none,
+ERROR(expected_colon_after_ternary_question,none,
       "expected ':' after '? ...' in ternary expression", ())
-ERROR(expected_expr_after_if_colon,none,
+ERROR(expected_expr_after_ternary_colon,none,
       "expected expression after '? ... :' in ternary expression", ())
 ERROR(expected_expr_after_try, none,
       "expected expression after 'try'", ())

include/swift/AST/DiagnosticsSema.def

@@ -1070,7 +1070,7 @@ ERROR(invalid_force_unwrap,none,
 ERROR(invalid_optional_chain,none,
       "cannot use optional chaining on non-optional value of type %0",
       (Type))
-ERROR(if_expr_cases_mismatch,none,
+ERROR(ternary_expr_cases_mismatch,none,
       "result values in '? :' expression have mismatching types %0 and %1",
       (Type, Type))
 

include/swift/AST/Expr.h

@@ -5061,25 +5061,21 @@ class RebindSelfInConstructorExpr : public Expr {
     return E->getKind() == ExprKind::RebindSelfInConstructor;
   }
 };
-  
-/// The conditional expression 'x ? y : z'.
-class IfExpr : public Expr {
+
+/// The ternary conditional expression 'x ? y : z'.
+class TernaryExpr : public Expr {
   Expr *CondExpr, *ThenExpr, *ElseExpr;
   SourceLoc QuestionLoc, ColonLoc;
 public:
-  IfExpr(Expr *CondExpr,
-         SourceLoc QuestionLoc, Expr *ThenExpr,
-         SourceLoc ColonLoc, Expr *ElseExpr,
-         Type Ty = Type())
-    : Expr(ExprKind::If, /*Implicit=*/false, Ty),
-      CondExpr(CondExpr), ThenExpr(ThenExpr), ElseExpr(ElseExpr),
-      QuestionLoc(QuestionLoc), ColonLoc(ColonLoc)
-  {}
-  
-  IfExpr(SourceLoc QuestionLoc, Expr *ThenExpr, SourceLoc ColonLoc)
-    : IfExpr(nullptr, QuestionLoc, ThenExpr, ColonLoc, nullptr)
-  {}
-  
+  TernaryExpr(Expr *CondExpr, SourceLoc QuestionLoc, Expr *ThenExpr,
+              SourceLoc ColonLoc, Expr *ElseExpr, Type Ty = Type())
+      : Expr(ExprKind::Ternary, /*Implicit=*/false, Ty), CondExpr(CondExpr),
+        ThenExpr(ThenExpr), ElseExpr(ElseExpr), QuestionLoc(QuestionLoc),
+        ColonLoc(ColonLoc) {}
+
+  TernaryExpr(SourceLoc QuestionLoc, Expr *ThenExpr, SourceLoc ColonLoc)
+      : TernaryExpr(nullptr, QuestionLoc, ThenExpr, ColonLoc, nullptr) {}
+
   SourceLoc getLoc() const { return QuestionLoc; }
   SourceLoc getStartLoc() const {
     return (isFolded() ? CondExpr->getStartLoc() : QuestionLoc);
@@ -5103,7 +5099,7 @@ class IfExpr : public Expr {
   bool isFolded() const { return CondExpr && ElseExpr; }
 
   static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::If;
+    return E->getKind() == ExprKind::Ternary;
   }
 };
 
@@ -5979,7 +5975,7 @@ class TypeJoinExpr final : public Expr,
 };
 
 inline bool Expr::isInfixOperator() const {
-  return isa<BinaryExpr>(this) || isa<IfExpr>(this) ||
+  return isa<BinaryExpr>(this) || isa<TernaryExpr>(this) ||
          isa<AssignExpr>(this) || isa<ExplicitCastExpr>(this);
 }
 

include/swift/AST/ExprNodes.def

@@ -194,7 +194,7 @@ ABSTRACT_EXPR(ExplicitCast, Expr)
   EXPR(Coerce, ExplicitCastExpr)
   EXPR_RANGE(ExplicitCast, ForcedCheckedCast, Coerce)
 UNCHECKED_EXPR(Arrow, Expr)
-EXPR(If, Expr)
+EXPR(Ternary, Expr)
 EXPR(EnumIsCase, Expr)
 EXPR(Assign, Expr)
 EXPR(CodeCompletion, Expr)

include/swift/SIL/NodeDatastructures.h

@@ -12,8 +12,6 @@
 //
 // This file defines efficient data structures for working with Nodes.
 //
-// TODO: Add an InstructionWorklist similar to BasicBlockWorklist.
-//
 //===----------------------------------------------------------------------===//
 
 #ifndef SWIFT_SIL_NODEDATASTRUCTURES_H
@@ -29,7 +27,7 @@ namespace swift {
 ///                                       NodeSet>`.
 ///
 /// Unfortunately it's not possible to use `llvm::SetVector` directly because
-/// the ValueSet and StackList constructors needs a `SILFunction` argument.
+/// the NodeSet and StackList constructors needs a `SILFunction` argument.
 ///
 /// Note: This class does not provide a `remove` method intentionally, because
 /// it would have a O(n) complexity.
@@ -63,6 +61,112 @@ class NodeSetVector {
   }
 };
 
+/// An implementation of `llvm::SetVector<SILInstruction *,
+///                                       StackList<SILInstruction *>,
+///                                       InstructionSet>`.
+///
+/// Unfortunately it's not possible to use `llvm::SetVector` directly because
+/// the InstructionSet and StackList constructors needs a `SILFunction`
+/// argument.
+///
+/// Note: This class does not provide a `remove` method intentionally, because
+/// it would have a O(n) complexity.
+class InstructionSetVector {
+  StackList<SILInstruction *> vector;
+  InstructionSet set;
+
+public:
+  using iterator = typename StackList<SILInstruction *>::iterator;
+
+  InstructionSetVector(SILFunction *function)
+      : vector(function), set(function) {}
+
+  iterator begin() const { return vector.begin(); }
+  iterator end() const { return vector.end(); }
+
+  llvm::iterator_range<iterator> getRange() const {
+    return llvm::make_range(begin(), end());
+  }
+
+  bool empty() const { return vector.empty(); }
+
+  bool contains(SILInstruction *instruction) const {
+    return set.contains(instruction);
+  }
+
+  /// Returns true if \p instruction was not contained in the set before
+  /// inserting.
+  bool insert(SILInstruction *instruction) {
+    if (set.insert(instruction)) {
+      vector.push_back(instruction);
+      return true;
+    }
+    return false;
+  }
+};
+
+/// A utility for processing instructions in a worklist.
+///
+/// It is basically a combination of an instruction vector and an instruction
+/// set. It can be used for typical worklist-processing algorithms.
+class InstructionWorklist {
+  StackList<SILInstruction *> worklist;
+  InstructionSet visited;
+
+public:
+  /// Construct an empty worklist.
+  InstructionWorklist(SILFunction *function)
+      : worklist(function), visited(function) {}
+
+  /// Initialize the worklist with \p initialBlock.
+  InstructionWorklist(SILInstruction *initialInstruction)
+      : InstructionWorklist(initialInstruction->getFunction()) {
+    push(initialInstruction);
+  }
+
+  /// Pops the last added element from the worklist or returns null, if the
+  /// worklist is empty.
+  SILInstruction *pop() {
+    if (worklist.empty())
+      return nullptr;
+    return worklist.pop_back_val();
+  }
+
+  /// Pushes \p instruction onto the worklist if \p instruction has never been
+  /// push before.
+  bool pushIfNotVisited(SILInstruction *instruction) {
+    if (visited.insert(instruction)) {
+      worklist.push_back(instruction);
+      return true;
+    }
+    return false;
+  }
+
+  /// Like `pushIfNotVisited`, but requires that \p instruction has never been
+  /// on the worklist before.
+  void push(SILInstruction *instruction) {
+    assert(!visited.contains(instruction));
+    visited.insert(instruction);
+    worklist.push_back(instruction);
+  }
+
+  /// Like `pop`, but marks the returned instruction as "unvisited". This means,
+  /// that the instruction can be pushed onto the worklist again.
+  SILInstruction *popAndForget() {
+    if (worklist.empty())
+      return nullptr;
+    SILInstruction *instruction = worklist.pop_back_val();
+    visited.erase(instruction);
+    return instruction;
+  }
+
+  /// Returns true if \p instruction was visited, i.e. has been added to the
+  /// worklist.
+  bool isVisited(SILInstruction *instruction) const {
+    return visited.contains(instruction);
+  }
+};
+
 /// An implementation of `llvm::SetVector<SILValue,
 ///                                       StackList<SILValue>,
 ///                                       ValueSet>`.
@@ -102,6 +206,64 @@ class ValueSetVector {
   }
 };
 
+/// A utility for processing values in a worklist.
+///
+/// It is basically a combination of a value vector and a value set. It can be
+/// used for typical worklist-processing algorithms.
+class ValueWorklist {
+  StackList<SILValue> worklist;
+  ValueSet visited;
+
+public:
+  /// Construct an empty worklist.
+  ValueWorklist(SILFunction *function)
+      : worklist(function), visited(function) {}
+
+  /// Initialize the worklist with \p initialValue.
+  ValueWorklist(SILValue initialValue)
+      : ValueWorklist(initialValue->getFunction()) {
+    push(initialValue);
+  }
+
+  /// Pops the last added element from the worklist or returns null, if the
+  /// worklist is empty.
+  SILValue pop() {
+    if (worklist.empty())
+      return nullptr;
+    return worklist.pop_back_val();
+  }
+
+  /// Pushes \p value onto the worklist if \p value has never been push before.
+  bool pushIfNotVisited(SILValue value) {
+    if (visited.insert(value)) {
+      worklist.push_back(value);
+      return true;
+    }
+    return false;
+  }
+
+  /// Like `pushIfNotVisited`, but requires that \p value has never been on the
+  /// worklist before.
+  void push(SILValue value) {
+    assert(!visited.contains(value));
+    visited.insert(value);
+    worklist.push_back(value);
+  }
+
+  /// Like `pop`, but marks the returned value as "unvisited". This means, that
+  /// the value can be pushed onto the worklist again.
+  SILValue popAndForget() {
+    if (worklist.empty())
+      return nullptr;
+    SILValue value = worklist.pop_back_val();
+    visited.erase(value);
+    return value;
+  }
+
+  /// Returns true if \p value was visited, i.e. has been added to the worklist.
+  bool isVisited(SILValue value) const { return visited.contains(value); }
+};
+
 } // namespace swift
 
 #endif

include/swift/SIL/SILDeclRef.h

@@ -380,7 +380,10 @@ struct SILDeclRef {
   bool isAlwaysInline() const;
   /// True if the function has the @_backDeploy attribute.
   bool isBackDeployed() const;
-  
+
+  /// Return the expected linkage for a definition of this declaration.
+  SILLinkage getDefinitionLinkage() const;
+
   /// Return the expected linkage of this declaration.
   SILLinkage getLinkage(ForDefinition_t forDefinition) const;