Add support for #elifdef and #elifndef

[aaron.ballman]

Summary

WG14 adopted N2645 and WG21 EWG has accepted P2334 in principle (still subject to full EWG vote + CWG review + plenary vote), which add support for #elifdef as shorthand for #elif defined and #elifndef as shorthand for #elif !defined. This patch adds support for the new preprocessor directives.

In this version of the patch, I am supporting the feature in all C and C++ modes. This seems like more useful functionality than diagnosing an unknown preprocessor directive in older language modes, and is a conforming extension in those modes anyway as use of an unknown directive is undefined behavior. However, it was not clear to me whether we want to issue a pedantic warning for this or not or whether we felt it was important to document this behavior explicitly.

[erichkeane]

clang/lib/Format/UnwrappedLineParser.cpp

754

Just looking through this, so forgive me if I there is something I don't understand... Why is this not doing something like parsePPIf(/*IfDef=*/true) like above?

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

924

Hrmph, not sure I understand this part either.

clang/lib/Lex/PPDirectives.cpp

651

Can you just pass 'Directive' here?

3277

Oh? What is the 'right' error here?

3286

Same here:)?

[aaron.ballman]

clang/lib/Format/UnwrappedLineParser.cpp

754

I had originally considered that, but it turns out that parsePPElif() just calls parsePPElse() and doesn't care about the condition whatsoever.

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

924

I'm not 100% certain myself.

clang/lib/Lex/PPDirectives.cpp

651

I think I'd have to pass Directive.str().c_str() to ensure I get a null terminated string to pass (CheckEndOfDirective() takes a const char *), and that involves an allocation, so I think this form may be better? I don't have a strong opinion though.

3277

Good catch, I'll correct this.

3286

Same here.

[erichkeane]

clang/lib/Lex/PPDirectives.cpp

651

Ugh, gross. Didn't realize it took a const char*. This is the better of the two, ugly, but at least non-allocating.

[aaron.ballman]

Updated based on review feedback.

[erichkeane]

I have one 'nit of preference', otherwise I think I don't want to +1 this without giving people a few days to take a look. Based on my looks through the surrounding code, this _LOOKS_ right enough as far as I can tell, but I still want to give others a few days.

clang/lib/Lex/PPDirectives.cpp

629

As you know, I'm a giant fan of using enums for cases like this, so it would be my preference to have something like that. Sadly it looks like it would have to be file-level here instead of functionlevel like is most convenient.

clang/test/Preprocessor/elifdef.c

72

Are there any tests you could do to make sure this 'works'? That is:

#define BAR
// expected-error@+3 {{"AN ERROR!"}}
#ifdef FOO
#elifdef BAR
#error "AN ERROR!"
#endif

AND

// no error expected here!
#ifdef FOO
#elifndef BAR
#error "AN ERROR!"
#endif

And perhaps...

// expected-error@+4 {{"AN ERROR AGAIN!"}}
#ifdef FOO
#elifdef BAR
#else
#error "AN ERROR AGAIN!"
#endif

[aaron.ballman]

Updated based on review feedback.

clang/lib/Lex/PPDirectives.cpp

629

Given that all the diagnostics are in the same file, I suppose that's fine.

clang/test/Preprocessor/elifdef.c

72

I think the first test is what's on lines 63-69, the third is what's on lines 43-47, but I'll add the second test because I don't think that's covered yet. Thanks for the suggestion!

[dexonsmith]

I reviewed the source minimizer sections, and the code looks correct.

It'd probably be good to have unit tests in clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp for the incremental changes.

• Do the new constructs stick around in the minimized source?
• Do they get paired correctly for the ppranges stuff? (I think you can modify or create new versions of SkippedPPRangesBasic and SkippedPPRangesNested.)

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

909

Please add the two new cases to this comment as well.

924

This part LGTM.

[aaron.ballman]

Updates based on review feedback.

Added tests for the source minimizer changes, thanks @dexonsmith!

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

909

Good catch, thanks!

[mibintc]

Wow thanks for doing this! I worked on it a couple days a while ago but I abandoned the effort and went back to my day job. It seems like preprocessing ought to be something like a "state machine" but I couldn't figure out the mechanism. Would it make sense to add some kind of high level description of the components, now that you've gone to the [presumably massive] effort of understanding it? Just a couple small comments above.

clang/lib/Lex/PPDirectives.cpp

1059

please put a comment on 'false'

1063

please put a comment on true

[aaron.ballman]

Updating based on review comments.

[aaron.ballman]

In D101192#2716596, @mibintc wrote:

Wow thanks for doing this! I worked on it a couple days a while ago but I abandoned the effort and went back to my day job.

Happy to help!

It seems like preprocessing ought to be something like a "state machine" but I couldn't figure out the mechanism. Would it make sense to add some kind of high level description of the components, now that you've gone to the [presumably massive] effort of understanding it? Just a couple small comments above.

Adding some developer documentation about the preprocessor may not be a bad idea in general, but I think that's orthogonal to this patch. We do have a place to add those kind of docs and it looks like the preprocessor is largely not mentioned: https://clang.llvm.org/docs/InternalsManual.html#the-lexer-and-preprocessor-library. However, I'd prefer not to sign up to write those docs at this time.

[aaron.ballman]

Ping

[rsmith]

clang/lib/Lex/PPDirectives.cpp

3254–3265

Hm, is the strict checking here appropriate? I'd expect skipping to start as soon as we hit the #elifdef directive, so the restriction on the form of the directive should be relaxed and we should just skip to the end of the line. ("When in a group that is skipped (15.2), the directive syntax is relaxed to allow any sequence of preprocessing tokens to occur between the directive name and the following new-line character."). For example, given:

#if 1
#elif
#endif

... we don't diagnose, even though the #elif line doesn't match the usual form for the directive (a constant-expression would require at least one token between elif and new-line), and I'd expect #elifdef to behave the same way.

With this fixed, the handling of #elif, #elifdef, and #elifndef (when not skipping) should be identical other than which callback is invoked; can the implementations be combined?

3291

This doesn't seem right to me: the macro's existence or non-existence does not affect preprocessing, so the macro was not used. But I assume this and the references to MD below will also be removed once this function stops parsing a macro name.

[aaron.ballman]

Updated based on review feedback.

[aaron.ballman]

clang/lib/Lex/PPDirectives.cpp

3254–3265

Good point! I think this means we'd need a second set of callbacks though -- we want the macro information when we process a #elifdef or a #elifndef that is taken (same as with #ifdef), so we'd need the interface that takes a MacroDefinition, but if we skip reading that because we're skipping the entire conditional block, we'd need a callback that takes the condition range.

I went that route with the updated patch. LMK if that works for you.

[aaron.ballman]

Now, with ever-so-slightly better formatting (the rest of the formatting issues are either matching existing style or a fight between my clang-format and CI's clang-format).

[aaron.ballman]

Ping

[mibintc]

let 'er rip

[aaron.ballman]

In D101192#2763498, @mibintc wrote:

let 'er rip

Thanks @mibintc!

@rsmith -- I'll land this sometime later this week unless I hear further comments from you. If I land it and you still have feedback, I can address it post commit.

[aaron.ballman]

I've landed in 8edd3464afbff65d7d5945b3a8b20009d6ff5deb

[bjope]

clang/lib/Lex/PPDirectives.cpp

594

Hi @aaron.ballman

This change is missing from https://reviews.llvm.org/rG8edd3464afbff65d7d5945b3a8b20009d6ff5deb , while you instead got it when doing the pp_err_else_after_else diagnostic a couple of lines above this.

It causes asserts (in DIagnostic::getArgKind) for me in test cases verifying the "elif after else" scenario using a test case basically doing

#if 1
#else
#elif
#endif

So maybe such a test case should be added as well?

But it seems like the patch you committed doesn't match with the reviewed patch. So maybe you can look into this and fix it?
(let me know if you need some additional help)

[aaron.ballman]

clang/lib/Lex/PPDirectives.cpp

594

Great catch and thank you for the test case! It seems that when I applied the patch, it misapplied, but not in a way that caused a test failure. I have no idea how that happened, but I assume I screwed up something with git somewhere along the way and caused the failure.

I've pushed baa2b8d08502acfa91a8dfd699d25f7b4e25edbb to fix it. Thanks!

[bjope]

clang/lib/Lex/PPDirectives.cpp

594

Big thanks for the quick fix! While I managed to track down this problem I didn't have time to properly fix it right away. Now I'll have one thing less to worry about tomorrow :-)

[aaron.ballman]

clang/lib/Lex/PPDirectives.cpp

594

Happy to fix my own messes!

[rsmith]

In this version of the patch, I am supporting the feature in all C and C++ modes. This seems like more useful functionality than diagnosing an unknown preprocessor directive in older language modes, and is a conforming extension in those modes anyway as use of an unknown directive is undefined behavior.

Is this really true? I think:

#define X
#if 0
#elifdef X
#error
#endif

... is a valid translation unit in C++ and is strictly conforming in C11 and earlier; any conditionally-supported-directive (using the C++ terminology) within a group is ignored when skipping that group.

That said... applying this to all language modes does seem like the right choice, even though it may be technically non-conforming.

clang/include/clang/Basic/DiagnosticLexKinds.td

 def err_pp_duplicate_name_in_arg_list : Error<
   "duplicate macro parameter name %0">;
 def err_pp_stringize_not_parameter : Error<
   "'%select{#|#@}0' is not followed by a macro parameter">;
 def err_pp_malformed_ident : Error<"invalid #ident directive">;
 def err_pp_unterminated_conditional : Error<
   "unterminated conditional directive">;
 def pp_err_else_after_else : Error<"#else after #else">;
-def pp_err_elif_after_else : Error<"#elif after #else">;
+def pp_err_elif_after_else : Error<
+  "%select{#elif|#elifdef|#elifndef}0 after #else">;
 def pp_err_else_without_if : Error<"#else without #if">;
-def pp_err_elif_without_if : Error<"#elif without #if">;
+def pp_err_elif_without_if : Error<
+  "%select{#elif|#elifdef|#elifndef}0 without #if">;
 def err_pp_endif_without_if : Error<"#endif without #if">;
 def err_pp_expected_value_in_expr : Error<"expected value in expression">;
 def err_pp_expected_rparen : Error<"expected ')' in preprocessor expression">;
 def err_pp_expected_eol : Error<
   "expected end of line in preprocessor expression">;
 def err_pp_expected_after : Error<"missing %1 after %0">;
 def err_pp_nested_paren : Error<"nested parentheses not permitted in %0">;
 def err_pp_colon_without_question : Error<"':' without preceding '?'">;

clang/include/clang/Basic/TokenKinds.def

 // manually updated if something is added here.
 PPKEYWORD(not_keyword)
 
 // C99 6.10.1 - Conditional Inclusion.
 PPKEYWORD(if)
 PPKEYWORD(ifdef)
 PPKEYWORD(ifndef)
 PPKEYWORD(elif)
+PPKEYWORD(elifdef)
+PPKEYWORD(elifndef)
 PPKEYWORD(else)
 PPKEYWORD(endif)
 PPKEYWORD(defined)
 
 // C99 6.10.2 - Source File Inclusion.
 PPKEYWORD(include)
 PPKEYWORD(__include_macros)
 

clang/include/clang/Lex/DependencyDirectivesSourceMinimizer.h

enum TokenKind {
   pp_import,
   pp_pragma_import,
   pp_pragma_once,
   pp_include_next,
   pp_if,
   pp_ifdef,
   pp_ifndef,
   pp_elif,
+  pp_elifdef,
+  pp_elifndef,
   pp_else,
   pp_endif,
   decl_at_import,
   cxx_export_decl,
   cxx_module_decl,
   cxx_import_decl,
   pp_eof,
 };

clang/include/clang/Lex/PPCallbacks.h

public:
   /// Hook called whenever an \#ifdef is seen.
   /// \param Loc the source location of the directive.
   /// \param MacroNameTok Information on the token being tested.
   /// \param MD The MacroDefinition if the name was a macro, null otherwise.
   virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
                      const MacroDefinition &MD) {
   }
 
+  /// Hook called whenever an \#elifdef is seen.
+  /// \param Loc the source location of the directive.
+  /// \param MacroNameTok Information on the token being tested.
+  /// \param MD The MacroDefinition if the name was a macro, null otherwise.
+  virtual void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+                       const MacroDefinition &MD) {
+  }
+
   /// Hook called whenever an \#ifndef is seen.
   /// \param Loc the source location of the directive.
   /// \param MacroNameTok Information on the token being tested.
   /// \param MD The MacroDefiniton if the name was a macro, null otherwise.
   virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
                       const MacroDefinition &MD) {
   }
 
+  /// Hook called whenever an \#elifndef is seen.
+  /// \param Loc the source location of the directive.
+  /// \param MacroNameTok Information on the token being tested.
+  /// \param MD The MacroDefinition if the name was a macro, null otherwise.
+  virtual void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+                        const MacroDefinition &MD) {
+  }
+
   /// Hook called whenever an \#else is seen.
   /// \param Loc the source location of the directive.
   /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
   virtual void Else(SourceLocation Loc, SourceLocation IfLoc) {
   }
 
   /// Hook called whenever an \#endif is seen.
   /// \param Loc the source location of the directive.
public:
 
   /// Hook called whenever an \#ifdef is seen.
   void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
              const MacroDefinition &MD) override {
     First->Ifdef(Loc, MacroNameTok, MD);
     Second->Ifdef(Loc, MacroNameTok, MD);
   }
 
+  /// Hook called whenever an \#elifdef is seen.
+  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+               const MacroDefinition &MD) override {
+    First->Elifdef(Loc, MacroNameTok, MD);
+    Second->Elifdef(Loc, MacroNameTok, MD);
+  }
+
   /// Hook called whenever an \#ifndef is seen.
   void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
               const MacroDefinition &MD) override {
     First->Ifndef(Loc, MacroNameTok, MD);
     Second->Ifndef(Loc, MacroNameTok, MD);
   }
 
+  /// Hook called whenever an \#elifndef is seen.
+  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+                const MacroDefinition &MD) override {
+    First->Elifndef(Loc, MacroNameTok, MD);
+    Second->Elifndef(Loc, MacroNameTok, MD);
+  }
+
   /// Hook called whenever an \#else is seen.
   void Else(SourceLocation Loc, SourceLocation IfLoc) override {
     First->Else(Loc, IfLoc);
     Second->Else(Loc, IfLoc);
   }
 
   /// Hook called whenever an \#endif is seen.
   void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
     First->Endif(Loc, IfLoc);
     Second->Endif(Loc, IfLoc);
   }
 };
 
 }  // end namespace clang
 
 #endif

clang/include/clang/Lex/PPConditionalDirectiveRecord.h

private:
   void If(SourceLocation Loc, SourceRange ConditionRange,
           ConditionValueKind ConditionValue) override;
   void Elif(SourceLocation Loc, SourceRange ConditionRange,
             ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
   void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
              const MacroDefinition &MD) override;
   void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
               const MacroDefinition &MD) override;
+  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+               const MacroDefinition &MD) override;
+  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+                const MacroDefinition &MD) override;
   void Else(SourceLocation Loc, SourceLocation IfLoc) override;
   void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
 };
 
 } // end namespace clang
 
 #endif // LLVM_CLANG_LEX_PPCONDITIONALDIRECTIVERECORD_H

clang/include/clang/Lex/PreprocessingRecord.h

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
                             CharSourceRange FilenameRange,
                             const FileEntry *File, StringRef SearchPath,
                             StringRef RelativePath, const Module *Imported,
                             SrcMgr::CharacteristicKind FileType) override;
     void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
                const MacroDefinition &MD) override;
     void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
                 const MacroDefinition &MD) override;
+    void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+                 const MacroDefinition &MD) override;
+    void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+                  const MacroDefinition &MD) override;
 
     /// Hook called whenever the 'defined' operator is seen.
     void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
                  SourceRange Range) override;
 
     void SourceRangeSkipped(SourceRange Range,
                             SourceLocation EndifLoc) override;
 

clang/include/clang/Lex/Preprocessor.h

private:
   // Conditional Inclusion.
   void HandleIfdefDirective(Token &Result, const Token &HashToken,
                             bool isIfndef, bool ReadAnyTokensBeforeDirective);
   void HandleIfDirective(Token &IfToken, const Token &HashToken,
                          bool ReadAnyTokensBeforeDirective);
   void HandleEndifDirective(Token &EndifToken);
   void HandleElseDirective(Token &Result, const Token &HashToken);
   void HandleElifDirective(Token &ElifToken, const Token &HashToken);
+  void HandleElifdefDirective(Token &Result, const Token &HashToken,
+                              bool isElifndef,
+                              bool ReadAnyTokensBeforeDirective);
 
   // Pragmas.
   void HandlePragmaDirective(PragmaIntroducer Introducer);
 
 public:
   void HandlePragmaOnce(Token &OnceTok);
   void HandlePragmaMark();
   void HandlePragmaPoison();

clang/lib/Basic/IdentifierTable.cpp

#define CASE(LEN, FIRST, THIRD, NAME) \
 
   CASE( 6, 'a', 's', assert);
   CASE( 6, 'd', 'f', define);
   CASE( 6, 'i', 'n', ifndef);
   CASE( 6, 'i', 'p', import);
   CASE( 6, 'p', 'a', pragma);
 
   CASE( 7, 'd', 'f', defined);
+  CASE( 7, 'e', 'i', elifdef);
   CASE( 7, 'i', 'c', include);
   CASE( 7, 'w', 'r', warning);
 
+  CASE( 8, 'e', 'i', elifndef);
   CASE( 8, 'u', 'a', unassert);
   CASE(12, 'i', 'c', include_next);
 
   CASE(14, '_', 'p', __public_macro);
 
   CASE(15, '_', 'p', __private_macro);
 
   CASE(16, '_', 'i', __include_macros);

clang/lib/Format/UnwrappedLineParser.cpp

case tok::pp_if:
     break;
   case tok::pp_ifdef:
   case tok::pp_ifndef:
     parsePPIf(/*IfDef=*/true);
     break;
   case tok::pp_else:
     parsePPElse();
     break;
+  case tok::pp_elifdef:
+  case tok::pp_elifndef:
   case tok::pp_elif:
     parsePPElIf();
     break;
   case tok::pp_endif:
     parsePPEndIf();
     break;
   default:
     parsePPUnknown();

clang/lib/Index/IndexingAction.cpp

public:
   void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
               const MacroDefinition &MD) override {
     if (!MD.getMacroInfo()) // Ignore nonexistent macro.
       return;
     IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
                                    MacroNameTok.getLocation(),
                                    *MD.getMacroInfo());
   }
+
+  void Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+               const MacroDefinition &MD) override {
+    if (!MD.getMacroInfo()) // Ignore non-existent macro.
+      return;
+    IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
+                                   MacroNameTok.getLocation(),
+                                   *MD.getMacroInfo());
+  }
+  void Elifndef(SourceLocation Loc, const Token &MacroNameTok,
+                const MacroDefinition &MD) override {
+    if (!MD.getMacroInfo()) // Ignore non-existent macro.
+      return;
+    IndexCtx->handleMacroReference(*MacroNameTok.getIdentifierInfo(),
+                                   MacroNameTok.getLocation(),
+                                   *MD.getMacroInfo());
+  }
 };
 
 class IndexASTConsumer final : public ASTConsumer {
   std::shared_ptr<IndexDataConsumer> DataConsumer;
   std::shared_ptr<IndexingContext> IndexCtx;
   std::shared_ptr<Preprocessor> PP;
   std::function<bool(const Decl *)> ShouldSkipFunctionBody;
 

clang/lib/Lex/DependencyDirectivesSourceMinimizer.cpp

auto Kind = llvm::StringSwitch<TokenKind>(Id.Name)
                   .Case("define", pp_define)
                   .Case("undef", pp_undef)
                   .Case("import", pp_import)
                   .Case("include_next", pp_include_next)
                   .Case("if", pp_if)
                   .Case("ifdef", pp_ifdef)
                   .Case("ifndef", pp_ifndef)
                   .Case("elif", pp_elif)
+                  .Case("elifdef", pp_elifdef)
+                  .Case("elifndef", pp_elifndef)
                   .Case("else", pp_else)
                   .Case("endif", pp_endif)
                   .Case("pragma", pp_pragma_import)
                   .Default(pp_none);
   if (Kind == pp_none) {
     skipDirective(Id.Name, First, End);
     return false;
   }
bool Minimizer::minimize() {
   return Error;
 }
 
 bool clang::minimize_source_to_dependency_directives::computeSkippedRanges(
     ArrayRef<Token> Input, llvm::SmallVectorImpl<SkippedRange> &Range) {
   struct Directive {
     enum DirectiveKind {
       If,  // if/ifdef/ifndef
-      Else // elif,else
+      Else // elif/elifdef/elifndef, else
     };
     int Offset;
     DirectiveKind Kind;
   };
   llvm::SmallVector<Directive, 32> Offsets;
   for (const Token &T : Input) {
     switch (T.K) {
     case pp_if:
     case pp_ifdef:
     case pp_ifndef:
       Offsets.push_back({T.Offset, Directive::If});
       break;
 
     case pp_elif:
+    case pp_elifdef:
+    case pp_elifndef:
     case pp_else: {
       if (Offsets.empty())
         return true;
       int PreviousOffset = Offsets.back().Offset;
       Range.push_back({PreviousOffset, T.Offset - PreviousOffset});
       Offsets.push_back({T.Offset, Directive::Else});
       break;
     }

clang/lib/Lex/Lexer.cpp

if (TheTok.isAtStartOfLine() && TheTok.getKind() == tok::hash) {
       ActiveCommentLoc = SourceLocation();
 
       // Figure out which directive this is. Since we're lexing raw tokens,
       // we don't have an identifier table available. Instead, just look at
       // the raw identifier to recognize and categorize preprocessor directives.
       TheLexer.LexFromRawLexer(TheTok);
       if (TheTok.getKind() == tok::raw_identifier && !TheTok.needsCleaning()) {
         StringRef Keyword = TheTok.getRawIdentifier();
         PreambleDirectiveKind PDK
           = llvm::StringSwitch<PreambleDirectiveKind>(Keyword)
               .Case("include", PDK_Skipped)
               .Case("__include_macros", PDK_Skipped)
               .Case("define", PDK_Skipped)
               .Case("undef", PDK_Skipped)
               .Case("line", PDK_Skipped)
               .Case("error", PDK_Skipped)
               .Case("pragma", PDK_Skipped)
               .Case("import", PDK_Skipped)
               .Case("include_next", PDK_Skipped)
               .Case("warning", PDK_Skipped)
               .Case("ident", PDK_Skipped)
               .Case("sccs", PDK_Skipped)
               .Case("assert", PDK_Skipped)
               .Case("unassert", PDK_Skipped)
               .Case("if", PDK_Skipped)
               .Case("ifdef", PDK_Skipped)
               .Case("ifndef", PDK_Skipped)
               .Case("elif", PDK_Skipped)
+              .Case("elifdef", PDK_Skipped)
+              .Case("elifndef", PDK_Skipped)
               .Case("else", PDK_Skipped)
               .Case("endif", PDK_Skipped)
               .Default(PDK_Unknown);
 
         switch (PDK) {
         case PDK_Skipped:
           continue;
 

clang/lib/Lex/PPConditionalDirectiveRecord.cpp

 void PPConditionalDirectiveRecord::Elif(SourceLocation Loc,
                                         SourceRange ConditionRange,
                                         ConditionValueKind ConditionValue,
                                         SourceLocation IfLoc) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
 
+void PPConditionalDirectiveRecord::Elifdef(SourceLocation Loc,
+                                           const Token &MacroNameTok,
+                                           const MacroDefinition &MD) {
+  addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
+  CondDirectiveStack.back() = Loc;
+}
+
+void PPConditionalDirectiveRecord::Elifndef(SourceLocation Loc,
+                                            const Token &MacroNameTok,
+                                            const MacroDefinition &MD) {
+  addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
+  CondDirectiveStack.back() = Loc;
+}
+
 void PPConditionalDirectiveRecord::Else(SourceLocation Loc,
                                         SourceLocation IfLoc) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   CondDirectiveStack.back() = Loc;
 }
 
 void PPConditionalDirectiveRecord::Endif(SourceLocation Loc,
                                          SourceLocation IfLoc) {
   addCondDirectiveLoc(CondDirectiveLoc(Loc, CondDirectiveStack.back()));
   assert(!CondDirectiveStack.empty());
   CondDirectiveStack.pop_back();
 }
 
 size_t PPConditionalDirectiveRecord::getTotalMemory() const {
   return llvm::capacity_in_bytes(CondDirectiveLocs);
 }

clang/lib/Lex/PPDirectives.cpp

 
 /// Enumerates possible cases of #define/#undef a reserved identifier.
 enum MacroDiag {
   MD_NoWarn,        //> Not a reserved identifier
   MD_KeywordDef,    //> Macro hides keyword, enabled by default
   MD_ReservedMacro  //> #define of #undef reserved id, disabled by default
 };
 
+/// Enumerates possible %select values for the pp_err_elif_after_else and
+/// pp_err_elif_without_if diagnostics.
+enum PPElifDiag {
+  PED_Elif,
+  PED_Elifdef,
+  PED_Elifndef
+};
+
 /// Checks if the specified identifier is reserved in the specified
 /// language.
 /// This function does not check if the identifier is a keyword.
 static bool isReservedId(StringRef Text, const LangOptions &Lang) {
   // C++ [macro.names], C11 7.1.3:
   // All identifiers that begin with an underscore and either an uppercase
   // letter or another underscore are always reserved for any use.
   if (Text.size() >= 2 && Text[0] == '_' &&
if (Directive.startswith("if")) {
           break;
         } else {
           DiscardUntilEndOfDirective();  // C99 6.10p4.
         }
       } else if (Sub == "lif") {  // "elif".
         PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
 
         // If this is a #elif with a #else before it, report the error.
-        if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
+        if (CondInfo.FoundElse)
+          Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif;
 
         // If this is in a skipping block or if we're already handled this #if
         // block, don't bother parsing the condition.
         if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
           DiscardUntilEndOfDirective();
         } else {
           // Restore the value of LexingRawMode so that identifiers are
           // looked up, etc, inside the #elif expression.
if (Directive.startswith("if")) {
                 CondInfo.IfLoc);
           }
           // If this condition is true, enter it!
           if (CondValue) {
             CondInfo.FoundNonSkip = true;
             break;
           }
         }
+      } else if (Sub == "lifdef" ||  // "elifdef"
+                 Sub == "lifndef") { // "elifndef"
+        bool IsElifDef = Sub == "lifdef";
+        PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
+        Token DirectiveToken = Tok;
+
+        // If this is a #elif with a #else before it, report the error.
+        if (CondInfo.FoundElse)
+          Diag(Tok, diag::pp_err_elif_after_else)
+              << (IsElifDef ? PED_Elifdef : PED_Elifndef);
+
+        // If this is in a skipping block or if we're already handled this #if
+        // block, don't bother parsing the condition.
+        if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
+          DiscardUntilEndOfDirective();
+        } else {
+          // Restore the value of LexingRawMode so that identifiers are
+          // looked up, etc, inside the #elif[n]def expression.
+          assert(CurPPLexer->LexingRawMode && "We have to be skipping here!");
+          CurPPLexer->LexingRawMode = false;
+          Token MacroNameTok;
+          ReadMacroName(MacroNameTok);
+          CurPPLexer->LexingRawMode = true;
+
+          // If the macro name token is tok::eod, there was an error that was
+          // already reported.
+          if (MacroNameTok.is(tok::eod)) {
+            // Skip code until we get to #endif.  This helps with recovery by
+            // not emitting an error when the #endif is reached.
+            continue;
+          }
+
+          CheckEndOfDirective(IsElifDef ? "elifdef" : "elifndef");
+
+          IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
+          auto MD = getMacroDefinition(MII);
+          MacroInfo *MI = MD.getMacroInfo();
+
+          if (Callbacks) {
+            if (IsElifDef) {
+              Callbacks->Elifdef(DirectiveToken.getLocation(), MacroNameTok,
+                                 MD);
+            } else {
+              Callbacks->Elifndef(DirectiveToken.getLocation(), MacroNameTok,
+                                  MD);
+            }
+          }
+          // If this condition is true, enter it!
+          if (static_cast<bool>(MI) == IsElifDef) {
+            CondInfo.FoundNonSkip = true;
+            break;
+          }
+        }
       }
     }
 
     CurPPLexer->ParsingPreprocessorDirective = false;
     // Restore comment saving mode.
     if (CurLexer) CurLexer->resetExtendedTokenMode();
   }
 
default:
     case tok::pp_ifdef:
       return HandleIfdefDirective(Result, SavedHash, false,
                                   true /*not valid for miopt*/);
     case tok::pp_ifndef:
       return HandleIfdefDirective(Result, SavedHash, true,
                                   ReadAnyTokensBeforeDirective);
     case tok::pp_elif:
       return HandleElifDirective(Result, SavedHash);
+    case tok::pp_elifdef:
+      return HandleElifdefDirective(Result, SavedHash, /*isElifndef*/false,
+                                    true /*not valid for miopt*/);
+    case tok::pp_elifndef:
+      return HandleElifdefDirective(Result, SavedHash, /*isElifndef*/true,
+                                    ReadAnyTokensBeforeDirective);
     case tok::pp_else:
       return HandleElseDirective(Result, SavedHash);
     case tok::pp_endif:
       return HandleEndifDirective(Result);
 
     // C99 6.10.2 - Source File Inclusion.
     case tok::pp_include:
       // Handle #include.
void Preprocessor::HandleElifDirective(Token &ElifToken,
 
   // #elif directive in a non-skipping conditional... start skipping.
   // We don't care what the condition is, because we will always skip it (since
   // the block immediately before it was included).
   SourceRange ConditionRange = DiscardUntilEndOfDirective();
 
   PPConditionalInfo CI;
   if (CurPPLexer->popConditionalLevel(CI)) {
-    Diag(ElifToken, diag::pp_err_elif_without_if);
+    Diag(ElifToken, diag::pp_err_elif_without_if) << PED_Elif;
     return;
   }
 
   // If this is a top-level #elif, inform the MIOpt.
   if (CurPPLexer->getConditionalStackDepth() == 0)
     CurPPLexer->MIOpt.EnterTopLevelConditional();
 
   // If this is a #elif with a #else before it, report the error.
-  if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
+  if (CI.FoundElse)
+    Diag(ElifToken, diag::pp_err_elif_after_else) << PED_Elif;
 
   if (Callbacks)
     Callbacks->Elif(ElifToken.getLocation(), ConditionRange,
                     PPCallbacks::CVK_NotEvaluated, CI.IfLoc);
 
   bool RetainExcludedCB = PPOpts->RetainExcludedConditionalBlocks &&
     getSourceManager().isInMainFile(ElifToken.getLocation());
 
   if ((PPOpts->SingleFileParseMode && !CI.FoundNonSkip) || RetainExcludedCB) {
     // In 'single-file-parse mode' undefined identifiers trigger parsing of all
     // the directive blocks.
     CurPPLexer->pushConditionalLevel(ElifToken.getLocation(), /*wasskip*/false,
                                      /*foundnonskip*/false, /*foundelse*/false);
     return;
   }
 
   // Finally, skip the rest of the contents of this block.
   SkipExcludedConditionalBlock(
       HashToken.getLocation(), CI.IfLoc, /*Foundnonskip*/ true,
       /*FoundElse*/ CI.FoundElse, ElifToken.getLocation());
 }
+
+/// HandleElifdefDirective - Implements the \#elifdef/\#elifndef directive.
+/// isElifndef is true when this is a \#elifndef directive.
+/// ReadAnyTokensBeforeDirective is true if any tokens have been returned or
+/// pp-directives activated before this \#elifndef has been lexed.
+void Preprocessor::HandleElifdefDirective(Token &Result, const Token &HashToken,
+                                          bool isElifndef,
+                                          bool ReadAnyTokensBeforeDirective) {
+  ++NumElse;
+  Token DirectiveTok = Result;
+
+  Token MacroNameTok;
+  ReadMacroName(MacroNameTok);
+
+  // Error reading macro name?  If so, diagnostic already issued.
+  if (MacroNameTok.is(tok::eod)) {
+    // Skip code until we get to #endif.  This helps with recovery by not
+    // emitting an error when the #endif is reached.
+    SkipExcludedConditionalBlock(HashToken.getLocation(),
+                                 DirectiveTok.getLocation(),
+                                 /*Foundnonskip*/ false, /*FoundElse*/ false);
+    return;
+  }
+
+  // Check to see if this is the last token on the #elif[n]def line.
+  CheckEndOfDirective(isElifndef ? "elifndef" : "elifdef");
+
+  PPConditionalInfo CI;
+  if (CurPPLexer->popConditionalLevel(CI)) {
+    Diag(DirectiveTok, diag::pp_err_elif_without_if)
+        << (isElifndef ? PED_Elifndef : PED_Elifdef);
+    return;
+  }
+
+  if (CurPPLexer->getConditionalStackDepth() == 0)
+    CurPPLexer->MIOpt.EnterTopLevelConditional();
+
+  // If this is a #elif[n]def with a #else before it, report the error.
+  if (CI.FoundElse)
+    Diag(DirectiveTok, diag::pp_err_elif_after_else)
+        << (isElifndef ? PED_Elifndef : PED_Elifdef);
+
+  IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
+  auto MD = getMacroDefinition(MII);
+  MacroInfo *MI = MD.getMacroInfo();
+
+  // If there is a macro, process it.
+  if (MI) // Mark it used.
+    markMacroAsUsed(MI);
+
+  if (Callbacks) {
+    if (isElifndef)
+      Callbacks->Elifndef(DirectiveTok.getLocation(), MacroNameTok, MD);
+    else
+      Callbacks->Elifdef(DirectiveTok.getLocation(), MacroNameTok, MD);
+  }
+
+  bool RetainExcludedCB =
+      PPOpts->RetainExcludedConditionalBlocks &&
+      getSourceManager().isInMainFile(DirectiveTok.getLocation());
+
+  // Should we include the stuff contained by this directive?
+  if (PPOpts->SingleFileParseMode && !MI) {
+    // In 'single-file-parse mode' undefined identifiers trigger parsing of all
+    // the directive blocks.
+    CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
+                                     /*wasskip*/ false, /*foundnonskip*/ false,
+                                     /*foundelse*/ false);
+  } else if (!MI == isElifndef || RetainExcludedCB) {
+    // Yes, remember that we are inside a conditional, then lex the next token.
+    CurPPLexer->pushConditionalLevel(DirectiveTok.getLocation(),
+                                     /*wasskip*/ false, /*foundnonskip*/ true,
+                                     /*foundelse*/ false);
+  } else {
+    // No, skip the contents of this block.
+    SkipExcludedConditionalBlock(HashToken.getLocation(),
+                                 DirectiveTok.getLocation(),
+                                 /*Foundnonskip*/ false,
+                                 /*FoundElse*/ false);
+  }
+}

clang/lib/Lex/PreprocessingRecord.cpp

 void PreprocessingRecord::Ifdef(SourceLocation Loc, const Token &MacroNameTok,
                                 const MacroDefinition &MD) {
   // This is not actually a macro expansion but record it as a macro reference.
   if (MD)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       MacroNameTok.getLocation());
 }
 
+void PreprocessingRecord::Elifdef(SourceLocation Loc, const Token &MacroNameTok,
+                                  const MacroDefinition &MD) {
+  // This is not actually a macro expansion but record it as a macro reference.
+  if (MD)
+    addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
+                      MacroNameTok.getLocation());
+}
+
 void PreprocessingRecord::Ifndef(SourceLocation Loc, const Token &MacroNameTok,
                                  const MacroDefinition &MD) {
   // This is not actually a macro expansion but record it as a macro reference.
   if (MD)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       MacroNameTok.getLocation());
 }
 
+void PreprocessingRecord::Elifndef(SourceLocation Loc,
+                                   const Token &MacroNameTok,
+                                   const MacroDefinition &MD) {
+  // This is not actually a macro expansion but record it as a macro reference.
+  if (MD)
+    addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
+                      MacroNameTok.getLocation());
+}
+
 void PreprocessingRecord::Defined(const Token &MacroNameTok,
                                   const MacroDefinition &MD,
                                   SourceRange Range) {
   // This is not actually a macro expansion but record it as a macro reference.
   if (MD)
     addMacroExpansion(MacroNameTok, MD.getMacroInfo(),
                       MacroNameTok.getLocation());
 }

clang/lib/Lex/Preprocessor.cpp

void Preprocessor::PrintStats() {
   llvm::errs() << "\n*** Preprocessor Stats:\n";
   llvm::errs() << NumDirectives << " directives found:\n";
   llvm::errs() << "  " << NumDefined << " #define.\n";
   llvm::errs() << "  " << NumUndefined << " #undef.\n";
   llvm::errs() << "  #include/#include_next/#import:\n";
   llvm::errs() << "    " << NumEnteredSourceFiles << " source files entered.\n";
   llvm::errs() << "    " << MaxIncludeStackDepth << " max include stack depth\n";
   llvm::errs() << "  " << NumIf << " #if/#ifndef/#ifdef.\n";
-  llvm::errs() << "  " << NumElse << " #else/#elif.\n";
+  llvm::errs() << "  " << NumElse << " #else/#elif/#elifdef/#elifndef.\n";
   llvm::errs() << "  " << NumEndif << " #endif.\n";
   llvm::errs() << "  " << NumPragma << " #pragma.\n";
   llvm::errs() << NumSkipped << " #if/#ifndef#ifdef regions skipped\n";
 
   llvm::errs() << NumMacroExpanded << "/" << NumFnMacroExpanded << "/"
              << NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, "
              << NumFastMacroExpanded << " on the fast path.\n";
   llvm::errs() << (NumFastTokenPaste+NumTokenPaste)

clang/lib/Sema/SemaCodeComplete.cpp

void Sema::CodeCompletePreprocessorDirective(bool InConditional) {
 
   if (InConditional) {
     // #elif <condition>
     Builder.AddTypedTextChunk("elif");
     Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
     Builder.AddPlaceholderChunk("condition");
     Results.AddResult(Builder.TakeString());
 
+    // #elifdef <macro>
+    Builder.AddTypedTextChunk("elifdef");
+    Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
+    Builder.AddPlaceholderChunk("macro");
+    Results.AddResult(Builder.TakeString());
+
+    // #elifndef <macro>
+    Builder.AddTypedTextChunk("elifndef");
+    Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
+    Builder.AddPlaceholderChunk("macro");
+    Results.AddResult(Builder.TakeString());
+
     // #else
     Builder.AddTypedTextChunk("else");
     Results.AddResult(Builder.TakeString());
 
     // #endif
     Builder.AddTypedTextChunk("endif");
     Results.AddResult(Builder.TakeString());
   }

clang/test/Index/complete-preprocessor.m

 // CHECK-CC1-NEXT: NotImplemented:{TypedText line}{HorizontalSpace  }{Placeholder number}{HorizontalSpace  }{Text "}{Placeholder filename}{Text "} (40)
 // CHECK-CC1-NEXT: NotImplemented:{TypedText pragma}{HorizontalSpace  }{Placeholder arguments} (40)
 // CHECK-CC1-NEXT: NotImplemented:{TypedText undef}{HorizontalSpace  }{Placeholder macro} (40)
 // CHECK-CC1-NEXT: NotImplemented:{TypedText warning}{HorizontalSpace  }{Placeholder message} (40)
 // RUN: c-index-test -code-completion-at=%s:5:2 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro}{LeftParen (}{Placeholder args}{RightParen )} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText elif}{HorizontalSpace  }{Placeholder condition} (40)
+// CHECK-CC2-NEXT: NotImplemented:{TypedText elifdef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: NotImplemented:{TypedText elifndef}{HorizontalSpace  }{Placeholder macro} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText else} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText endif} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText error}{HorizontalSpace  }{Placeholder message} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText if}{HorizontalSpace  }{Placeholder condition} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText ifdef}{HorizontalSpace  }{Placeholder macro} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText ifndef}{HorizontalSpace  }{Placeholder macro} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText import}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
 // CHECK-CC2-NEXT: NotImplemented:{TypedText import}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)

clang/test/Preprocessor/elifdef.c

+// RUN: %clang_cc1 %s -Eonly -verify
+
+#ifdef FOO
+#elifdef BAR
+#error "did not expect to get here"
+#endif
+
+/* expected-error@+4 {{"got it"}} */
+#ifdef FOO
+#elifdef BAR
+#else
+#error "got it"
+#endif
+
+/* expected-error@+3 {{"got it"}} */
+#ifdef FOO
+#elifndef BAR
+#error "got it"
+#endif
+
+/* expected-error@+3 {{"got it"}} */
+#ifdef FOO
+#elifndef BAR
+#error "got it"
+#else
+#error "did not expect to get here"
+#endif
+
+#define BAR
+/* expected-error@+3 {{"got it"}} */
+#ifdef FOO
+#elifdef BAR
+#error "got it"
+#endif
+#undef BAR
+
+#ifdef FOO
+#elifdef BAR // test that comments aren't an issue
+#error "did not expect to get here"
+#endif
+
+/* expected-error@+4 {{"got it"}} */
+#ifdef FOO
+#elifdef BAR // test that comments aren't an issue
+#else
+#error "got it"
+#endif
+
+/* expected-error@+3 {{"got it"}} */
+#ifdef FOO
+#elifndef BAR // test that comments aren't an issue
+#error "got it"
+#endif
+
+/* expected-error@+3 {{"got it"}} */
+#ifdef FOO
+#elifndef BAR // test that comments aren't an issue
+#error "got it"
+#else
+#error "did not expect to get here"
+#endif
+
+#define BAR
+/* expected-error@+3 {{"got it"}} */
+#ifdef FOO
+#elifdef BAR // test that comments aren't an issue
+#error "got it"
+#endif
+#undef BAR
+
+#define BAR
+/* expected-error@+6 {{"got it"}} */
+#ifdef FOO
+#error "did not expect to get here"
+#elifndef BAR
+#error "did not expect to get here"
+#else
+#error "got it"
+#endif
+#undef BAR
+
+/* expected-error@+3 {{#elifdef after #else}} */
+#ifdef FOO
+#else
+#elifdef BAR
+#endif
+
+/* expected-error@+3 {{#elifndef after #else}} */
+#ifdef FOO
+#else
+#elifndef BAR
+#endif
+
+#elifdef FOO /* expected-error {{#elifdef without #if}} */
+#endif       /* expected-error {{#endif without #if}} */
+
+#elifndef FOO /* expected-error {{#elifndef without #if}} */
+#endif        /* expected-error {{#endif without #if}} */

clang/test/Preprocessor/if_warning.c

 // RUN: %clang_cc1 %s -Eonly -Werror=undef -verify
 
 extern int x;
 
 #if foo   // expected-error {{'foo' is not defined, evaluates to 0}}
 #endif
 
 #ifdef foo
+#elifdef foo
 #endif
 
 #if defined(foo)
 #endif
 
 
 // PR3938
 #if 0
 #ifdef D
+#elifdef D
 #else 1       // Should not warn due to C99 6.10p4
 #endif
 #endif
 
 // rdar://9475098
 #if 0
 #else 1   // expected-warning {{extra tokens}}
 #endif
 
 // PR6852
 #if 'somesillylongthing'  // expected-warning {{character constant too long for its type}} \
                           // expected-warning {{multi-character character constant}}
 #endif

clang/test/Preprocessor/ifdef-recover.c

 #endif
 
 /* PR1936 */
 /* expected-error@+2 {{unterminated function-like macro invocation}} expected-error@+2 {{expected value in expression}} expected-note@+1 {{macro 'f' defined here}} */
 #define f(x) x
 #if f(2
 #endif
 
+/* expected-error@+2 {{macro name missing}} */
+#ifdef FOO
+#elifdef
+#endif
+
+/* expected-error@+2 {{macro name must be an identifier}} */
+#ifdef FOO
+#elifdef !
+#endif
+
 int x;

clang/test/Preprocessor/macro_misc.c

 // RUN: %clang_cc1 %s -Eonly -verify
 
 // This should not be rejected.
 #ifdef defined
+#elifdef defined
 #endif
 
 
 
 // PR3764
 
 // This should not produce a redefinition warning.
 #define FUNC_LIKE(a) (a)

clang/test/Preprocessor/macro_vaopt_check.cpp

 //expected-note@+1{{to match this '('}}
 #define V1(...) __VA_OPT__  ((())
 #undef V1
 
 // __VA_OPT__ can't appear anywhere else.
 #if __VA_OPT__ // expected-warning {{__VA_OPT__ can only appear in the expansion of a variadic macro}}
 #endif
 
+// expected-warning@+2 {{__VA_OPT__ can only appear in the expansion of a variadic macro}}
 #ifdef __VA_OPT__ // expected-warning {{__VA_OPT__ can only appear in the expansion of a variadic macro}}
+#elifdef __VA_OPT__
 #endif
 
 #define BAD __VA_OPT__ // expected-warning {{__VA_OPT__ can only appear in the expansion of a variadic macro}}

clang/unittests/Lex/DependencyDirectivesSourceMinimizerTest.cpp

TEST(MinimizeSourceToDependencyDirectivesTest, AllTokens) {
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define A\n"
                                            "#undef A\n"
                                            "#endif\n"
                                            "#if A\n"
                                            "#ifdef A\n"
                                            "#ifndef A\n"
+                                           "#elifdef A\n"
+                                           "#elifndef A\n"
                                            "#elif A\n"
                                            "#else\n"
                                            "#include <A>\n"
                                            "#include_next <A>\n"
                                            "#__include_macros <A>\n"
                                            "#import <A>\n"
                                            "@import A;\n"
                                            "#pragma clang module import A\n"
                                            "export module m;\n"
                                            "import m;\n",
                                            Out, Tokens));
   EXPECT_EQ(pp_define, Tokens[0].K);
   EXPECT_EQ(pp_undef, Tokens[1].K);
   EXPECT_EQ(pp_endif, Tokens[2].K);
   EXPECT_EQ(pp_if, Tokens[3].K);
   EXPECT_EQ(pp_ifdef, Tokens[4].K);
   EXPECT_EQ(pp_ifndef, Tokens[5].K);
-  EXPECT_EQ(pp_elif, Tokens[6].K);
-  EXPECT_EQ(pp_else, Tokens[7].K);
-  EXPECT_EQ(pp_include, Tokens[8].K);
-  EXPECT_EQ(pp_include_next, Tokens[9].K);
-  EXPECT_EQ(pp___include_macros, Tokens[10].K);
-  EXPECT_EQ(pp_import, Tokens[11].K);
-  EXPECT_EQ(decl_at_import, Tokens[12].K);
-  EXPECT_EQ(pp_pragma_import, Tokens[13].K);
-  EXPECT_EQ(cxx_export_decl, Tokens[14].K);
-  EXPECT_EQ(cxx_module_decl, Tokens[15].K);
-  EXPECT_EQ(cxx_import_decl, Tokens[16].K);
-  EXPECT_EQ(pp_eof, Tokens[17].K);
+  EXPECT_EQ(pp_elifdef, Tokens[6].K);
+  EXPECT_EQ(pp_elifndef, Tokens[7].K);
+  EXPECT_EQ(pp_elif, Tokens[8].K);
+  EXPECT_EQ(pp_else, Tokens[9].K);
+  EXPECT_EQ(pp_include, Tokens[10].K);
+  EXPECT_EQ(pp_include_next, Tokens[11].K);
+  EXPECT_EQ(pp___include_macros, Tokens[12].K);
+  EXPECT_EQ(pp_import, Tokens[13].K);
+  EXPECT_EQ(decl_at_import, Tokens[14].K);
+  EXPECT_EQ(pp_pragma_import, Tokens[15].K);
+  EXPECT_EQ(cxx_export_decl, Tokens[16].K);
+  EXPECT_EQ(cxx_module_decl, Tokens[17].K);
+  EXPECT_EQ(cxx_import_decl, Tokens[18].K);
+  EXPECT_EQ(pp_eof, Tokens[19].K);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, Define) {
   SmallVector<char, 128> Out;
   SmallVector<Token, 4> Tokens;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#define MACRO", Out, Tokens));
EXPECT_STREQ("#ifdef A\n"
                "#elif C\n"
                "#define D\n"
                "#else\n"
                "#define E\n"
                "#endif\n",
                Out.data());
 }
 
+TEST(MinimizeSourceToDependencyDirectivesTest, Elifdef) {
+  SmallVector<char, 128> Out;
+
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
+                                                    "#define B\n"
+                                                    "#elifdef C\n"
+                                                    "#define D\n"
+                                                    "#endif\n",
+                                                    Out));
+  EXPECT_STREQ("#ifdef A\n"
+               "#define B\n"
+               "#elifdef C\n"
+               "#define D\n"
+               "#endif\n",
+               Out.data());
+
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
+                                                    "#define B\n"
+                                                    "#elifdef B\n"
+                                                    "#define C\n"
+                                                    "#elifndef C\n"
+                                                    "#define D\n"
+                                                    "#else\n"
+                                                    "#define E\n"
+                                                    "#endif\n",
+                                                    Out));
+  EXPECT_STREQ("#ifdef A\n"
+               "#define B\n"
+               "#elifdef B\n"
+               "#define C\n"
+               "#elifndef C\n"
+               "#define D\n"
+               "#else\n"
+               "#define E\n"
+               "#endif\n",
+               Out.data());
+}
+
 TEST(MinimizeSourceToDependencyDirectivesTest, EmptyIfdef) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
                                                     "void skip();\n"
                                                     "#elif B\n"
                                                     "#elif C\n"
                                                     "#else D\n"
                                                     "#endif\n",
                                                     Out));
   EXPECT_STREQ("#ifdef A\n"
                "#elif B\n"
                "#elif C\n"
                "#endif\n",
                Out.data());
 }
 
+TEST(MinimizeSourceToDependencyDirectivesTest, EmptyElifdef) {
+  SmallVector<char, 128> Out;
+
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives("#ifdef A\n"
+                                                    "void skip();\n"
+                                                    "#elifdef B\n"
+                                                    "#elifndef C\n"
+                                                    "#else D\n"
+                                                    "#endif\n",
+                                                    Out));
+  EXPECT_STREQ("#ifdef A\n"
+               "#elifdef B\n"
+               "#elifndef C\n"
+               "#endif\n",
+               Out.data());
+}
+
 TEST(MinimizeSourceToDependencyDirectivesTest, Pragma) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma A\n", Out));
   EXPECT_STREQ("", Out.data());
 
   ASSERT_FALSE(minimizeSourceToDependencyDirectives("#pragma clang\n", Out));
   EXPECT_STREQ("", Out.data());
TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesBasic) {
   ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Toks));
   SmallVector<SkippedRange, 4> Ranges;
   ASSERT_FALSE(computeSkippedRanges(Toks, Ranges));
   EXPECT_EQ(Ranges.size(), 1u);
   EXPECT_EQ(Ranges[0].Offset, 0);
   EXPECT_EQ(Ranges[0].Length, (int)Out.find("#endif"));
 }
 
+TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesBasicElifdef) {
+  SmallString<128> Out;
+  SmallVector<Token, 32> Toks;
+  StringRef Source = "#ifdef BLAH\n"
+                     "void skip();\n"
+                     "#elifdef BLAM\n"
+                     "void skip();\n"
+                     "#elifndef GUARD\n"
+                     "#define GUARD\n"
+                     "void foo();\n"
+                     "#endif\n";
+  ASSERT_FALSE(minimizeSourceToDependencyDirectives(Source, Out, Toks));
+  SmallVector<SkippedRange, 4> Ranges;
+  ASSERT_FALSE(computeSkippedRanges(Toks, Ranges));
+  EXPECT_EQ(Ranges.size(), 3u);
+  EXPECT_EQ(Ranges[0].Offset, 0);
+  EXPECT_EQ(Ranges[0].Length, (int)Out.find("#elifdef"));
+  EXPECT_EQ(Ranges[1].Offset, (int)Out.find("#elifdef"));
+  EXPECT_EQ(Ranges[1].Offset + Ranges[1].Length, (int)Out.find("#elifndef"));
+  EXPECT_EQ(Ranges[2].Offset, (int)Out.find("#elifndef"));
+  EXPECT_EQ(Ranges[2].Offset + Ranges[2].Length, (int)Out.rfind("#endif"));
+}
+
 TEST(MinimizeSourceToDependencyDirectivesTest, SkippedPPRangesNested) {
   SmallString<128> Out;
   SmallVector<Token, 32> Toks;
   StringRef Source = "#ifndef GUARD\n"
                      "#define GUARD\n"
                      "#if FOO\n"
                      "#include hello\n"
                      "#elif BAR\n"