For loads from ``const`` global variables of :ref:`C retainable pointer type
<arc.misc.c-retainable>`, it is reasonable to assume that global system
- constants were initialitzed with true constants (e.g. string literals), but
+ constants were initialized with true constants (e.g. string literals), but
user constants might have been initialized with something dynamically
allocated, using a global initializer.
* ``PT_VoidPtr``
- Void pointer type, can be used for rount-trip casts. Represented as
+ Void pointer type, can be used for round-trip casts. Represented as
the union of all pointers which can be cast to void.
Defined in ``"VoidPointer.h"``.
that Clang doesn't know, like ``blerg``, it'll ignore and assume
``unknown``, which is not always desired, so be careful.
-Finally, the env (enviornment) option is something that will pick default
+Finally, the env (environment) option is something that will pick default
CPU/FPU, define the specific behaviour of your code (PCS, extensions),
and also choose the correct library calls, etc.
this fact as `⊤`.
* When two control flow paths join, we compute the set union of incoming
- values (limiting the number of elements to 3, representig larger sets as
+ values (limiting the number of elements to 3, representing larger sets as
`⊤`).
The sets of possible values are influenced by:
We can't say what specific value gets printed, but we know that it is either `x`
or `-x`.
-Dataflow analysis is an istance of abstract interpretation, and does not dictate
+Dataflow analysis is an instance of abstract interpretation, and does not dictate
how exactly the lattice and transfer functions should be designed, beyond the
necessary conditions for the analysis to converge. Nevertheless, we can use
symbolic execution ideas to guide our design of the lattice and transfer
For this purpose we can use lattice in a form of a mapping from variable
declarations to initialization states; each initialization state is represented
-by the followingn lattice:
+by the following lattice:
$ clang++ -std=c++20 -g debugging-example.cpp -o debugging-example
$ gdb ./debugging-example
- (gdb) # We've alreay set the breakpoint.
+ (gdb) # We've already set the breakpoint.
(gdb) r
Program received signal SIGTRAP, Trace/breakpoint trap.
detail::chain_fn<0> () at debugging-example2.cpp:73
Taking a branch on nullable pointers are the same like taking branch on null unspecified pointers.
-Explicit cast from nullable to nonnul:
+Explicit cast from nullable to nonnull:
.. code-block:: cpp
/// virtual function; in abstract classes, the final overrider for at
/// least one virtual function is a pure virtual function. Due to
/// multiple, virtual inheritance, it is possible for a class to have
-/// more than one final overrider. Athough this is an error (per C++
+/// more than one final overrider. Although this is an error (per C++
/// [class.virtual]p2), it is not considered an error here: the final
/// overrider map can represent multiple final overriders for a
/// method, and it is up to the client to determine whether they are
void checkContainerDecl(const BlockCommandComment *Comment);
/// Resolve parameter names to parameter indexes in function declaration.
- /// Emit diagnostics about unknown parametrs.
+ /// Emit diagnostics about unknown parameters.
void resolveParamCommandIndexes(const FullComment *FC);
/// \returns \c true if the declaration that this comment is attached to
/// declaration to the declaration that is a definition (if there is one).
///
/// \param CheckForPendingFriendDefinition If \c true, also check for friend
- /// declarations that were instantiataed from function definitions.
+ /// declarations that were instantiated from function definitions.
/// Such a declaration behaves as if it is a definition for the
/// purpose of redefinition checking, but isn't actually a "real"
/// definition until its body is instantiated.
uint64_t : NumDeclContextBits;
/// Kind of initializer,
- /// function call or omp_priv<init_expr> initializtion.
+ /// function call or omp_priv<init_expr> initialization.
uint64_t InitializerKind : 2;
};
/// template.
///
/// This pointer refers to the template arguments (there are as
- /// many template arguments as template parameaters) for the
+ /// many template arguments as template parameters) for the
/// template, and is allocated lazily, since most templates do not
/// require the use of this information.
TemplateArgument *InjectedArgs = nullptr;
};
/// DeclarationNameInfo - A collector data type for bundling together
-/// a DeclarationName and the correspnding source/type location info.
+/// a DeclarationName and the corresponding source/type location info.
struct DeclarationNameInfo {
private:
/// Name - The declaration name, also encoding name kind.
void setDependence(ExprDependence Deps) {
ExprBits.Dependent = static_cast<unsigned>(Deps);
}
- friend class ASTImporter; // Sets dependence dircetly.
- friend class ASTStmtReader; // Sets dependence dircetly.
+ friend class ASTImporter; // Sets dependence directly.
+ friend class ASTStmtReader; // Sets dependence directly.
public:
QualType getType() const { return TR; }
}
/// Determines whether the type of this expression depends on
- /// - a template paramter (C++ [temp.dep.expr], which means that its type
+ /// - a template parameter (C++ [temp.dep.expr], which means that its type
/// could change from one template instantiation to the next)
/// - or an error
///
/// member expression.
static QualType findBoundMemberType(const Expr *expr);
- /// Skip past any invisble AST nodes which might surround this
+ /// Skip past any invisible AST nodes which might surround this
/// statement, such as ExprWithCleanups or ImplicitCastExpr nodes,
/// but also injected CXXMemberExpr and CXXConstructExpr which represent
/// implicit conversions.
return const_cast<Expr *>(this)->IgnoreParenLValueCasts();
}
- /// Skip past any parenthese and casts which do not change the value
+ /// Skip past any parentheses and casts which do not change the value
/// (including ptr->int casts of the same size) until reaching a fixed point.
/// Skips:
/// * What IgnoreParens() skips
/// The number of arguments in the call expression.
unsigned NumArgs;
- /// The location of the right parenthese. This has a different meaning for
+ /// The location of the right parentheses. This has a different meaning for
/// the derived classes of CallExpr.
SourceLocation RParenLoc;
/// \enum IfThen -- then branch of the if statement has no call.
/// \enum IfElse -- else branch of the if statement has no call.
/// \enum Switch -- one of the switch cases doesn't have a call.
-/// \enum SwitchSkipped -- there is no call if none of the cases appies.
+/// \enum SwitchSkipped -- there is no call if none of the cases applies.
/// \enum LoopEntered -- no call when the loop is entered.
/// \enum LoopSkipped -- no call when the loop is not entered.
/// \enum FallbackReason -- fallback case when we were not able to figure out
/// Check a function's CFG for consumed violations.
///
/// We traverse the blocks in the CFG, keeping track of the state of each
- /// value who's type has uniquness annotations. If methods are invoked in
+ /// value who's type has uniqueness annotations. If methods are invoked in
/// the wrong state a warning is issued. Each block in the CFG is traversed
/// exactly once.
void run(AnalysisDeclContext &AC);
projects / platform / upstream / llvm.git / commitdiff