[Support/GlobPattern] - Do not crash when pattern has characters with int value < 0.

[grimar]

Summary

Found it during work on LLD, it would crash on following
linker script:

SECTIONS { .foo : { *("*®") } }

That happens because ® has int value -82. And chars are used as
array index in code, and are signed by default.

[grimar]

• Use character literals in testcase.

[grimar]

• Uploaded correct diff. Sorry for noise.

[ruiu]

lib/Support/GlobPattern.cpp

39 ↗

(On Diff #108285)

Instead of casting to uint8_t, cast to unsigned.

[grimar]

lib/Support/GlobPattern.cpp

39 ↗

(On Diff #108285)

That will not work:

(unsigned)0xFF == 0xFFFFFFFF == 4294967295
(uint8_t)0xFF == 255

[grimar]

lib/Support/GlobPattern.cpp

39 ↗

(On Diff #108285)

I was mean

(unsigned)(char)0xFF == 4294967295

[ruiu]

lib/Support/GlobPattern.cpp

36 ↗

(On Diff #108285)

Add these line before this line to remove all these casts.

uint8_t Start = S[0];
uint8_t End = S[2];

[grimar]

• Addressed review comments.

[ruiu]

LGTM

lib/Support/GlobPattern.cpp

38 ↗

(On Diff #108602)

Add a blank line.

llvm/trunk/lib/Support/GlobPattern.cpp

 static Expected<BitVector> expand(StringRef S, StringRef Original) {
   BitVector BV(256, false);
 
   // Expand X-Y.
   for (;;) {
     if (S.size() < 3)
       break;
 
+    uint8_t Start = S[0];
+    uint8_t End = S[2];
+
     // If it doesn't start with something like X-Y,
     // consume the first character and proceed.
     if (S[1] != '-') {
-      BV[S[0]] = true;
+      BV[Start] = true;
       S = S.substr(1);
       continue;
     }
 
     // It must be in the form of X-Y.
     // Validate it and then interpret the range.
-    if (S[0] > S[2])
+    if (Start > End)
       return make_error<StringError>("invalid glob pattern: " + Original,
                                      errc::invalid_argument);
 
-    for (int C = S[0]; C <= S[2]; ++C)
-      BV[C] = true;
+    for (int C = Start; C <= End; ++C)
+      BV[(uint8_t)C] = true;
     S = S.substr(3);
   }
 
   for (char C : S)
-    BV[C] = true;
+    BV[(uint8_t)C] = true;
   return BV;
 }
 
 // This is a scanner for the glob pattern.
 // A glob pattern token is one of "*", "?", "[<chars>]", "[^<chars>]"
 // (which is a negative form of "[<chars>]"), or a non-meta character.
 // This function returns the first token in S.
 static Expected<BitVector> scan(StringRef &S, StringRef Original) {
if (Chars.startswith("^")) {
       if (!BV)
         return BV.takeError();
       return BV->flip();
     }
     return expand(Chars, Original);
   }
   default:
     BitVector BV(256, false);
-    BV[S[0]] = true;
+    BV[(uint8_t)S[0]] = true;
     S = S.substr(1);
     return BV;
   }
 }
 
 Expected<GlobPattern> GlobPattern::create(StringRef S) {
   GlobPattern Pat;
 
if (Pats[0].size() == 0) {
         return true;
       for (size_t I = 0, E = S.size(); I < E; ++I)
         if (matchOne(Pats, S.substr(I)))
           return true;
       return false;
     }
 
     // If Pats[0] is not '*', it must consume one character.
-    if (S.empty() || !Pats[0][S[0]])
+    if (S.empty() || !Pats[0][(uint8_t)S[0]])
       return false;
     Pats = Pats.slice(1);
     S = S.substr(1);
   }
 }

llvm/trunk/unittests/Support/GlobPatternTest.cpp

TEST_F(GlobPatternTest, Basics) {
   EXPECT_FALSE(Pat5->match(""));
 }
 
 TEST_F(GlobPatternTest, Invalid) {
   Expected<GlobPattern> Pat1 = GlobPattern::create("[");
   EXPECT_FALSE((bool)Pat1);
   handleAllErrors(Pat1.takeError(), [&](ErrorInfoBase &EIB) {});
 }
+
+TEST_F(GlobPatternTest, ExtSym) {
+  Expected<GlobPattern> Pat1 = GlobPattern::create("a*\xFF");
+  EXPECT_TRUE((bool)Pat1);
+  EXPECT_TRUE(Pat1->match("axxx\xFF"));
+  Expected<GlobPattern> Pat2 = GlobPattern::create("[\xFF-\xFF]");
+  EXPECT_TRUE((bool)Pat2);
+  EXPECT_TRUE(Pat2->match("\xFF"));
+}
 }