[lldb] Support serial port parity checking

lldb/include/lldb/Host/File.h

private:
   const NativeFile &operator=(const NativeFile &) = delete;
 };
 
 class SerialPort : public NativeFile {
 public:
   struct Options {
     llvm::Optional<unsigned int> BaudRate = llvm::None;
     llvm::Optional<Terminal::Parity> Parity = llvm::None;
+    llvm::Optional<Terminal::ParityCheck> ParityCheck = llvm::None;
     llvm::Optional<unsigned int> StopBits = llvm::None;
   };
 
   // Obtain Options corresponding to the passed URL query string
   // (i.e. the part after '?').
   static llvm::Expected<Options> OptionsFromURL(llvm::StringRef urlqs);
 
   static llvm::Expected<std::unique_ptr<SerialPort>>

lldb/include/lldb/Host/Terminal.h

public:
   enum class Parity {
     No,
     Even,
     Odd,
     Space,
     Mark,
   };
 
+  enum class ParityCheck {
+    // No parity checking
+    No,
+    // Replace erraneous bytes with NUL
+    ReplaceWithNUL,
+    // Ignore erraneous bytes
+    Ignore,
+    // Mark erraneous bytes by prepending them with \xFF\x00; real \xFF
+    // is escaped to \xFF\xFF
+    Mark,
+  };
+
   Terminal(int fd = -1) : m_fd(fd) {}
 
   ~Terminal() = default;
 
   bool IsATerminal() const;
 
   int GetFileDescriptor() const { return m_fd; }
 
public:
   llvm::Error SetRaw();
 
   llvm::Error SetBaudRate(unsigned int baud_rate);
 
   llvm::Error SetStopBits(unsigned int stop_bits);
 
   llvm::Error SetParity(Parity parity);
 
+  llvm::Error SetParityCheck(ParityCheck parity_check);
+
   llvm::Error SetHardwareFlowControl(bool enabled);
 
 protected:
   struct Data;
 
   int m_fd; // This may or may not be a terminal file descriptor
 
   llvm::Expected<Data> GetData();

lldb/source/Host/common/File.cpp

if (x.consume_front("baud=")) {
               .Case("mark", Terminal::Parity::Mark)
               .Case("space", Terminal::Parity::Space)
               .Default(llvm::None);
       if (!serial_options.Parity)
         return llvm::createStringError(
             llvm::inconvertibleErrorCode(),
             "Invalid parity (must be no, even, odd, mark or space): %s",
             x.str().c_str());
+    } else if (x.consume_front("parity-check=")) {
+      serial_options.ParityCheck =
+          llvm::StringSwitch<llvm::Optional<Terminal::ParityCheck>>(x)
+              .Case("no", Terminal::ParityCheck::No)
+              .Case("replace", Terminal::ParityCheck::ReplaceWithNUL)
+              .Case("ignore", Terminal::ParityCheck::Ignore)
+              // "mark" mode is not currently supported as it requires special
+              // input processing
+              // .Case("mark", Terminal::ParityCheck::Mark)
+              .Default(llvm::None);
+      if (!serial_options.ParityCheck)
+        return llvm::createStringError(
+            llvm::inconvertibleErrorCode(),
+            "Invalid parity-check (must be no, replace, ignore or mark): %s",
+            x.str().c_str());
     } else if (x.consume_front("stop-bits=")) {
       unsigned int stop_bits;
       if (!llvm::to_integer(x, stop_bits, 10) ||
           (stop_bits != 1 && stop_bits != 2))
         return llvm::createStringError(
             llvm::inconvertibleErrorCode(),
             "Invalid stop bit number (must be 1 or 2): %s", x.str().c_str());
       serial_options.StopBits = stop_bits;
if (serial_options.BaudRate) {
     if (llvm::Error error =
             term.SetBaudRate(serial_options.BaudRate.getValue()))
       return std::move(error);
   }
   if (serial_options.Parity) {
     if (llvm::Error error = term.SetParity(serial_options.Parity.getValue()))
       return std::move(error);
   }
+  if (serial_options.ParityCheck) {
+    if (llvm::Error error =
+            term.SetParityCheck(serial_options.ParityCheck.getValue()))
+      return std::move(error);
+  }
   if (serial_options.StopBits) {
     if (llvm::Error error =
             term.SetStopBits(serial_options.StopBits.getValue()))
       return std::move(error);
   }
 
   return std::move(out);
 }

lldb/source/Host/common/Terminal.cpp

#else
           "space/mark parity is not supported by the platform");
 #endif
     }
   }
   return SetData(data.get());
 #endif // #if LLDB_ENABLE_TERMIOS
 }
 
+llvm::Error Terminal::SetParityCheck(Terminal::ParityCheck parity_check) {
+  llvm::Expected<Data> data = GetData();
+  if (!data)
+    return data.takeError();
+
+#if LLDB_ENABLE_TERMIOS
+  struct termios &fd_termios = data->m_termios;
+  fd_termios.c_iflag &= ~(IGNPAR | PARMRK | INPCK);
+
+  if (parity_check != ParityCheck::No) {
+    fd_termios.c_iflag |= INPCK;
+    if (parity_check == ParityCheck::Ignore)
+      fd_termios.c_iflag |= IGNPAR;
+    else if (parity_check == ParityCheck::Mark)
+      fd_termios.c_iflag |= PARMRK;
+  }
+  return SetData(data.get());
+#endif // #if LLDB_ENABLE_TERMIOS
+}
+
 llvm::Error Terminal::SetHardwareFlowControl(bool enabled) {
   llvm::Expected<Data> data = GetData();
   if (!data)
     return data.takeError();
 
 #if LLDB_ENABLE_TERMIOS
 #if defined(CRTSCTS)
   struct termios &fd_termios = data->m_termios;

lldb/unittests/Host/posix/TerminalTest.cpp

ASSERT_THAT_ERROR(m_term.SetParity(Terminal::Parity::Space),
                         "space/mark parity is not supported by the platform")));
   ASSERT_THAT_ERROR(m_term.SetParity(Terminal::Parity::Mark),
                     llvm::Failed<llvm::ErrorInfoBase>(testing::Property(
                         &llvm::ErrorInfoBase::message,
                         "space/mark parity is not supported by the platform")));
 #endif
 }
 
+TEST_F(TerminalTest, SetParityCheck) {
+  struct termios terminfo;
+
+  ASSERT_THAT_ERROR(m_term.SetParityCheck(Terminal::ParityCheck::No),
+                    llvm::Succeeded());
+  ASSERT_EQ(tcgetattr(m_fd, &terminfo), 0);
+  EXPECT_EQ(terminfo.c_iflag & (IGNPAR | PARMRK | INPCK), 0U);
+
+  ASSERT_THAT_ERROR(
+      m_term.SetParityCheck(Terminal::ParityCheck::ReplaceWithNUL),
+      llvm::Succeeded());
+  ASSERT_EQ(tcgetattr(m_fd, &terminfo), 0);
+  EXPECT_NE(terminfo.c_iflag & INPCK, 0U);
+  EXPECT_EQ(terminfo.c_iflag & (IGNPAR | PARMRK), 0U);
+
+  ASSERT_THAT_ERROR(m_term.SetParityCheck(Terminal::ParityCheck::Ignore),
+                    llvm::Succeeded());
+  ASSERT_EQ(tcgetattr(m_fd, &terminfo), 0);
+  EXPECT_NE(terminfo.c_iflag & IGNPAR, 0U);
+  EXPECT_EQ(terminfo.c_iflag & PARMRK, 0U);
+  EXPECT_NE(terminfo.c_iflag & INPCK, 0U);
+
+  ASSERT_THAT_ERROR(m_term.SetParityCheck(Terminal::ParityCheck::Mark),
+                    llvm::Succeeded());
+  ASSERT_EQ(tcgetattr(m_fd, &terminfo), 0);
+  EXPECT_EQ(terminfo.c_iflag & IGNPAR, 0U);
+  EXPECT_NE(terminfo.c_iflag & PARMRK, 0U);
+  EXPECT_NE(terminfo.c_iflag & INPCK, 0U);
+}
+
 TEST_F(TerminalTest, SetHardwareFlowControl) {
 #if defined(CRTSCTS)
   struct termios terminfo;
 
   ASSERT_THAT_ERROR(m_term.SetHardwareFlowControl(true), llvm::Succeeded());
   ASSERT_EQ(tcgetattr(m_fd, &terminfo), 0);
   EXPECT_NE(terminfo.c_cflag & CRTSCTS, 0U);