[Demangle][Rust] Parse path backreferences

[tmiasko]

Summary

Depends on D103364

[dblaikie]

Looks good - probably 3 separate commits, though. (handy if they're separate reviews too in the future - just a bit easier to check tests, etc)

llvm/lib/Demangle/RustDemangle.cpp

510–512

Maybe split this in two - add the two different places for backrefs separately, with separate tests? Oh, three different places (also demangleConst)?

[tmiasko]

Parse path backreferences

[tmiasko]

llvm/lib/Demangle/RustDemangle.cpp

510–512

I split patch into D103847 and D103848, while adding extra tests that exercise recursion limit in each production.

llvm/include/llvm/Demangle/RustDemangle.h

private:
   void demangleDynBounds();
   void demangleDynTrait();
   void demangleBinder();
   void demangleConst();
   void demangleConstInt();
   void demangleConstBool();
   void demangleConstChar();
 
+  template <typename Callable> void demangleBackref(Callable Demangler) {
+    uint64_t Backref = parseBase62Number();
+    if (Error || Backref >= Position) {
+      Error = true;
+      return;
+    }
+
+    if (!Print)
+      return;
+
+    SwapAndRestore<size_t> SavePosition(Position, Position);
+    Position = Backref;
+    Demangler();
+  }
+
   Identifier parseIdentifier();
   uint64_t parseOptionalBase62Number(char Tag);
   uint64_t parseBase62Number();
   uint64_t parseDecimalNumber();
   uint64_t parseHexNumber(StringView &HexDigits);
 
   void print(char C) {
     if (Error || !Print)

llvm/lib/Demangle/RustDemangle.cpp

for (size_t I = 0; !Error && !consumeIf('E'); ++I) {
       demangleGenericArg();
     }
     if (LeaveOpen)
       IsOpen = true;
     else
       print(">");
     break;
   }
+  case 'B':
+    demangleBackref([&] { IsOpen = demanglePath(InType, LeaveOpen); });
+    break;
   default:
-    // FIXME parse remaining productions.
     Error = true;
     break;
   }
 
   return IsOpen;
 }
 
 // <impl-path> = [<disambiguator>] <path>

 //          | "R" [<lifetime>] <type>     // &T
 //          | "Q" [<lifetime>] <type>     // &mut T
 //          | "P" <type>                  // *const T
 //          | "O" <type>                  // *mut T
 //          | "F" <fn-sig>                // fn(...) -> ...
 //          | "D" <dyn-bounds> <lifetime> // dyn Trait<Assoc = X> + Send + 'a
 //          | <backref>                   // backref
 void Demangler::demangleType() {
-  size_t Start = Position;
+  if (Error || RecursionLevel >= MaxRecursionLevel) {
+    Error = true;
+    return;
+  }
+  SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
 
+  size_t Start = Position;
   char C = consume();
   BasicType Type;
   if (parseBasicType(C, Type))
     return printBasicType(Type);
 
   switch (C) {
   case 'A':
     print("[");
if (consumeIf('L')) {
       if (auto Lifetime = parseBase62Number()) {
         print(" + ");
         printLifetime(Lifetime);
       }
     } else {
       Error = true;
     }
     break;
+  case 'B':
+    demangleBackref([&] { demangleType(); });
+    break;
   default:
     Position = Start;
     demanglePath(rust_demangle::InType::Yes);
     break;
   }
 }
 
 // <fn-sig> := [<binder>] ["U"] ["K" <abi>] {<type>} "E" <type>
for (size_t I = 0; I != Binder; ++I) {
     printLifetime(1);
   }
   print("> ");
 }
 
 // <const> = <basic-type> <const-data>
 //         | "p"                          // placeholder
 //         | <backref>
 void Demangler::demangleConst() {
+  if (Error || RecursionLevel >= MaxRecursionLevel) {
+    Error = true;
+    return;
+  }
+  SwapAndRestore<size_t> SaveRecursionLevel(RecursionLevel, RecursionLevel + 1);
+
+  char C = consume();
   BasicType Type;
-  if (parseBasicType(consume(), Type)) {
+  if (parseBasicType(C, Type)) {
     switch (Type) {
     case BasicType::I8:
     case BasicType::I16:
     case BasicType::I32:
     case BasicType::I64:
     case BasicType::I128:
     case BasicType::ISize:
     case BasicType::U8:
case BasicType::Bool:
       break;
     case BasicType::Char:
       demangleConstChar();
       break;
     case BasicType::Placeholder:
       print('_');
       break;
     default:
-      // FIXME demangle backreferences.
       Error = true;
       break;
     }
+  } else if (C == 'B') {
+    demangleBackref([&] { demangleConst(); });
   } else {
     Error = true;
   }
 }
 
 // <const-data> = ["n"] <hex-number>
 void Demangler::demangleConstInt() {
   if (consumeIf('n'))

llvm/test/Demangle/rust.test

 CHECK: char::<'\u{10ffff}'>
        _RIC4charKc10ffff_E
 
 ; Invalid char constants
 
 CHECK: _RIC4charKc1234567_E
        _RIC4charKc1234567_E
 
+; Backreferences
+
+CHECK: backref::<7, 7>
+       _RIC7backrefKi7_KBa_E
+
+CHECK: backref::<(), ()>
+       _RIC7backrefuB9_E
+
+CHECK: backref::<backref::ident>
+       _RIC7backrefNvB0_5identE
+
+; Invalid backreferences
+
+CHECK: _RB_
+       _RB_
+
+CHECK: _RB5_
+       _RB5_
+
+CHECK: _RNvB_1a
+       _RNvB_1a
+
 ; Invalid mangled characters
 
 CHECK: _RNvC2a.1c
        _RNvC2a.1c
 
 CHECK: _RNvC2a$1c
        _RNvC2a$1c