maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/test/Analysis/plist-macros-with-expansion...

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

951 lines
33 KiB
C++
Raw Normal View History

[analyzer] Specify the C++ standard in more tests. Makes life easier for downstream developers with different default standard. llvm-svn: 375308
2019-10-19 08:08:17 +08:00
// RUN: %clang_analyze_cc1 -std=c++14 -analyzer-checker=core %s \
[analyzer][PlistMacroExpansion] Part 1.: New expand-macros flag This is the first part of the implementation of the inclusion of macro expansions into the plist output. It adds a new flag that adds a new "macro_expansions" entry to each report that has PathDiagnosticPieces that were expanded from a macro. While there's an entry for each macro expansion, both the name of the macro and what it expands to is missing, and will be implemented in followup patches. Differential Revision: https://reviews.llvm.org/D52742 llvm-svn: 345724
2018-10-31 22:54:27 +08:00
// RUN: -analyzer-output=plist -o %t.plist \
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// RUN: -analyzer-config expand-macros=true -verify
[analyzer][PlistMacroExpansion] Part 1.: New expand-macros flag This is the first part of the implementation of the inclusion of macro expansions into the plist output. It adds a new flag that adds a new "macro_expansions" entry to each report that has PathDiagnosticPieces that were expanded from a macro. While there's an entry for each macro expansion, both the name of the macro and what it expands to is missing, and will be implemented in followup patches. Differential Revision: https://reviews.llvm.org/D52742 llvm-svn: 345724
2018-10-31 22:54:27 +08:00
//
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// RUN: FileCheck --input-file=%t.plist %s
[analyzer][PlistMacroExpansion] Part 1.: New expand-macros flag This is the first part of the implementation of the inclusion of macro expansions into the plist output. It adds a new flag that adds a new "macro_expansions" entry to each report that has PathDiagnosticPieces that were expanded from a macro. While there's an entry for each macro expansion, both the name of the macro and what it expands to is missing, and will be implemented in followup patches. Differential Revision: https://reviews.llvm.org/D52742 llvm-svn: 345724
2018-10-31 22:54:27 +08:00
void print(const void*);
//===----------------------------------------------------------------------===//
// Tests for non-function-like macro expansions.
//===----------------------------------------------------------------------===//
#define SET_PTR_VAR_TO_NULL \
ptr = 0
void nonFunctionLikeMacroTest() {
int *ptr;
SET_PTR_VAR_TO_NULL;
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>18</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>SET_PTR_VAR_TO_NULL</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =0</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 1.: New expand-macros flag This is the first part of the implementation of the inclusion of macro expansions into the plist output. It adds a new flag that adds a new "macro_expansions" entry to each report that has PathDiagnosticPieces that were expanded from a macro. While there's an entry for each macro expansion, both the name of the macro and what it expands to is missing, and will be implemented in followup patches. Differential Revision: https://reviews.llvm.org/D52742 llvm-svn: 345724
2018-10-31 22:54:27 +08:00
#define NULL 0
#define SET_PTR_VAR_TO_NULL_WITH_NESTED_MACRO \
ptr = NULL
void nonFunctionLikeNestedMacroTest() {
int *ptr;
SET_PTR_VAR_TO_NULL_WITH_NESTED_MACRO;
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>42</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>SET_PTR_VAR_TO_NULL_WITH_NESTED_MACRO</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =0</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
Reland '[analyzer][PlistMacroExpansion] Part 2.: Retrieving the macro name and primitive expansion' llvm-svn: 346111
2018-11-05 10:14:36 +08:00
//===----------------------------------------------------------------------===//
// Tests for function-like macro expansions.
//===----------------------------------------------------------------------===//
void setToNull(int **vptr) {
*vptr = nullptr;
}
#define TO_NULL(x) \
setToNull(x)
void functionLikeMacroTest() {
int *ptr;
TO_NULL(&ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>73</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL(&amp;ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>setToNull (&amp;ptr )</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
Reland '[analyzer][PlistMacroExpansion] Part 2.: Retrieving the macro name and primitive expansion' llvm-svn: 346111
2018-11-05 10:14:36 +08:00
#define DOES_NOTHING(x) \
{ \
int b; \
b = 5; \
} \
print(x)
#define DEREF(x) \
DOES_NOTHING(x); \
*x
void functionLikeNestedMacroTest() {
int *a;
TO_NULL(&a);
DEREF(a) = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>104</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL(&amp;a)</string>
// CHECK-NEXT: <key>expansion</key><string>setToNull (&amp;a )</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>105</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>DEREF(a)</string>
// CHECK-NEXT: <key>expansion</key><string>{int b ;b =5;}print (a );*a </string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
Reland '[analyzer][PlistMacroExpansion] Part 2.: Retrieving the macro name and primitive expansion' llvm-svn: 346111
2018-11-05 10:14:36 +08:00
//===----------------------------------------------------------------------===//
// Tests for undefining and/or redifining macros.
//===----------------------------------------------------------------------===//
#define WILL_UNDEF_SET_NULL_TO_PTR(ptr) \
ptr = nullptr;
void undefinedMacroByTheEndOfParsingTest() {
int *ptr;
WILL_UNDEF_SET_NULL_TO_PTR(ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
#undef WILL_UNDEF_SET_NULL_TO_PTR
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>141</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>WILL_UNDEF_SET_NULL_TO_PTR(ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =nullptr ;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
Reland '[analyzer][PlistMacroExpansion] Part 2.: Retrieving the macro name and primitive expansion' llvm-svn: 346111
2018-11-05 10:14:36 +08:00
#define WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL(ptr) \
/* Nothing */
#undef WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL
#define WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL(ptr) \
ptr = nullptr;
void macroRedefinedMultipleTimesTest() {
int *ptr;
WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL(ptr)
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
#undef WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL
#define WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL(ptr) \
print("This string shouldn't be in the plist file at all. Or anywhere, " \
"but here.");
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>169</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>WILL_REDIFINE_MULTIPLE_TIMES_SET_TO_NULL(ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =nullptr ;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
Reland '[analyzer][PlistMacroExpansion] Part 2.: Retrieving the macro name and primitive expansion' llvm-svn: 346111
2018-11-05 10:14:36 +08:00
#define WILL_UNDEF_SET_NULL_TO_PTR_2(ptr) \
ptr = nullptr;
#define PASS_PTR_TO_MACRO_THAT_WILL_BE_UNDEFD(ptr) \
WILL_UNDEF_SET_NULL_TO_PTR_2(ptr)
void undefinedMacroInsideAnotherMacroTest() {
int *ptr;
PASS_PTR_TO_MACRO_THAT_WILL_BE_UNDEFD(ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>200</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>PASS_PTR_TO_MACRO_THAT_WILL_BE_UNDEFD(ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =nullptr ;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
Reland '[analyzer][PlistMacroExpansion] Part 2.: Retrieving the macro name and primitive expansion' llvm-svn: 346111
2018-11-05 10:14:36 +08:00
#undef WILL_UNDEF_SET_NULL_TO_PTR_2
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
//===----------------------------------------------------------------------===//
// Tests for macro arguments containing commas and parantheses.
//
// As of writing these tests, the algorithm expands macro arguments by lexing
// the macro's expansion location, and relies on finding tok::comma and
// tok::l_paren/tok::r_paren.
//===----------------------------------------------------------------------===//
// Note that this commas, parantheses in strings aren't parsed as tok::comma or
// tok::l_paren/tok::r_paren, but why not test them.
#define TO_NULL_AND_PRINT(x, str) \
x = 0; \
print(str)
void macroArgContainsCommaInStringTest() {
int *a;
TO_NULL_AND_PRINT(a, "Will this , cause a crash?");
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>237</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL_AND_PRINT(a, &quot;Will this , cause a crash?&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>a =0;print (&quot;Will this , cause a crash?&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
void macroArgContainsLParenInStringTest() {
int *a;
TO_NULL_AND_PRINT(a, "Will this ( cause a crash?");
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>257</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL_AND_PRINT(a, &quot;Will this ( cause a crash?&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>a =0;print (&quot;Will this ( cause a crash?&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
void macroArgContainsRParenInStringTest() {
int *a;
TO_NULL_AND_PRINT(a, "Will this ) cause a crash?");
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>277</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL_AND_PRINT(a, &quot;Will this ) cause a crash?&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>a =0;print (&quot;Will this ) cause a crash?&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define CALL_FUNCTION(funcCall) \
funcCall
// Function calls do contain both tok::comma and tok::l_paren/tok::r_paren.
void macroArgContainsLParenRParenTest() {
int *a;
CALL_FUNCTION(setToNull(&a));
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>302</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CALL_FUNCTION(setToNull(&amp;a))</string>
// CHECK-NEXT: <key>expansion</key><string>setToNull (&amp;a )</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
void setToNullAndPrint(int **vptr, const char *str) {
setToNull(vptr);
print(str);
}
void macroArgContainsCommaLParenRParenTest() {
int *a;
CALL_FUNCTION(setToNullAndPrint(&a, "Hello!"));
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>327</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CALL_FUNCTION(setToNullAndPrint(&amp;a, &quot;Hello!&quot;))</string>
// CHECK-NEXT: <key>expansion</key><string>setToNullAndPrint (&amp;a ,&quot;Hello!&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define CALL_FUNCTION_WITH_TWO_PARAMS(funcCall, param1, param2) \
funcCall(param1, param2)
void macroArgContainsCommaLParenRParenTest2() {
int *a;
CALL_FUNCTION_WITH_TWO_PARAMS(setToNullAndPrint, &a, "Hello!");
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>350</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CALL_FUNCTION_WITH_TWO_PARAMS(setToNullAndPrint, &amp;a, &quot;Hello!&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>setToNullAndPrint (&amp;a ,&quot;Hello!&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define CALL_LAMBDA(l) \
l()
void commaInBracketsTest() {
int *ptr;
const char str[] = "Hello!";
// You need to add parantheses around a lambda expression to compile this,
// else the comma in the capture will be parsed as divider of macro args.
CALL_LAMBDA(([&ptr, str] () mutable { TO_NULL(&ptr); }));
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// FIXME: Why does the expansion appear twice?
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>376</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CALL_LAMBDA(([&amp;ptr, str] () mutable { TO_NULL(&amp;ptr); }))</string>
// CHECK-NEXT: <key>expansion</key><string>([&amp;ptr ,str ]()mutable {setToNull (&amp;ptr );})()</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>376</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CALL_LAMBDA(([&amp;ptr, str] () mutable { TO_NULL(&amp;ptr); }))</string>
// CHECK-NEXT: <key>expansion</key><string>([&amp;ptr ,str ]()mutable {setToNull (&amp;ptr );})()</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define PASTE_CODE(code) \
code
void commaInBracesTest() {
PASTE_CODE({ // expected-warning{{Dereference of null pointer}}
// NOTE: If we were to add a new variable here after a comma, we'd get a
// compilation error, so this test is mainly here to show that this was also
// investigated.
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
//
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
// int *ptr = nullptr, a;
int *ptr = nullptr;
*ptr = 5;
})
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>408</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>PASTE_CODE({ // expected-
// CHECK-NEXT: // NOTE: If we were to add a new variable here after a comma, we&apos;d get a
// CHECK-NEXT: // compilation error, so this test is mainly here to show that this was also
// CHECK-NEXT: // investigated.
// CHECK-NEXT: //
// CHECK-NEXT: // int *ptr = nullptr, a;
// CHECK-NEXT: int *ptr = nullptr;
// CHECK-NEXT: *ptr = 5;
// CHECK-NEXT: })</string>
// CHECK-NEXT: <key>expansion</key><string>{int *ptr =nullptr ;*ptr =5;}</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
// Example taken from
// https://gcc.gnu.org/onlinedocs/cpp/Macro-Arguments.html#Macro-Arguments.
#define POTENTIALLY_EMPTY_PARAM(x, y) \
x; \
y = nullptr
void emptyParamTest() {
int *ptr;
POTENTIALLY_EMPTY_PARAM(,ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>451</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>POTENTIALLY_EMPTY_PARAM(,ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>;ptr =nullptr </string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define NESTED_EMPTY_PARAM(a, b) \
POTENTIALLY_EMPTY_PARAM(a, b);
void nestedEmptyParamTest() {
int *ptr;
NESTED_EMPTY_PARAM(, ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>476</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>NESTED_EMPTY_PARAM(, ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>;ptr =nullptr ;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define CALL_FUNCTION_WITH_ONE_PARAM_THROUGH_MACRO(func, param) \
CALL_FUNCTION(func(param))
void lParenRParenInNestedMacro() {
int *ptr;
CALL_FUNCTION_WITH_ONE_PARAM_THROUGH_MACRO(setToNull, &ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>499</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CALL_FUNCTION_WITH_ONE_PARAM_THROUGH_MACRO(setToNull, &amp;ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>setToNull (&amp;ptr )</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
//===----------------------------------------------------------------------===//
// Tests for variadic macro arguments.
//===----------------------------------------------------------------------===//
template <typename ...Args>
void variadicFunc(Args ...args);
#define VARIADIC_SET_TO_NULL(ptr, ...) \
ptr = nullptr; \
variadicFunc(__VA_ARGS__)
void variadicMacroArgumentTest() {
int *ptr;
VARIADIC_SET_TO_NULL(ptr, 1, 5, "haha!");
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>530</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>VARIADIC_SET_TO_NULL(ptr, 1, 5, &quot;haha!&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =nullptr ;variadicFunc (1,5,&quot;haha!&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 4.: Support for __VA_ARGS__ Differential Revision: https://reviews.llvm.org/D52986 llvm-svn: 347888
2018-11-30 01:09:41 +08:00
void variadicMacroArgumentWithoutAnyArgumentTest() {
int *ptr;
// Not adding a single parameter to ... is silly (and also causes a
// preprocessor warning), but is not an excuse to crash on it.
VARIADIC_SET_TO_NULL(ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>552</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>VARIADIC_SET_TO_NULL(ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>ptr =nullptr ;variadicFunc ()</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
//===----------------------------------------------------------------------===//
// Tests for # and ##.
//===----------------------------------------------------------------------===//
#define DECLARE_FUNC_AND_SET_TO_NULL(funcName, ptr) \
void generated_##funcName(); \
ptr = nullptr;
void hashHashOperatorTest() {
int *ptr;
DECLARE_FUNC_AND_SET_TO_NULL(whatever, ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>580</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>DECLARE_FUNC_AND_SET_TO_NULL(whatever, ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>void generated_whatever ();ptr =nullptr ;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 5.: Support for # and ## From what I can see, this should be the last patch needed to replicate macro argument expansions. Differential Revision: https://reviews.llvm.org/D52988 llvm-svn: 348025
2018-12-01 03:21:35 +08:00
void macroArgContainsHashHashInStringTest() {
int *a;
TO_NULL_AND_PRINT(a, "Will this ## cause a crash?");
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>600</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL_AND_PRINT(a, &quot;Will this ## cause a crash?&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>a =0;print (&quot;Will this ## cause a crash?&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define PRINT_STR(str, ptr) \
print(#str); \
ptr = nullptr
void hashOperatorTest() {
int *ptr;
PRINT_STR(Hello, ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>624</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>PRINT_STR(Hello, ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>print (&quot;Hello&quot;);ptr =nullptr </string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 5.: Support for # and ## From what I can see, this should be the last patch needed to replicate macro argument expansions. Differential Revision: https://reviews.llvm.org/D52988 llvm-svn: 348025
2018-12-01 03:21:35 +08:00
void macroArgContainsHashInStringTest() {
int *a;
TO_NULL_AND_PRINT(a, "Will this # cause a crash?");
*a = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>644</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>TO_NULL_AND_PRINT(a, &quot;Will this # cause a crash?&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>a =0;print (&quot;Will this # cause a crash?&quot;)</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
//===----------------------------------------------------------------------===//
// Tests for more complex macro expansions.
//
// We won't cover anything that wasn't covered up to this point, but rather
// show more complex, macros with deeper nesting, more arguments (some unused)
// and so on.
//===----------------------------------------------------------------------===//
#define IF(Condition) \
if ( Condition )
#define L_BRACE {
#define R_BRACE }
#define LESS <
#define GREATER >
#define EQUALS =
#define SEMICOLON ;
#define NEGATIVE -
#define RETURN return
#define ZERO 0
#define EUCLIDEAN_ALGORITHM(A, B) \
IF(A LESS ZERO) L_BRACE \
A EQUALS NEGATIVE A SEMICOLON \
R_BRACE \
IF(B LESS ZERO) L_BRACE \
B EQUALS NEGATIVE B SEMICOLON \
R_BRACE \
\
/* This is where a while loop would be, but that seems to be too complex */ \
/* for the analyzer just yet. Let's just pretend that this algorithm */ \
/* works. */ \
\
RETURN B / (B - B) SEMICOLON
int getLowestCommonDenominator(int A, int B) {
EUCLIDEAN_ALGORITHM(A, B) // expected-warning{{Division by zero}}
}
void testVeryComplexAlgorithm() {
int tmp = 8 / (getLowestCommonDenominator(5, 7) - 1);
print(&tmp);
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>698</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>EUCLIDEAN_ALGORITHM(A, B)</string>
// CHECK-NEXT: <key>expansion</key><string>if (A &lt;0){A =-A ;}if (B &lt;0){B =-B ;}return B /(B -B );</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][PlistMacroExpansion] Part 3.: Macro arguments are expanded This part focuses on expanding macro arguments. Differential Revision: https://reviews.llvm.org/D52795 llvm-svn: 347629
2018-11-27 10:28:23 +08:00
#define YET_ANOTHER_SET_TO_NULL(x, y, z) \
print((void *) x); \
print((void *) y); \
z = nullptr;
#define DO_NOTHING(str) str
#define DO_NOTHING2(str2) DO_NOTHING(str2)
void test() {
int *ptr;
YET_ANOTHER_SET_TO_NULL(5, DO_NOTHING2("Remember the Vasa"), ptr);
*ptr = 5; // expected-warning{{Dereference of null pointer}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>730</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>YET_ANOTHER_SET_TO_NULL(5, DO_NOTHING2(&quot;Remember the Vasa&quot;), ptr)</string>
// CHECK-NEXT: <key>expansion</key><string>print ((void *)5);print ((void *)&quot;Remember the Vasa&quot;);ptr =nullptr ;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer] Fix infinite recursion in printing macros In the commited testfile, macro expansion (the one implemented for the plist output) runs into an infinite recursion. The issue originates from the algorithm being faulty, as in #define value REC_MACRO_FUNC(value) the "value" is being (or at least attempted) expanded from the same macro. The solved this issue by gathering already visited macros in a set, which does resolve the crash, but will result in an incorrect macro expansion, that would preferably be fixed down the line. Patch by Tibor Brunner! Differential Revision: https://reviews.llvm.org/D57891 llvm-svn: 355705
2019-03-09 00:26:29 +08:00
int garbage_value;
#define REC_MACRO_FUNC(REC_MACRO_PARAM) garbage_##REC_MACRO_PARAM
#define value REC_MACRO_FUNC(value)
void recursiveMacroUser() {
if (value == 0)
1 / value; // expected-warning{{Division by zero}}
// expected-warning@-1{{expression result unused}}
}
[analyzer] Fix function macro crash Re-commit D57893. Differential Revision: https://reviews.llvm.org/D57893 llvm-svn: 356142
2019-03-14 21:38:16 +08:00
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>754</integer>
// CHECK-NEXT: <key>col</key><integer>7</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>value</string>
// CHECK-NEXT: <key>expansion</key><string>garbage_value </string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][MacroExpansion][NFC] Fix a missing test output check
2020-08-13 01:00:24 +08:00
[analyzer] Fix function macro crash Re-commit D57893. Differential Revision: https://reviews.llvm.org/D57893 llvm-svn: 356142
2019-03-14 21:38:16 +08:00
#define FOO(x) int foo() { return x; }
#define APPLY_ZERO1(function) function(0)
APPLY_ZERO1(FOO)
void useZeroApplier1() { (void)(1 / foo()); } // expected-warning{{Division by zero}}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>776</integer>
// CHECK-NEXT: <key>col</key><integer>1</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>APPLY_ZERO1(FOO)</string>
// CHECK-NEXT: <key>expansion</key><string>int foo (){return 0;}</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer] Fix function macro crash Re-commit D57893. Differential Revision: https://reviews.llvm.org/D57893 llvm-svn: 356142
2019-03-14 21:38:16 +08:00
#define BAR(x) int bar() { return x; }
#define APPLY_ZERO2 BAR(0)
APPLY_ZERO2
void useZeroApplier2() { (void)(1 / bar()); } // expected-warning{{Division by zero}}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>796</integer>
// CHECK-NEXT: <key>col</key><integer>1</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>APPLY_ZERO2</string>
// CHECK-NEXT: <key>expansion</key><string>int bar (){return 0;}</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][MacroExpansion] Fix a crash where multiple parameters resolved to __VA_ARGS__ In short, macro expansions handled the case where a variadic parameter mapped to multiple arguments, but not the other way around. An internal ticket was submitted that demonstrated that we fail an assertion. Macro expansion so far worked by lexing the source code token-by-token and using the Preprocessor to turn these tokens into identifiers or just get their proper spelling, but what this counter intuitively doesn't do, is actually expand these macros, so we have to do the heavy lifting -- in this case, figure out what __VA_ARGS__ expands into. Since this case can only occur in a nested macro, the information we gathered from the containing macro does contain this information. If a parameter resolves to __VA_ARGS__, we need to temporarily stop getting our tokens from the lexer, and get the tokens from what __VA_ARGS__ maps to. Differential Revision: https://reviews.llvm.org/D86135
2020-09-11 19:51:54 +08:00
void foo(int &x, const char *str);
#define PARAMS_RESOLVE_TO_VA_ARGS(i, fmt) foo(i, fmt); \
i = 0;
#define DISPATCH(...) PARAMS_RESOLVE_TO_VA_ARGS(__VA_ARGS__);
void mulitpleParamsResolveToVA_ARGS(void) {
int x = 1;
DISPATCH(x, "LF1M healer");
(void)(10 / x); // expected-warning{{Division by zero}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>821</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>DISPATCH(x, &quot;LF1M healer&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>foo (x ,&quot;LF1M healer&quot;);x =0;;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][MacroExpansion] Fix a crash where multiple parameters resolved to __VA_ARGS__ In short, macro expansions handled the case where a variadic parameter mapped to multiple arguments, but not the other way around. An internal ticket was submitted that demonstrated that we fail an assertion. Macro expansion so far worked by lexing the source code token-by-token and using the Preprocessor to turn these tokens into identifiers or just get their proper spelling, but what this counter intuitively doesn't do, is actually expand these macros, so we have to do the heavy lifting -- in this case, figure out what __VA_ARGS__ expands into. Since this case can only occur in a nested macro, the information we gathered from the containing macro does contain this information. If a parameter resolves to __VA_ARGS__, we need to temporarily stop getting our tokens from the lexer, and get the tokens from what __VA_ARGS__ maps to. Differential Revision: https://reviews.llvm.org/D86135
2020-09-11 19:51:54 +08:00
void variadicCFunction(int &x, const char *str, ...);
#define CONCAT_VA_ARGS(i, fmt, ...) variadicCFunction(i, fmt, ##__VA_ARGS__); \
i = 0;
void concatVA_ARGS(void) {
int x = 1;
CONCAT_VA_ARGS(x, "You need to construct additional pylons.", 'c', 9);
(void)(10 / x); // expected-warning{{Division by zero}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>846</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CONCAT_VA_ARGS(x, &quot;You need to construct additional pylons.&quot;, &apos;c&apos;, 9)</string>
// CHECK-NEXT: <key>expansion</key><string>variadicCFunction (x ,&quot;You need to construct additional pylons.&quot;,&apos;c&apos;,9);x =0;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][MacroExpansion] Fix a crash where multiple parameters resolved to __VA_ARGS__ In short, macro expansions handled the case where a variadic parameter mapped to multiple arguments, but not the other way around. An internal ticket was submitted that demonstrated that we fail an assertion. Macro expansion so far worked by lexing the source code token-by-token and using the Preprocessor to turn these tokens into identifiers or just get their proper spelling, but what this counter intuitively doesn't do, is actually expand these macros, so we have to do the heavy lifting -- in this case, figure out what __VA_ARGS__ expands into. Since this case can only occur in a nested macro, the information we gathered from the containing macro does contain this information. If a parameter resolves to __VA_ARGS__, we need to temporarily stop getting our tokens from the lexer, and get the tokens from what __VA_ARGS__ maps to. Differential Revision: https://reviews.llvm.org/D86135
2020-09-11 19:51:54 +08:00
void concatVA_ARGSEmpty(void) {
int x = 1;
CONCAT_VA_ARGS(x, "You need to construct");
(void)(10 / x); // expected-warning{{Division by zero}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>866</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>CONCAT_VA_ARGS(x, &quot;You need to construct&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>variadicCFunction (x ,&quot;You need to construct&quot;);x =0;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][MacroExpansion] Fix a crash where multiple parameters resolved to __VA_ARGS__ In short, macro expansions handled the case where a variadic parameter mapped to multiple arguments, but not the other way around. An internal ticket was submitted that demonstrated that we fail an assertion. Macro expansion so far worked by lexing the source code token-by-token and using the Preprocessor to turn these tokens into identifiers or just get their proper spelling, but what this counter intuitively doesn't do, is actually expand these macros, so we have to do the heavy lifting -- in this case, figure out what __VA_ARGS__ expands into. Since this case can only occur in a nested macro, the information we gathered from the containing macro does contain this information. If a parameter resolves to __VA_ARGS__, we need to temporarily stop getting our tokens from the lexer, and get the tokens from what __VA_ARGS__ maps to. Differential Revision: https://reviews.llvm.org/D86135
2020-09-11 19:51:54 +08:00
#define STRINGIFIED_VA_ARGS(i, fmt, ...) variadicCFunction(i, fmt, #__VA_ARGS__); \
i = 0;
void stringifyVA_ARGS(void) {
int x = 1;
STRINGIFIED_VA_ARGS(x, "Additional supply depots required.", 'a', 10);
(void)(10 / x); // expected-warning{{Division by zero}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>889</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>STRINGIFIED_VA_ARGS(x, &quot;Additional supply depots required.&quot;, &apos;a&apos;, 10)</string>
// CHECK-NEXT: <key>expansion</key><string>variadicCFunction (x ,&quot;Additional supply depots required.&quot;,&quot;&apos;a&apos;, 10&quot;);x =0;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[analyzer][MacroExpansion] Fix a crash where multiple parameters resolved to __VA_ARGS__ In short, macro expansions handled the case where a variadic parameter mapped to multiple arguments, but not the other way around. An internal ticket was submitted that demonstrated that we fail an assertion. Macro expansion so far worked by lexing the source code token-by-token and using the Preprocessor to turn these tokens into identifiers or just get their proper spelling, but what this counter intuitively doesn't do, is actually expand these macros, so we have to do the heavy lifting -- in this case, figure out what __VA_ARGS__ expands into. Since this case can only occur in a nested macro, the information we gathered from the containing macro does contain this information. If a parameter resolves to __VA_ARGS__, we need to temporarily stop getting our tokens from the lexer, and get the tokens from what __VA_ARGS__ maps to. Differential Revision: https://reviews.llvm.org/D86135
2020-09-11 19:51:54 +08:00
void stringifyVA_ARGSEmpty(void) {
int x = 1;
STRINGIFIED_VA_ARGS(x, "Additional supply depots required.");
(void)(10 / x); // expected-warning{{Division by zero}}
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>909</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>STRINGIFIED_VA_ARGS(x, &quot;Additional supply depots required.&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>variadicCFunction (x ,&quot;Additional supply depots required.&quot;,&quot;&quot;);x =0;</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>
[Analyzer] GNU named variadic macros in Plister Added support for GNU named variadic macros in macro expansion for plist generation. Fix for https://bugs.llvm.org/show_bug.cgi?id=44493 Reviewed By: Szelethus Differential Revision: https://reviews.llvm.org/D87942
2020-09-22 04:37:39 +08:00
// bz44493: Support GNU-style named variadic arguments in plister
#define BZ44493_GNUVA(i, args...) --(i);
int bz44493(void) {
int a = 2;
BZ44493_GNUVA(a);
BZ44493_GNUVA(a, "arg2");
(void)(10 / a); // expected-warning{{Division by zero}}
return 0;
}
[analyzer] Use the MacroExpansionContext for macro expansions in plists Removes the obsolete ad-hoc macro expansions during bugreport constructions. It will skip the macro expansion if the expansion happened in an imported TU. Also removes the expected plist file, while expanding matching context for the tests. Adds a previously crashing `plist-macros-with-expansion.c` testfile. Temporarily marks `plist-macros-with-expansion-ctu.c ` to `XFAIL`. Reviewed By: xazax.hun, Szelethus Differential Revision: https://reviews.llvm.org/D93224
2021-02-22 18:12:18 +08:00
// CHECK: <key>macro_expansions</key>
// CHECK-NEXT: <array>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>location</key>
// CHECK-NEXT: <dict>
// CHECK-NEXT: <key>line</key><integer>933</integer>
// CHECK-NEXT: <key>col</key><integer>3</integer>
// CHECK-NEXT: <key>file</key><integer>0</integer>
// CHECK-NEXT: </dict>
// CHECK-NEXT: <key>name</key><string>BZ44493_GNUVA(a, &quot;arg2&quot;)</string>
// CHECK-NEXT: <key>expansion</key><string>--(a );</string>
// CHECK-NEXT: </dict>
// CHECK-NEXT: </array>