PP extension

README.md

@@ -120,3 +120,19 @@ Join [LLVM Discourse forums](https://discourse.llvm.org/), [discord chat](https:
 
 The LLVM project has adopted a [code of conduct](https://llvm.org/docs/CodeOfConduct.html) for
 participants to all modes of communication within the project.
+
+## Build Procedural-Parametric Extension
+
+It is not differs from mainstream llvm build.
+But you can use the recommended command line for debug build
+```
+cmake -DCMAKE_BUILD_TYPE:STRING=Debug -DBUILD_SHARED_LIBS:STRING=ON "-DLLVM_TARGETS_TO_BUILD:STRING=X86" -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE "-DLLVM_ENABLE_PROJECTS:STRING=clang" -DLLVM_OPTIMIZED_TABLEGEN:STRING=ON -DLLVM_CCACHE_BUILD:STRING=ON -DCMAKE_C_COMPILER:FILEPATH=<path-to-c-compiler> -DCMAKE_CXX_COMPILER:FILEPATH=<path-to-cpp-compiler> -S<source-path> -B<build-path> -G Ninja
+```
+After that it is needed to build clang:
+```
+cmake --build <build-path> --config Debug --target all --
+```
+And check if it is actually works:
+```
+<build-path>/bin/llvm-lit <source-path>/clang/test/CodeGen/pp-linked.c
+```

clang/include/clang/AST/Decl.h

@@ -1830,6 +1830,11 @@ class ParmVarDecl : public VarDecl {
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == ParmVar; }
 
+  /// Setter and checker for ident type
+  /// used in multimethods (pp-extension)
+  bool PPExtIsGenAsSpecIdType() const { return identType == PPExtIdentType::GenAsSpecForMM; }
+  void PPExtSetIdentType(PPExtIdentType t) { identType = t; }
+
 private:
   enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
 
@@ -1849,6 +1854,8 @@ class ParmVarDecl : public VarDecl {
 
   void setParameterIndexLarge(unsigned parameterIndex);
   unsigned getParameterIndexLarge() const;
+
+  PPExtIdentType identType = PPExtIdentType::Default;
 };
 
 enum class MultiVersionKind {
@@ -2546,6 +2553,24 @@ class FunctionDecl : public DeclaratorDecl,
     setParams(getASTContext(), NewParamInfo);
   }
 
+  struct PPMMParam {
+    RecordDecl* RD;
+    ParmVarDecl* PVD;
+    int IdxOfTypeTag; // of __pp_specialization_type
+    int ParamIdx; //- index of this parameter
+    RecordDecl* BaseRD; // base of generalization
+  };
+
+  struct MMParams
+  {
+    std::vector<PPMMParam> ParamsList;
+    bool IsSpecialization = false;
+  };
+
+  MMParams getRecordDeclsGenArgsForPPMM() const;
+
+  static int getNumOfSpecializationsPPMM(StringRef Name);
+
   /// Returns the minimum number of arguments needed to call this function. This
   /// may be fewer than the number of function parameters, if some of the
   /// parameters have default arguments (in C++).

clang/include/clang/Basic/IdentifierTable.h

@@ -561,6 +561,7 @@ class IdentifierInfoLookup {
 /// piece of the code, as each occurrence of every identifier goes through
 /// here when lexed.
 class IdentifierTable {
+public:
   // Shark shows that using MallocAllocator is *much* slower than using this
   // BumpPtrAllocator!
   using HashTableTy = llvm::StringMap<IdentifierInfo *, llvm::BumpPtrAllocator>;

clang/include/clang/Basic/Specifiers.h

@@ -390,6 +390,22 @@ namespace clang {
     }
     llvm_unreachable("Unknown AccessSpecifier");
   }
+
+  // PP-EXT
+  // Enum describes ppstruct identifier type
+  enum class PPExtIdentType
+  {
+    // Default ident type - generalization
+    //  or any specialization
+    //  (including recursive ones)
+    Default,
+    // Special ident type - generalization with ".void" postfix
+    //  It is used in multimethod specializations
+    //  to show that this method should be specialized
+    //  for generalization (instead of one of specializations)
+    GenAsSpecForMM
+  };
+
 } // end namespace clang
 
 #endif // LLVM_CLANG_BASIC_SPECIFIERS_H

clang/include/clang/Parse/Parser.h

@@ -252,6 +252,70 @@ class Parser : public CodeCompletionHandler {
   /// Current kind of OpenMP clause
   OpenMPClauseKind OMPClauseKind = llvm::omp::OMPC_unknown;
 
+  /// Part of PP-EXT
+  /// When true, we are in parsing base types of pp multimethod invocation
+  /// (between '<' and '>')
+  /// MultiMethod<...here...>();
+  bool IsInPPMM = false;
+
+  /// PP-EXT
+  using NameAndPtr = std::pair<StringRef, bool>;
+
+  std::string PPExtConstructGenName(
+    StringRef BaseName,
+    NameAndPtr SpecName,
+    bool AddPrefix = true
+  );
+
+  std::string PPExtConstructGenName(
+    std::vector<NameAndPtr> Names,
+    ParsedAttributes& PAttrs
+  );
+
+  RecordDecl* PPExtCreateGeneralization(
+    StringRef Name,
+    RecordDecl* Head,
+    RecordDecl* Tail,
+    SourceLocation Loc,
+    ParsedAttributes& PAttrs);
+
+  RecordDecl* PPExtGetTypeByName(StringRef Name);
+
+  using PPIdDescription = std::pair<PPExtIdentType, IdentifierInfo*>;
+  PPIdDescription PPExtGetIdForExistingOrNewlyCreatedGen(
+    StringRef BaseName,
+    ParsedAttributes& PAttrs,
+    bool NeedToAddLParen = true,
+    bool SaveLastIdent = false
+  );
+
+  enum class PPStructType {
+    Default,
+    Generalization,
+    Specialization
+  };
+
+  PPStructType PPExtGetStructType(const RecordDecl* RD) const;
+
+  struct PPStructInitDesc {
+    NamedDecl* VD;
+    const RecordDecl* RD;
+    const PPStructType Type;
+  };
+
+  std::vector<PPStructInitDesc> PPExtGetRDListToInit(const RecordDecl* RD) const;
+
+  std::string PPExtConstructTagName(StringRef GenName);
+
+  struct PPMemberInitData {
+    Expr* Assign;
+    Expr* MemberAccess;
+  };
+
+  PPMemberInitData PPExtInitPPStruct(PPStructInitDesc IDesc, Expr* MemberAccess);
+
+  static DeclSpec::TST PPExtGetFieldTypeByTokKind(tok::TokenKind TK);
+
   /// RAII class that manages the template parameter depth.
   class TemplateParameterDepthRAII {
     unsigned &Depth;
@@ -483,6 +547,16 @@ class Parser : public CodeCompletionHandler {
     return ParseTopLevelDecl(Result, IS);
   }
 
+  std::vector<clang::Parser::DeclGroupPtrTy> m_PPTypedefs;
+  std::vector<clang::Parser::DeclGroupPtrTy> m_PPCtors;
+  std::vector<clang::Parser::DeclGroupPtrTy> m_PPGlobalVars;
+  // PP-EXT TODO: Combine these two fields
+  bool IsInPPMultimethod = false;
+  StringRef PPMultimethodNameStr;
+  Declarator* PPMMDecl;
+  int NumberOfPPSpecilizations = 0;
+  void FinalizePPArgsParsing();
+
   /// ConsumeToken - Consume the current 'peek token' and lex the next one.
   /// This does not work with special tokens: string literals, code completion,
   /// annotation tokens and balanced tokens must be handled using the specific
@@ -2172,6 +2246,93 @@ class Parser : public CodeCompletionHandler {
   StmtResult ParseSEHFinallyBlock(SourceLocation Loc);
   StmtResult ParseSEHLeaveStatement();
 
+//===--------------------------------------------------------------------===//
+  // Procedural-parametric extension
+
+  struct SpecsDescr {
+    std::string VariantName;
+    IdentifierInfo* FullNameIInfo = nullptr;
+    bool IsPtr = false;
+  };
+  using SpecsVec = SmallVector<SpecsDescr>;
+  Optional<SpecsVec> TryParsePPExt(Decl *TagDecl,
+                         SmallVector<Decl *, 32>& FieldDecls);
+
+  void PPExtAddAlign8Attr(ParsedAttributes &Attrs);
+
+  void FieldGenerator(const char* FieldName,
+                          DeclSpec::TST FieldType,
+                          Decl *TagDecl,
+                          RecordDecl* RD,
+                          SmallVector<Decl *, 32>& FieldDecls,
+                          const ParsedAttributes& Attrs,
+                          bool IsPointer);
+  enum class PPFuncMode {
+    Ctor,
+    Init,
+    Increment,
+    CreateSpec,
+    MMDefault
+  };
+
+  struct PPMangledNames {
+    struct PPVariant {
+      std::string VariantName;
+      std::string VariantInitFuncName;
+      std::string VariantTagVariableName;
+      std::string VariantCreateSpecFuncName;
+    };
+
+    std::string BaseStructName;
+    std::string BaseTagVariableName;
+    std::string BaseCtorName;
+    std::string BaseIncFuncName;
+    std::vector<PPVariant> VariantStructNames;
+
+    void setBaseName(std::string BaseName);
+
+    void addVariantName(std::string VariantName);
+
+    std::string MMName;
+    std::string MMArrayName;
+
+    void setMMName(std::string Name);
+
+    LLVM_ATTRIBUTE_NOINLINE
+    void dump();
+  };
+
+  static void dumpPPNames(PPMangledNames& p);
+
+  void AddStmts(StmtVector& Stmts,
+                PPFuncMode Mode,
+                std::string StrVarName,
+                PPMangledNames& ppMNames);
+
+  void AddFunc(std::string FuncName,
+               PPFuncMode Mode,
+               std::string TagNameToInit,
+               PPMangledNames& ppMNames,
+               DeclSpec::TST ReturnType = DeclSpec::TST_void,
+               SmallVector<DeclaratorChunk::ParamInfo, 16> *ParamInfo = nullptr);
+
+  void FieldGenerator(const char* FieldName,
+                      DeclSpec::TST FieldType,
+                      RecordDecl* RD,
+                      bool IsPointer,
+                      const ParsedAttributes& TestAttrs,
+                      Decl *TestDecl,
+                      SmallVector<Decl *, 32>& FieldDecls);
+
+  Sema::DeclGroupPtrTy VarGenerate(std::string TypeVarName,
+                                   bool IsPointer = false,
+                                   std::string TypeNameStr = "");
+  Sema::DeclGroupPtrTy TypedefGenerate(std::string TypeVarName,
+                                       DeclSpec::TST ReturnTypeSpecifier,
+                                       SmallVector<DeclaratorChunk::ParamInfo, 16>& ParamInfo);
+
+  bool PPExtNextTokIsLParen = false;
+
   //===--------------------------------------------------------------------===//
   // Objective-C Statements
 

clang/include/clang/Sema/DeclSpec.h

@@ -399,6 +399,8 @@ class DeclSpec {
 
   ObjCDeclSpec *ObjCQualifiers;
 
+  PPExtIdentType identType = PPExtIdentType::Default;
+
   static bool isTypeRep(TST T) {
     return (T == TST_typename || T == TST_typeofType ||
             T == TST_underlyingType || T == TST_atomic);
@@ -816,6 +818,11 @@ class DeclSpec {
   ///
   /// Only tag declspecs can stand alone.
   bool isMissingDeclaratorOk();
+
+  /// Setter and getter for ident type
+  /// used in multimethods (pp-extension)
+  PPExtIdentType PPExtGetIdentType() const { return identType; }
+  void PPExtSetIdentType(PPExtIdentType t) { identType = t; }
 };
 
 /// Captures information about "declaration specifiers" specific to

clang/include/clang/Sema/Scope.h

@@ -147,10 +147,12 @@ class Scope {
   /// scope.
   Scope *AnyParent;
 
+public:
   /// Flags - This contains a set of ScopeFlags, which indicates how the scope
   /// interrelates with other control flow statements.
   unsigned Flags;
 
+private:
   /// Depth - This is the depth of this scope.  The translation-unit scope has
   /// depth 0.
   unsigned short Depth;
@@ -161,10 +163,12 @@ class Scope {
 
   unsigned short MSCurManglingNumber;
 
+public:
   /// PrototypeDepth - This is the number of function prototype scopes
   /// enclosing this scope, including this scope.
   unsigned short PrototypeDepth;
 
+private:
   /// PrototypeIndex - This is the number of parameters currently
   /// declared in this scope.
   unsigned short PrototypeIndex;

clang/lib/AST/ASTContext.cpp

@@ -11588,6 +11588,13 @@ bool ASTContext::DeclMustBeEmitted(const Decl *D) {
     return true;
 
   if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
+
+    if (FD->getName().startswith("__pp_mm_")) {
+      // PP-EXT: Always emit bodies for multimethods
+      // even if they are marked as `static`
+      return true;
+    }
+
     // Forward declarations aren't required.
     if (!FD->doesThisDeclarationHaveABody())
       return FD->doesDeclarationForceExternallyVisibleDefinition();