Home | History | Annotate | Download | only in Sema

Lines Matching defs:IS

116   // Note that this is also a performance optimization.  Analyzing
185 // Returns true if the function is called anywhere within the CFGBlock.
187 // this pointer is required.
268   // If the exit block is unreachable, skip processing the function.
272   // Emit diagnostic if a recursive function call is detected for all paths.
306             !E->getSubExpr() || // throw; is considered cuaght by any handler
427   // Now we know what is live, we check the live precessors of the exit block
455     // Destructors can appear after the 'return' in the CFG.  This is
491       // TODO: Verify this is correct.
766   // Don't issue a fixit if there is already an initializer.
787 /// condition is CondVal.
792     // If condition is always true, remove all but the 'then'.
801     // If condition is always false, remove all but the 'else'.
855     // For all binary terminators, branch 0 is taken if the condition is true,
856     // and branch 1 is taken if the condition is false.
869     // "condition is true / condition is false".
871       const IfStmt *IS = cast<IfStmt>(Term);
874       Range = IS->getCond()->getSourceRange();
876       CreateIfFixit(S, IS, IS->getThen(), IS->getElse(),
909     // "loop is entered / loop is exited".
939     // "condition is true / loop is exited".
948     // "switch case is taken".
990 /// as a warning. If a particular use is one we omit warnings for, returns
996     // Inspect the initializer of the variable declaration which is
1004     // This is used to indicate to GCC that 'x' is intentionally left
1115           continue; // Case label is preceded with a normal label, good.
1142           // // <<<< This place is represented by a 'hanging' CFG block.
1385     // read is not within a loop, don't warn. Additionally, don't warn in a
1386     // loop if the base object is a local variable -- local variables are often
1458     // case can be turned off if it is too noisy.
1520     // Although this call will be slow, this is only called when outputting
1534   // the same as insertion order. This is needed to obtain a deterministic
1575       // variable, but the root cause is an idiomatic self-init.  We want
1576       // to report the diagnostic at the self-init since that is the root cause.
1600             // on the first point at which a variable is used uninitialized.
2166 /// At the moment, its primary goal is to make the information gathered during
2168 /// function.  This is important due to the fact that blocks are analyzed before
2169 /// the enclosed function is even parsed fully, so it is not viable to access
2176   // It is important to analyze blocks within functions because it's a very
2221   // (1) The CFGs often can't be constructed (if the body is invalid), so
2260   // is used to speed up various analyses.
2261   // FIXME: This isn't the right factoring.  This is here for initial
2264   // appropriately.  This is essentially a layering violation.
2307           // FIXME: We should be able to assert that block is non-null, but
2317           // If we cannot map to a basic block, assume the statement is
2349     // and it is very difficult to prove that a snippet of code in a template
2350     // is unreachable for all instantiations.