[llvm-readelf] - Print unknown st_other value if present in GNU output.

[grimar]

Summary

This is a fix for https://bugs.llvm.org/show_bug.cgi?id=40785.

llvm-readelf does not print the st_value of the symbol when
st_value has any non-visibility bits set.

This patch:

• Aligns "Ndx" row for the default and a new cases.

(it was 1 space character off for the case when "PROTECTED" visibility was printed)

• Prints "[<other>: 0x??]" for symbols which has an additional st_other bits set.

In compare with GNU, this logic is a bit simpler and seems to be more consistent.

For MIPS GNU can print named flags, though can't print a mix of them:
0: 00000000 0 NOTYPE LOCAL DEFAULT UND
1: 00000000 0 NOTYPE GLOBAL DEFAULT [OPTIONAL] UND a1
2: 00000000 0 NOTYPE GLOBAL DEFAULT [MIPS PLT] UND a2
3: 00000000 0 NOTYPE GLOBAL DEFAULT [MIPS PIC] UND a3
4: 00000000 0 NOTYPE GLOBAL DEFAULT [MICROMIPS] UND a4
5: 00000000 0 NOTYPE GLOBAL DEFAULT [MIPS16] UND a5
6: 00000000 0 NOTYPE GLOBAL DEFAULT [<other>: c] UND b1
7: 00000000 0 NOTYPE GLOBAL DEFAULT [<other>: 28] UND b2

On PPC64 it can print a localentry value that is encoded in the high bits of st_other
63: 0000000000000850 208 FUNC GLOBAL DEFAULT [<localentry>: 8] 12

We chose to print the raw st_other field, prefixed with '0x'.

[MaskRay]

test/tools/llvm-readobj/elf-symbol-visibility.test

51–85

Can the Other: [ 4 ] test be added here? I think using one test is fine. The additional YAML test does not make it easier to read.

tools/llvm-readobj/ELFDumper.cpp

3276

The description says:

Prints "[<other>: 0x??]" for symbols which has an additional st_other bits set.

However, the code actually uses [<st_other: ...>] (I would favor [<other:...>] because it is shorter, if you don't think that confusing)

[MaskRay]

In compare with GNU, this logic is simpler and seems more consistent. The details about the known differences were listed in the comments on a bug page.

We should summarize what GNU readelf does. IIRC it interprets certain bits for some archs

0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND 
1: 00000000     0 NOTYPE  GLOBAL DEFAULT [OPTIONAL]   UND a1
2: 00000000     0 NOTYPE  GLOBAL DEFAULT [MIPS PLT]   UND a2
3: 00000000     0 NOTYPE  GLOBAL DEFAULT [MIPS PIC]   UND a3
4: 00000000     0 NOTYPE  GLOBAL DEFAULT [MICROMIPS]   UND a4
5: 00000000     0 NOTYPE  GLOBAL DEFAULT [MIPS16]   UND a5
6: 00000000     0 NOTYPE  GLOBAL DEFAULT [<other>: c]   UND b1
7: 00000000     0 NOTYPE  GLOBAL DEFAULT [<other>: 28]   UND b2

On PPC64, it just leaves the field uninterpreted. We choose to print the raw st_other field, prefixed with 0x.

[grimar]

test/tools/llvm-readobj/elf-symbol-visibility.test

51–85

Idea to have 2 tests is to check that we add the additional padding added when we have st_other with non-visibility flags.
I.e. to check the output with --strict-whitespace --match-full-lines before and after adding the padding.
I think it is useful.

tools/llvm-readobj/ELFDumper.cpp

3276

We print it under a row named "Vis". Probably it is not so clear what is "other" when we print the visibility.
It is also probably not clear if "other" contain the whole st_other value or st_other & ~0x3.

So "st_other" IMO is a bit better. Lets see what others think.

[MaskRay]

test/tools/llvm-readobj/elf-symbol-visibility.test

51–85

Sorry, I didn't notice that the headers are different. I agree that we should have 2 tests.

tools/llvm-readobj/ELFDumper.cpp

351

I think James will suggest a better wording here... ELFYAML.cpp has such comments:

// Symbol's Other field is a bit special. It is usually a field that
// represents st_other and holds the symbol visibility. However, on some
// platforms, it can contain bit fields and regular values, or even sometimes a
// crazy mix of them (see comments for NormalizedOther). Because of this, we
// need special handling.

355

llvm::is_contained

361

OtherBitsUsed may be confusing. I am not sure what the best is. One suggestion is NonVisibilityBitsUsed. Let's see what others think.

[jhenderson]

test/tools/llvm-readobj/elf-symbol-visibility.test

5

a -> the

27–32

I don't mind too much, but maybe you could simplify this whilst still preserving the core of the test by removing --match-full-lines. You only really care about what's going around the Visibility columns (and the spacing to the Ndx column), so everything else is a bit superfluous (e.g. the Type and Value columns).

Same comment applies below to the second test case.

tools/llvm-readobj/ELFDumper.cpp

351

I do have some suggestions:

"One holds visibility (STV_* bits)" etc -> "The first two bits hold the symbol visibility (STV_*)" and the remainder hold other platform-specific values."

I'd delete the entire STO_* brackets bit, because the elf gABI doesn't officially support anything defined in those bits (it certainly doesn't have an STO_* enum), so the meaning is entirely platform dependent.

361

NonVisibilityBitsUsed sounds good to me.

594–595

Perhaps worth naming this last field: bool /*OtherBitsUsed*/

3257

What's this change about?

3276

I don't have a strong feeling either way. I think it's rare enough that it won't matter. <other:...> is fine by me as it is a bit shorter, and I don't think it'll be that confusing (after all how would the value work if it didn't include the visibility bits?).

5320–5321

Same as earlier comment.

[grimar]

• Addressed review comments.

test/tools/llvm-readobj/elf-symbol-visibility.test

27–32

OK.

tools/llvm-readobj/ELFDumper.cpp

355

I do not think I can use llvm::is_contained here? I need to find 'Elf_Sym which has Sym.st_other & ~0x3 != 0.
llvm::is_contained would help if I needed to find a particular Elf_Sym.

3257

Before this patch "Ndx" row was 1 space off for the case when the "PROTECTED" visibility (has the longest spelling) was printed.

3276

2:1, I renamed to "other".

[jhenderson]

test/tools/llvm-readobj/elf-symbol-visibility.test

27–32

Maybe keep the names though, to self-document and make sure the right symbols match up :)

tools/llvm-readobj/ELFDumper.cpp

3257

Okay. Does the changed format match up with GNU readelf?

[grimar]

• Addressed review comments.

tools/llvm-readobj/ELFDumper.cpp

3257

Nope. And wasn't before. GNU output is off for Ndx and Name:

Symbol table '.symtab' contains 5 entries:
   Num:    Value  Size Type    Bind   Vis      Ndx Name
     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 00000000     0 NOTYPE  GLOBAL DEFAULT  UND default
     2: 00000000     0 NOTYPE  GLOBAL INTERNAL  UND internal
     3: 00000000     0 NOTYPE  GLOBAL HIDDEN   UND hidden
     4: 00000000     0 NOTYPE  GLOBAL PROTECTED  UND protected

We do not need to try be bug compatible here it seems, since we improve the alignment in favor of readability.

Our output is perfect now:

Symbol table '.symtab' contains 5 entries:
   Num:    Value  Size Type    Bind   Vis       Ndx Name
     0: 00000000     0 NOTYPE  LOCAL  DEFAULT   UND
     1: 00000000     0 NOTYPE  GLOBAL DEFAULT   UND default
     2: 00000000     0 NOTYPE  GLOBAL INTERNAL  UND internal
     3: 00000000     0 NOTYPE  GLOBAL HIDDEN    UND hidden
     4: 00000000     0 NOTYPE  GLOBAL PROTECTED UND protected

[jhenderson]

LGTM.

test/tools/llvm-readobj/elf-symbol-visibility.test

-# Show that llvm-readobj prints the symbol visibility where recognised, or
-# something sensible when not, for both GNU and LLVM output.
+## Show that llvm-readobj prints the symbol visibility where recognised, or
+## something sensible when not, for both GNU and LLVM output.
 
-# RUN: yaml2obj %s > %t
-# RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=LLVM
-# RUN: llvm-readelf --symbols %t | FileCheck %s --check-prefix=GNU
+## Check how we dump symbols when they have only STV_* bits set for st_other.
+## (This is the most common case).
+
+# RUN: yaml2obj --docnum=1 %s > %t1.o
+# RUN: llvm-readobj --symbols %t1.o | FileCheck %s --check-prefix=LLVM
+# RUN: llvm-readelf --symbols %t1.o | FileCheck %s --strict-whitespace --check-prefix=GNU
 
 # LLVM:      Name: default
 # LLVM:      Other: 0
 # LLVM:      Name: internal
 # LLVM:      Other [ (0x1)
 # LLVM-NEXT:   STV_INTERNAL (0x1)
 # LLVM-NEXT: ]
 # LLVM:      Name: hidden
 # LLVM:      Other [ (0x2)
 # LLVM-NEXT:   STV_HIDDEN (0x2)
 # LLVM-NEXT: ]
 # LLVM:      Name: protected
 # LLVM:      Other [ (0x3)
 # LLVM-NEXT:   STV_PROTECTED (0x3)
 # LLVM-NEXT: ]
-# LLVM:      Name: other
-# LLVM:      Other [ (0x4)
-# LLVM-NEXT: ]
 
-# FIXME - the "other" symbol should print something indicating its non-zero st_other value.
-# See https://bugs.llvm.org/show_bug.cgi?id=40785.
-# GNU:      DEFAULT   {{.*}} default
-# GNU-NEXT: INTERNAL  {{.*}} internal
-# GNU-NEXT: HIDDEN    {{.*}} hidden
-# GNU-NEXT: PROTECTED {{.*}} protected
-# GNU-NEXT: DEFAULT   {{.*}} other
+# GNU:      Vis       Ndx
+# GNU-NEXT: DEFAULT   UND
+# GNU-NEXT: DEFAULT   UND
+# GNU-NEXT: INTERNAL  UND
+# GNU-NEXT: HIDDEN    UND
+# GNU-NEXT: PROTECTED UND
 
-!ELF
+--- !ELF
 FileHeader:
   Class:   ELFCLASS32
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_386
 Symbols:
   - Name: default
     Other: [ STV_DEFAULT ]
     Binding: STB_GLOBAL
   - Name: internal
     Other: [ STV_INTERNAL ]
     Binding: STB_GLOBAL
   - Name: hidden
     Other: [ STV_HIDDEN ]
     Binding: STB_GLOBAL
   - Name: protected
     Other: [ STV_PROTECTED ]
     Binding: STB_GLOBAL
+
+## Check the output when we have non-visibility bits set for at least one of the symbols.
+
+# RUN: yaml2obj --docnum=2 %s > %t2.o
+# RUN: llvm-readobj --symbols %t2.o | FileCheck %s --check-prefixes=LLVM,LLVM-OTHER
+# RUN: llvm-readelf --symbols %t2.o | FileCheck %s --strict-whitespace --check-prefix=GNU-OTHER
+
+# LLVM-OTHER:      Name: other
+# LLVM-OTHER:      Other [ (0x4)
+# LLVM-OTHER-NEXT: ]
+
+#      GNU-OTHER: Vis                    Ndx Name
+# GNU-OTHER-NEXT: DEFAULT                UND 
+# GNU-OTHER-NEXT: DEFAULT                UND default
+# GNU-OTHER-NEXT: INTERNAL               UND internal
+# GNU-OTHER-NEXT: HIDDEN                 UND hidden
+# GNU-OTHER-NEXT: PROTECTED              UND protected
+# GNU-OTHER-NEXT: DEFAULT [<other: 0x4>] UND other
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS32
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_386
+Symbols:
+  - Name: default
+    Other: [ STV_DEFAULT ]
+  - Name: internal
+    Other: [ STV_INTERNAL ]
+  - Name: hidden
+    Other: [ STV_HIDDEN ]
+  - Name: protected
+    Other: [ STV_PROTECTED ]
   - Name: other
-    Binding: STB_GLOBAL
     Other: [ 4 ]

tools/llvm-readobj/ELFDumper.cpp

StrTable = unwrapOrError(ObjF->getFileName(),
                              Obj->getStringTableForSymtab(*DotSymtabSec));
     Syms = unwrapOrError(ObjF->getFileName(), Obj->symbols(DotSymtabSec));
     SymtabName =
         unwrapOrError(ObjF->getFileName(), Obj->getSectionName(DotSymtabSec));
     Entries = DotSymtabSec->getEntityCount();
   }
   if (Syms.begin() == Syms.end())
     return;
-  ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries);
+
+  // The st_other field has 2 logical parts. The first two bits hold the symbol
+  // visibility (STV_*) and the remainder hold other platform-specific values.
+  bool NonVisibilityBitsUsed = llvm::find_if(Syms, [](const Elf_Sym &S) {
+                                 return S.st_other & ~0x3;
+                               }) != Syms.end();
+
+  ELFDumperStyle->printSymtabMessage(Obj, SymtabName, Entries,
+                                     NonVisibilityBitsUsed);
   for (const auto &Sym : Syms)
-    ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic);
+    ELFDumperStyle->printSymbol(Obj, &Sym, Syms.begin(), StrTable, IsDynamic,
+                                NonVisibilityBitsUsed);
 }
 
 template <class ELFT> class MipsGOTParser;
 
 template <typename ELFT> class DumpStyle {
 public:
   using Elf_Shdr = typename ELFT::Shdr;
   using Elf_Sym = typename ELFT::Sym;
public:
   virtual void printRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSectionHeaders(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymbols(const ELFFile<ELFT> *Obj, bool PrintSymbols,
                             bool PrintDynamicSymbols) = 0;
   virtual void printHashSymbols(const ELFFile<ELFT> *Obj) {}
   virtual void printDynamic(const ELFFile<ELFT> *Obj) {}
   virtual void printDynamicRelocations(const ELFFile<ELFT> *Obj) = 0;
   virtual void printSymtabMessage(const ELFFile<ELFT> *Obj, StringRef Name,
-                                  size_t Offset) {}
+                                  size_t Offset, bool NonVisibilityBitsUsed) {}
   virtual void printSymbol(const ELFFile<ELFT> *Obj, const Elf_Sym *Symbol,
                            const Elf_Sym *FirstSym, StringRef StrTable,
-                           bool IsDynamic) = 0;
+                           bool IsDynamic, bool NonVisibilityBitsUsed) = 0;
   virtual void printProgramHeaders(const ELFFile<ELFT> *Obj,
                                    bool PrintProgramHeaders,
                                    cl::boolOrDefault PrintSectionMapping) = 0;
   virtual void printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                          const Elf_Shdr *Sec) = 0;
   virtual void printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                              const Elf_Shdr *Sec) = 0;
   virtual void printVersionDependencySection(const ELFFile<ELFT> *Obj,
public:
   void printGroupSections(const ELFFile<ELFT> *Obj) override;
   void printRelocations(const ELFO *Obj) override;
   void printSectionHeaders(const ELFO *Obj) override;
   void printSymbols(const ELFO *Obj, bool PrintSymbols,
                     bool PrintDynamicSymbols) override;
   void printHashSymbols(const ELFO *Obj) override;
   void printDynamic(const ELFFile<ELFT> *Obj) override;
   void printDynamicRelocations(const ELFO *Obj) override;
-  void printSymtabMessage(const ELFO *Obj, StringRef Name,
-                          size_t Offset) override;
+  void printSymtabMessage(const ELFO *Obj, StringRef Name, size_t Offset,
+                          bool NonVisibilityBitsUsed) override;
   void printProgramHeaders(const ELFO *Obj, bool PrintProgramHeaders,
                            cl::boolOrDefault PrintSectionMapping) override;
   void printVersionSymbolSection(const ELFFile<ELFT> *Obj,
                                  const Elf_Shdr *Sec) override;
   void printVersionDefinitionSection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
   void printVersionDependencySection(const ELFFile<ELFT> *Obj,
                                      const Elf_Shdr *Sec) override;
private:
   void printHashedSymbol(const ELFO *Obj, const Elf_Sym *FirstSym, uint32_t Sym,
                          StringRef StrTable, uint32_t Bucket);
   void printRelocHeader(unsigned SType);
   void printRelocation(const ELFO *Obj, const Elf_Shdr *SymTab,
                        const Elf_Rela &R, bool IsRela);
   void printRelocation(const ELFO *Obj, const Elf_Sym *Sym,
                        StringRef SymbolName, const Elf_Rela &R, bool IsRela);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
-                   StringRef StrTable, bool IsDynamic) override;
+                   StringRef StrTable, bool IsDynamic,
+                   bool NonVisibilityBitsUsed) override;
   std::string getSymbolSectionNdx(const ELFO *Obj, const Elf_Sym *Symbol,
                                   const Elf_Sym *FirstSym);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela R, bool IsRela);
   bool checkTLSSections(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkoffsets(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkVMA(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   bool checkPTDynamic(const Elf_Phdr &Phdr, const Elf_Shdr &Sec);
   void printProgramHeaders(const ELFO *Obj);
public:
   void printMipsPLT(const MipsGOTParser<ELFT> &Parser) override;
 
 private:
   void printRelocation(const ELFO *Obj, Elf_Rela Rel, const Elf_Shdr *SymTab);
   void printDynamicRelocation(const ELFO *Obj, Elf_Rela Rel);
   void printSymbols(const ELFO *Obj);
   void printDynamicSymbols(const ELFO *Obj);
   void printSymbol(const ELFO *Obj, const Elf_Sym *Symbol, const Elf_Sym *First,
-                   StringRef StrTable, bool IsDynamic) override;
+                   StringRef StrTable, bool IsDynamic,
+                   bool /*NonVisibilityBitsUsed*/) override;
   void printProgramHeaders(const ELFO *Obj);
   void printSectionMapping(const ELFO *Obj) {}
 
   ScopedPrinter &W;
 };
 
 } // end anonymous namespace
 
OS << "Key to Flags:\n"
      << "  I (info), L (link order), G (group), T (TLS), E (exclude),\
  x (unknown)\n"
      << "  O (extra OS processing required) o (OS specific),\
  p (processor specific)\n";
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printSymtabMessage(const ELFO *Obj, StringRef Name,
-                                        size_t Entries) {
+                                        size_t Entries,
+                                        bool NonVisibilityBitsUsed) {
   if (!Name.empty())
     OS << "\nSymbol table '" << Name << "' contains " << Entries
        << " entries:\n";
   else
     OS << "\n Symbol table for image:\n";
 
   if (ELFT::Is64Bits)
-    OS << "   Num:    Value          Size Type    Bind   Vis      Ndx Name\n";
+    OS << "   Num:    Value          Size Type    Bind   Vis";
   else
-    OS << "   Num:    Value  Size Type    Bind   Vis      Ndx Name\n";
+    OS << "   Num:    Value  Size Type    Bind   Vis";
+
+  if (NonVisibilityBitsUsed)
+    OS << "             ";
+  OS << "       Ndx Name\n";
 }
 
 template <class ELFT>
 std::string GNUStyle<ELFT>::getSymbolSectionNdx(const ELFO *Obj,
                                                 const Elf_Sym *Symbol,
                                                 const Elf_Sym *FirstSym) {
   unsigned SectionIndex = Symbol->st_shndx;
   switch (SectionIndex) {
default:
     // A normal section with an index
     return to_string(format_decimal(SectionIndex, 3));
   }
 }
 
 template <class ELFT>
 void GNUStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
                                  const Elf_Sym *FirstSym, StringRef StrTable,
-                                 bool IsDynamic) {
+                                 bool IsDynamic, bool NonVisibilityBitsUsed) {
   static int Idx = 0;
   static bool Dynamic = true;
 
   // If this function was called with a different value from IsDynamic
   // from last call, happens when we move from dynamic to static symbol
   // table, "Num" field should be reset.
   if (!Dynamic != !IsDynamic) {
     Idx = 0;
     Dynamic = false;
   }
 
   unsigned Bias = ELFT::Is64Bits ? 8 : 0;
   Field Fields[8] = {0,         8,         17 + Bias, 23 + Bias,
-                     31 + Bias, 38 + Bias, 47 + Bias, 51 + Bias};
+                     31 + Bias, 38 + Bias, 48 + Bias, 51 + Bias};
   Fields[0].Str = to_string(format_decimal(Idx++, 6)) + ":";
   Fields[1].Str = to_string(
       format_hex_no_prefix(Symbol->st_value, ELFT::Is64Bits ? 16 : 8));
   Fields[2].Str = to_string(format_decimal(Symbol->st_size, 5));
 
   unsigned char SymbolType = Symbol->getType();
   if (Obj->getHeader()->e_machine == ELF::EM_AMDGPU &&
       SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
     Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
   else
     Fields[3].Str = printEnum(SymbolType, makeArrayRef(ElfSymbolTypes));
 
   Fields[4].Str =
       printEnum(Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
   Fields[5].Str =
       printEnum(Symbol->getVisibility(), makeArrayRef(ElfSymbolVisibilities));
+  if (Symbol->st_other & ~0x3)
+    Fields[5].Str +=
+        " [<other: " + to_string(format_hex(Symbol->st_other, 2)) + ">]";
+
+  Fields[6].Column += NonVisibilityBitsUsed ? 13 : 0;
   Fields[6].Str = getSymbolSectionNdx(Obj, Symbol, FirstSym);
+
   Fields[7].Str =
       this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
   for (auto &Entry : Fields)
     printField(Entry);
   OS << "\n";
 }
 
 template <class ELFT>
if (opts::SectionSymbols) {
            unwrapOrError(this->FileName, Obj->symbols(Symtab))) {
         const Elf_Shdr *SymSec = unwrapOrError(
             this->FileName,
             Obj->getSection(&Sym, Symtab, this->dumper()->getShndxTable()));
         if (SymSec == &Sec)
           printSymbol(
               Obj, &Sym,
               unwrapOrError(this->FileName, Obj->symbols(Symtab)).begin(),
-              StrTable, false);
+              StrTable, false, false);
       }
     }
 
     if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
       ArrayRef<uint8_t> Data =
           unwrapOrError(this->FileName, Obj->getSectionContents(&Sec));
       W.printBinaryBlock(
           "SectionData",
           StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()));
     }
   }
 }
 
 template <class ELFT>
 void LLVMStyle<ELFT>::printSymbol(const ELFO *Obj, const Elf_Sym *Symbol,
                                   const Elf_Sym *First, StringRef StrTable,
-                                  bool IsDynamic) {
+                                  bool IsDynamic,
+                                  bool /*NonVisibilityBitsUsed*/) {
   unsigned SectionIndex = 0;
   StringRef SectionName;
   this->dumper()->getSectionNameIndex(Symbol, First, SectionName, SectionIndex);
   std::string FullSymbolName =
       this->dumper()->getFullSymbolName(Symbol, StrTable, IsDynamic);
   unsigned char SymbolType = Symbol->getType();
 
   DictScope D(W, "Symbol");