[llvm-pdbdump] Dump restrict type qualifier

[zturner]

Can you add a line for the function signature under the types section? We should see something like this:

int __cdecl(const volatile int* __restrict)

Aside from that, looks good.

[asmith]

Thanks! This has a dependence on D43060 and will wait for that one before committing.

[zturner]

Yea, sorry about that, rnk is OOO right now, I'll tell him to look at it tomorrow.

[majnemer]

test/tools/llvm-pdbdump/Inputs/TypeQualifiersTest.cpp

41

Extra semicolon?

[rnk]

tools/llvm-pdbutil/PrettyFunctionDumper.cpp

249–252

I'm pretty sure these modifiers go on the other side of the pointee type, like __restrict.

tools/llvm-pdbutil/PrettyTypedefDumper.cpp

51–54

These probably go on the other side as well.

test/tools/llvm-pdbdump/Inputs/TypeQualifiersTest.cpp

+// Compile with "cl /c /Zi /GR- TypeQualifiersTest.cpp"
+// Link with "link TypeQualifiersTest.obj /debug /nodefaultlib /entry:main"
+
+union Union {
+  int * __restrict x_member;
+  float * __restrict y_member;
+  int* volatile __restrict m_volatile;
+  const char* m_const;
+};
+
+int f(const volatile int* __restrict arg_crv) {
+  Union u;
+  return 1;
+}
+
+void g(int& __restrict arg_ref) {
+}
+
+namespace NS {
+  class Class {
+  public:
+    int get() const { return 1;}
+    int set() __restrict { return 2; }
+    void help() volatile { return; }
+  };
+
+  struct Foo {
+    int a;
+    int b;
+    int func(int x) __restrict { return 1; }
+  };
+
+  Foo s = { 10 };
+
+  const int* __restrict p_object = &s.a;
+
+  volatile int Foo:: * __restrict p_data_member = &Foo::a;
+
+  int (Foo::* p_member_func)(int) __restrict = &Foo::func;
+}
+
+typedef long* __restrict RestrictTypedef;
+RestrictTypedef RestrictVar;
+
+typedef volatile int* __restrict RankNArray[10][100];
+RankNArray ArrayVar;
+
+int main() {
+  NS::Class ClassVar;
+  ClassVar.get();
+  ClassVar.help();
+  ClassVar.set();
+
+  return 0;
+}

test/tools/llvm-pdbdump/type-qualifiers.test

+; RUN: llvm-pdbutil pretty -all -class-recurse-depth=1 \
+; RUN:   %p/Inputs/TypeQualifiersTest.pdb > %t
+; RUN: FileCheck -input-file=%t %s -check-prefix=GLOBALS_FUNC
+; RUN: FileCheck -input-file=%t %s -check-prefix=GLOBALS_DATA
+; RUN: FileCheck -input-file=%t %s -check-prefix=QUALS
+
+; GLOBALS_FUNC: ---GLOBALS---
+; GLOBALS_FUNC-DAG: int __cdecl f(const volatile int* __restrict arg_crv)
+; GLOBALS_FUNC-DAG: void __cdecl g(int& __restrict arg_ref)
+
+; GLOBALS_DATA: ---GLOBALS---
+; GLOBALS_DATA-DAG: static volatile int* __restrict ArrayVar[10][100]
+; GLOBALS_DATA-DAG: static long* __restrict RestrictVar
+; GLOBALS_DATA-DAG: static const int* __restrict NS::p_object
+; GLOBALS_DATA-DAG: static NS::Foo NS::s
+; GLOBALS_DATA-DAG: static volatile int* __restrict NS::p_data_member
+
+; QUALS: ---TYPES---
+; QUALS-DAG: typedef RankNArray
+; QUALS-DAG: typedef long* __restrict RestrictTypedef
+; QUALS: union Union
+; QUALS-DAG: int* __restrict x_member
+; QUALS-DAG: float* __restrict y_member
+; QUALS-DAG: int* volatile __restrict m_volatile
+; QUALS-DAG: const char* m_const

tools/llvm-pdbutil/PrettyFunctionDumper.cpp

if (!PointeeType)
     return;
 
   if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
     FunctionDumper NestedDumper(Printer);
     PointerType Pointer =
         Symbol.isReference() ? PointerType::Reference : PointerType::Pointer;
     NestedDumper.start(*FuncSig, nullptr, Pointer);
   } else {
     if (Symbol.isConstType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
     if (Symbol.isVolatileType())
       WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
     PointeeType->dump(*this);
     Printer << (Symbol.isReference() ? "&" : "*");
+
+    if (Symbol.getRawSymbol().isRestrictedType())
+      WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
   }
 }
 
 void FunctionDumper::dump(const PDBSymbolTypeUDT &Symbol) {
   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
 }

tools/llvm-pdbutil/PrettyTypedefDumper.cpp

 }
 
 void TypedefDumper::dump(const PDBSymbolTypeEnum &Symbol) {
   WithColor(Printer, PDB_ColorItem::Keyword).get() << "enum ";
   WithColor(Printer, PDB_ColorItem::Type).get() << " " << Symbol.getName();
 }
 
 void TypedefDumper::dump(const PDBSymbolTypePointer &Symbol) {
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "const ";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << "volatile ";
   auto PointeeType = Symbol.getPointeeType();
   if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
     FunctionDumper::PointerType Pointer = FunctionDumper::PointerType::Pointer;
     if (Symbol.isReference())
       Pointer = FunctionDumper::PointerType::Reference;
     FunctionDumper NestedDumper(Printer);
     NestedDumper.start(*FuncSig, nullptr, Pointer);
   } else {
     PointeeType->dump(*this);
     Printer << ((Symbol.isReference()) ? "&" : "*");
   }
+
+  if (Symbol.getRawSymbol().isRestrictedType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
 }
 
 void TypedefDumper::dump(const PDBSymbolTypeFunctionSig &Symbol) {
   FunctionDumper Dumper(Printer);
   Dumper.start(Symbol, nullptr, FunctionDumper::PointerType::None);
 }
 
 void TypedefDumper::dump(const PDBSymbolTypeUDT &Symbol) {
   WithColor(Printer, PDB_ColorItem::Keyword).get() << "class ";
   WithColor(Printer, PDB_ColorItem::Type).get() << Symbol.getName();
 }

tools/llvm-pdbutil/PrettyVariableDumper.cpp

if (auto Arguments = Symbol.getArguments()) {
     }
   }
   Printer << ")";
 
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile";
+
+  if (Symbol.getRawSymbol().isRestrictedType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict";
 }
 
 void VariableDumper::dump(const PDBSymbolTypePointer &Symbol) {
   auto PointeeType = Symbol.getPointeeType();
   if (!PointeeType)
     return;
   PointeeType->dump(*this);
   if (auto FuncSig = unique_dyn_cast<PDBSymbolTypeFunctionSig>(PointeeType)) {
     // A hack to get the calling convention in the right spot.
     Printer << " (";
     PDB_CallingConv CC = FuncSig->getCallingConvention();
     WithColor(Printer, PDB_ColorItem::Keyword).get() << CC << " ";
   } else if (isa<PDBSymbolTypeArray>(PointeeType)) {
     Printer << " (";
   }
   Printer << (Symbol.isReference() ? "&" : "*");
   if (Symbol.isConstType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " const ";
   if (Symbol.isVolatileType())
     WithColor(Printer, PDB_ColorItem::Keyword).get() << " volatile ";
+
+  if (Symbol.getRawSymbol().isRestrictedType())
+    WithColor(Printer, PDB_ColorItem::Keyword).get() << " __restrict ";
 }
 
 void VariableDumper::dumpRight(const PDBSymbolTypePointer &Symbol) {
   auto PointeeType = Symbol.getPointeeType();
   assert(PointeeType);
   if (!PointeeType)
     return;
   if (isa<PDBSymbolTypeFunctionSig>(PointeeType) ||