Merge from 'sycl' to 'sycl-web' (#2)

Author: iclsrc

clang/include/clang/Basic/Attr.td

@@ -1153,12 +1153,12 @@ def SYCLIntelMaxGlobalWorkDim : InheritableAttr {
   let PragmaAttributeSupport = 0;
 }
 
-def SYCLIntelUsesGlobalWorkOffset : InheritableAttr {
-  let Spellings = [CXX11<"intelfpga","uses_global_work_offset">];
-  let Args = [BoolArgument<"Enabled">];
+def SYCLIntelNoGlobalWorkOffset : InheritableAttr {
+  let Spellings = [CXX11<"intelfpga","no_global_work_offset">];
+  let Args = [BoolArgument<"Enabled", 1>];
   let LangOpts = [SYCLIsDevice, SYCLIsHost];
   let Subjects = SubjectList<[Function], ErrorDiag>;
-  let Documentation = [SYCLIntelUsesGlobalWorkOffsetDocs];
+  let Documentation = [SYCLIntelNoGlobalWorkOffsetAttrDocs];
   let PragmaAttributeSupport = 0;
 }
 

clang/include/clang/Basic/AttrDocs.td

@@ -2012,13 +2012,14 @@ device kernel, the attribute is ignored and it is not propagated to a kernel.
   }];
 }
 
-def SYCLIntelUsesGlobalWorkOffsetDocs : Documentation {
+def SYCLIntelNoGlobalWorkOffsetAttrDocs : Documentation {
   let Category = DocCatFunction;
-  let Heading = "uses_global_work_offset (IntelFPGA)";
+  let Heading = "no_global_work_offset (IntelFPGA)";
   let Content = [{
 Applies to a device function/lambda function or function call operator (of a
-function object). If 0, compiler doesn't use the global work offset values for
-the device function. Valid values are 0 and 1.
+function object). If 1, compiler doesn't use the global work offset values for
+the device function. Valid values are 0 and 1. If used without argument, value
+of 1 is set implicitly.
   }];
 }
 

clang/include/clang/Basic/AttributeCommonInfo.h

@@ -159,7 +159,7 @@ class AttributeCommonInfo {
         ParsedAttr == AT_SYCLIntelNumSimdWorkItems ||
         ParsedAttr == AT_SYCLIntelMaxWorkGroupSize ||
         ParsedAttr == AT_SYCLIntelMaxGlobalWorkDim ||
-        ParsedAttr == AT_SYCLIntelUsesGlobalWorkOffset)
+        ParsedAttr == AT_SYCLIntelNoGlobalWorkOffset)
       return true;
 
     return false;

clang/include/clang/Driver/Action.h

@@ -613,7 +613,8 @@ class OffloadUnbundlingJobAction final : public JobAction {
 
 public:
   // Offloading unbundling doesn't change the type of output.
-  OffloadUnbundlingJobAction(ActionList &Inputs);
+  OffloadUnbundlingJobAction(Action *Input);
+  OffloadUnbundlingJobAction(ActionList &Inputs, types::ID Type);
 
   /// Register information about a dependent action.
   void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch,

clang/include/clang/Driver/Options.td

@@ -197,6 +197,8 @@ def u_Group : OptionGroup<"<u group>">, Group<Link_Group>, DocFlatten;
 def reserved_lib_Group : OptionGroup<"<reserved libs group>">,
                          Flags<[Unsupported]>;
 
+def offload_lib_Group : OptionGroup<"<offload libs group>">;
+
 // Temporary groups for clang options which we know we don't support,
 // but don't want to verbosely warn the user about.
 def clang_ignored_f_Group : OptionGroup<"<clang ignored f group>">,
@@ -1674,7 +1676,8 @@ def fobjc_nonfragile_abi : Flag<["-"], "fobjc-nonfragile-abi">, Group<f_Group>;
 def fno_objc_nonfragile_abi : Flag<["-"], "fno-objc-nonfragile-abi">, Group<f_Group>;
 
 def fobjc_sender_dependent_dispatch : Flag<["-"], "fobjc-sender-dependent-dispatch">, Group<f_Group>;
-def foffload_static_lib_EQ : CommaJoined<["-"], "foffload-static-lib=">, Flags<[DriverOption, CoreOption]>;
+def foffload_static_lib_EQ : CommaJoined<["-"], "foffload-static-lib=">, Flags<[DriverOption, CoreOption]>, Group<offload_lib_Group>;
+def foffload_whole_static_lib_EQ : CommaJoined<["-"], "foffload-whole-static-lib=">, Flags<[DriverOption, CoreOption]>, Group<offload_lib_Group>;
 def fomit_frame_pointer : Flag<["-"], "fomit-frame-pointer">, Group<f_Group>;
 def fopenmp : Flag<["-"], "fopenmp">, Group<f_Group>, Flags<[CC1Option, NoArgumentUnused]>,
   HelpText<"Parse OpenMP pragmas and generate parallel code.">;

clang/include/clang/Driver/Types.def

@@ -106,6 +106,7 @@ TYPE("tempfilelist",             Tempfilelist, INVALID,         "txt",    phases
 TYPE("tempentriesfilelist",      TempEntriesfilelist, INVALID,  "txt",    phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("tempAOCOfilelist",         TempAOCOfilelist, INVALID,     "txt",    phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("archive",                  Archive,      INVALID,         "a",      phases::Compile, phases::Backend, phases::Assemble, phases::Link)
+TYPE("wholearchive",             WholeArchive, INVALID,         "a",      phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("fpga_aocx",                FPGA_AOCX,    INVALID,         "aocx",   phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("fpga_aocr",                FPGA_AOCR,    INVALID,         "aocr",   phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 TYPE("fpga_aoco",                FPGA_AOCO,    INVALID,         "aoco",   phases::Compile, phases::Backend, phases::Assemble, phases::Link)

clang/include/clang/Driver/Types.h

@@ -84,6 +84,9 @@ namespace types {
   /// isFPGA - Is this FPGA input.
   bool isFPGA(ID Id);
 
+  /// isArchive - Is this an archive input.
+  bool isArchive(ID Id);
+
   /// isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
   bool isObjC(ID Id);
 

clang/lib/AST/ItaniumMangle.cpp

@@ -2456,67 +2456,6 @@ static bool isTypeSubstitutable(Qualifiers Quals, const Type *Ty,
   return true;
 }
 
-namespace {
-struct DeclContextDesc {
-  Decl::Kind DeclKind;
-  StringRef Name;
-};
-} // namespace
-
-// For Scopes argument, the only supported Decl::Kind values are:
-// - Namespace
-// - CXXRecord
-// - ClassTemplateSpecialization
-static bool matchQualifiedTypeName(const QualType &Ty,
-                            ArrayRef<DeclContextDesc> Scopes) {
-  // The idea: check the declaration context chain starting from the type
-  // itself. At each step check the context is of expected kind
-  // (namespace) and name.
-  const CXXRecordDecl *RecTy = Ty->getAsCXXRecordDecl();
-
-  if (!RecTy)
-    return false; // only classes/structs supported
-  const auto *Ctx = dyn_cast<DeclContext>(RecTy);
-
-  for (const auto &Scope : llvm::reverse(Scopes)) {
-    Decl::Kind DK = Ctx->getDeclKind();
-    StringRef Name = "";
-
-    if (DK != Scope.DeclKind)
-      return false;
-
-    switch (DK) {
-    case Decl::Kind::ClassTemplateSpecialization:
-      // ClassTemplateSpecializationDecl inherits from CXXRecordDecl
-    case Decl::Kind::CXXRecord:
-      Name = cast<CXXRecordDecl>(Ctx)->getName();
-      break;
-    case Decl::Kind::Namespace:
-      Name = cast<NamespaceDecl>(Ctx)->getName();
-      break;
-    default:
-      return false;
-    }
-    if (Name != Scope.Name)
-      return false;
-    Ctx = Ctx->getParent();
-  }
-  return Ctx->isTranslationUnit();
-}
-
-static bool isSYCLHostHalfType(const Type *Ty) {
-  // FIXME: this is not really portable, since the bunch of namespace below
-  // is not specified by the SYCL standard and highly depends on particular
-  // implementation
-  static const std::array<DeclContextDesc, 5> Scopes = {
-      DeclContextDesc{Decl::Kind::Namespace, "cl"},
-      DeclContextDesc{Decl::Kind::Namespace, "sycl"},
-      DeclContextDesc{Decl::Kind::Namespace, "detail"},
-      DeclContextDesc{Decl::Kind::Namespace, "half_impl"},
-      DeclContextDesc{Decl::Kind::CXXRecord, "half"}};
-  return matchQualifiedTypeName(QualType(Ty, 0), Scopes);
-}
-
 void CXXNameMangler::mangleType(QualType T) {
   // If our type is instantiation-dependent but not dependent, we mangle
   // it as it was written in the source, removing any top-level sugar.
@@ -2576,11 +2515,6 @@ void CXXNameMangler::mangleType(QualType T) {
 
   bool isSubstitutable =
     isTypeSubstitutable(quals, ty, Context.getASTContext());
-  if (Context.isUniqueNameMangler() && isSYCLHostHalfType(ty)) {
-    // Set isSubstitutable to false for cl::sycl::detail::half_impl::half
-    // to achieve the same mangling for other components
-    isSubstitutable = false;
-  }
   if (isSubstitutable && mangleSubstitution(T))
     return;
 
@@ -3057,11 +2991,6 @@ void CXXNameMangler::mangleType(const RecordType *T) {
   mangleType(static_cast<const TagType*>(T));
 }
 void CXXNameMangler::mangleType(const TagType *T) {
-  if (Context.isUniqueNameMangler() && isSYCLHostHalfType(T)) {
-    // Mangle cl::sycl::detail::half_imple::half as _Float16
-    mangleType(Context.getASTContext().Float16Ty);
-    return;
-  }
   mangleName(T->getDecl());
 }
 

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -669,15 +669,10 @@ void CodeGenFunction::EmitOpenCLKernelMetadata(const FunctionDecl *FD,
                     llvm::MDNode::get(Context, AttrMDArgs));
   }
 
-  if (const SYCLIntelUsesGlobalWorkOffsetAttr *A =
-          FD->getAttr<SYCLIntelUsesGlobalWorkOffsetAttr>()) {
-    bool IsEnabled = A->getEnabled();
-    if (!IsEnabled) {
-      llvm::Metadata *AttrMDArgs[] = {
-          llvm::ConstantAsMetadata::get(Builder.getInt32(IsEnabled))};
-      Fn->setMetadata("uses_global_work_offset",
-                      llvm::MDNode::get(Context, AttrMDArgs));
-    }
+  if (const SYCLIntelNoGlobalWorkOffsetAttr *A =
+          FD->getAttr<SYCLIntelNoGlobalWorkOffsetAttr>()) {
+    if (A->getEnabled())
+      Fn->setMetadata("no_global_work_offset", llvm::MDNode::get(Context, {}));
   }
 }
 

clang/lib/Driver/Action.cpp

@@ -421,8 +421,12 @@ OffloadBundlingJobAction::OffloadBundlingJobAction(ActionList &Inputs)
 
 void OffloadUnbundlingJobAction::anchor() {}
 
-OffloadUnbundlingJobAction::OffloadUnbundlingJobAction(ActionList &Inputs)
-    : JobAction(OffloadUnbundlingJobClass, Inputs, Inputs.back()->getType()) {}
+OffloadUnbundlingJobAction::OffloadUnbundlingJobAction(Action *Input)
+    : JobAction(OffloadUnbundlingJobClass, Input, Input->getType()) {}
+
+OffloadUnbundlingJobAction::OffloadUnbundlingJobAction(ActionList &Inputs,
+                                                       types:: ID Type)
+    : JobAction(OffloadUnbundlingJobClass, Inputs, Type) {}
 
 void OffloadWrapperJobAction::anchor() {}