tree next = TREE_CHAIN (args);
/* NUM_ARG is null when the attribute includes just one argument, or is
- explictly set to null if it has been left uninitialized by the caller. */
+ explicitly set to null if it has been left uninitialized by the caller. */
tree num_arg = NULL_TREE;
if (next != NULL_TREE)
{
build_boolop (tree_code code, tree arg0, tree arg1)
{
/* Aggregate comparisons may get lowered to a call to builtin memcmp,
- so need to remove all side effects incase its address is taken. */
+ so need to remove all side effects in case its address is taken. */
if (AGGREGATE_TYPE_P (TREE_TYPE (arg0)))
arg0 = d_save_expr (arg0);
if (AGGREGATE_TYPE_P (TREE_TYPE (arg1)))
int offset;
if (cdo->isBaseOf (cd, &offset) && offset != 0)
{
- /* Generate a new frame to pass to the overriden function that
+ /* Generate a new frame to pass to the overridden function that
has the `this' pointer adjusted. */
gcc_assert (offset != OFFSET_RUNTIME);
return empty_modify_p (type, TREE_OPERAND (op, 1));
case CONSTRUCTOR:
- /* Non-empty construcors are valid. */
+ /* Non-empty constructors are valid. */
if (CONSTRUCTOR_NELTS (op) != 0 || TREE_CLOBBER_P (op))
return false;
break;
dmd::runDeferredSemantic3 ();
- /* Check again, incase semantic3 pass loaded any more modules. */
+ /* Check again, in case semantic3 pass loaded any more modules. */
while (builtin_modules.length != 0)
{
Module *m = builtin_modules.pop ();
case OPT_M:
case OPT_MM:
case OPT_fsyntax_only:
- /* Don't specify libaries if we won't link, since that would
+ /* Don't specify libraries if we won't link, since that would
cause a warning. */
saw_opt_c = true;
phobos_library = PHOBOS_NOLINK;
/* Generate a TypeTuple of the equivalent types used to determine if a
function argument of the given type can be passed in registers.
The results of this are highly platform dependent, and intended
- primarly for use in implementing va_arg() with RTTI. */
+ primarily for use in implementing va_arg() with RTTI. */
TypeTuple *
Target::toArgTypes (Type *)
emitted from the D Front-end to GCC trees.
All visit methods accept one parameter D, which holds the frontend AST
of the declaration to compile. These also don't return any value, instead
- generated code are appened to global_declarations or added to the
+ generated code are appended to global_declarations or added to the
current_binding_level by d_pushdecl(). */
class DeclVisitor : public Visitor
rest_of_decl_compilation (fndecl, 1, 0);
/* If this is a member function that nested (possibly indirectly) in another
- function, construct an expession for this member function's static chain
+ function, construct an expression for this member function's static chain
by going through parent link of nested classes. */
if (d->vthis)
d_function_chain->static_chain = get_symbol_decl (d->vthis);
implementation detail. The initialization of these symbols could be done at
run-time using during as part of the module initialization or shared static
constructors phase of run-time start-up - whichever comes after `gc_init()'.
- And infact that would be the better thing to do here eventually. */
+ And in fact that would be the better thing to do here eventually. */
tree
build_new_class_expr (ClassReferenceExp *expr)
void visit (CatExp *e) final override
{
/* This error is only emitted during the code generation pass because
- concatentation is allowed in CTFE. */
+ concatenation is allowed in CTFE. */
if (!global.params.useGC)
{
error_at (make_location_t (e->loc),
case EXP::unsignedRightShiftAssign:
/* Use the original lhs type before it was promoted. The left operand
of `>>>=' does not undergo integral promotions before shifting.
- Strip off casts just incase anyway. */
+ Strip off casts just in case anyway. */
while (e1b->op == EXP::cast_)
{
CastExp *ce = e1b->isCastExp ();
@deftypefnx {Function} {long} core.checkedint.subs (long @var{x}, long @var{y}, @
ref bool @var{overflow})
-Substract two signed integers, checking for overflow.
+Subtract two signed integers, checking for overflow.
This intrinsic is the same as the GCC built-in function
@code{__builtin_ssub_overflow}.
@deftypefnx {Function} {long} core.checkedint.subu (long @var{x}, long @var{y}, @
ref bool @var{overflow})
-Substract two unsigned integers, checking for overflow.
+Subtract two unsigned integers, checking for overflow.
This intrinsic is the same as the GCC built-in function
@code{__builtin_usub_overflow}.
@deftypefn {Function} {void} core.stdc.stdarg.va_end (va_list ap)
-Destroy @var{ap} so that it is no longer useable.
+Destroy @var{ap} so that it is no longer usable.
This intrinsic is the same as the GCC built-in function @code{__builtin_va_end}.
@end deftypefn
too complex, or do some low-level bit manipulation of floating point types.
Calls to these functions that exist after CTFE has finished will get standard
-code-generation without any special compiler intrinsic suppport.
+code-generation without any special compiler intrinsic support.
@deftypefn {Function} {float} std.math.exponential.exp (float x)
@deftypefnx {Function} {double} std.math.exponential.exp (double x)
return convert (TREE_TYPE (callexp), fold (exp));
}
-/* Expand a front-end instrinsic call to bsf(). This takes one argument,
+/* Expand a front-end intrinsic call to bsf(). This takes one argument,
the signature to which can be either:
int bsf (uint arg);
return call_builtin_fn (callexp, code, 1, arg);
}
-/* Expand a front-end instrinsic call to bsr(). This takes one argument,
+/* Expand a front-end intrinsic call to bsr(). This takes one argument,
the signature to which can be either:
int bsr (uint arg);
count = CALL_EXPR_ARG (callexp, 1);
else
{
- /* Retrieve from the encoded template instantation. */
+ /* Retrieve from the encoded template instantiation. */
tree callee = get_callee_fndecl (callexp);
TemplateInstance *ti = DECL_LANG_FRONTEND (callee)->isInstantiated ();
gcc_assert (ti && ti->tiargs && ti->tiargs->length == 2);
return call_builtin_fn (callexp, BUILT_IN_VA_START, 2, ap, parmn);
}
-/* Expand a front-end instrinsic call to INTRINSIC, which is either a call to
+/* Expand a front-end intrinsic call to INTRINSIC, which is either a call to
adds(), addu(), subs(), subu(), negs(), muls(), or mulu(). These intrinsics
expect to take two or three arguments, the signature to which can be either:
return compound_expr (exp, real_part (result));
}
-/* Expand a front-end instrinsic call to volatileLoad(). This takes one
+/* Expand a front-end intrinsic call to volatileLoad(). This takes one
argument, the signature to which can be either:
ubyte volatileLoad (ubyte* ptr);
return result;
}
-/* Expand a front-end instrinsic call to volatileStore(). This takes two
+/* Expand a front-end intrinsic call to volatileStore(). This takes two
arguments, the signature to which can be either:
void volatileStore (ubyte* ptr, ubyte value);
return modify_expr (result, value);
}
-/* Expand a front-end instrinsic call to convertvector(). This takes one
+/* Expand a front-end intrinsic call to convertvector(). This takes one
argument, the signature to which is:
vector(T) convertvector (vector(F) vec);
type, 1, vec);
}
-/* Expand a front-end instrinsic call to blendvector(). This expects to take
+/* Expand a front-end intrinsic call to blendvector(). This expects to take
three arguments, the signature to which is:
vector(T) blendvector (vector(T) vec0, vector(U) vec1, vector(M) mask);
return ret;
}
-/* Expand a front-end instrinsic call to shuffle(). This expects to take three
+/* Expand a front-end intrinsic call to shuffle(). This expects to take three
arguments, the signature to which is:
vector(T) shuffle (vector(T) vec0, vector(T) vec1, vector(M) mask);
TREE_TYPE (callexp), vec0, vec1, mask);
}
-/* Expand a front-end instrinsic call to shufflevector(). This takes two
+/* Expand a front-end intrinsic call to shufflevector(). This takes two
positional arguments and a variadic list, the signature to which is:
vector(TM) shuffle (vector(T) vec1, vector(T) vec2, index...);
return ret;
}
-/* Expand a front-end instrinsic call to loadUnaligned(). This takes one
+/* Expand a front-end intrinsic call to loadUnaligned(). This takes one
argument, the signature to which is:
vector(T) loadUnaligned (vector(T)* ptr)
return convert (TREE_TYPE (callexp), load);
}
-/* Expand a front-end instrinsic call to storeUnaligned(). This takes two
+/* Expand a front-end intrinsic call to storeUnaligned(). This takes two
arguments, the signature to which is:
vector(T) storeUnaligned (vector(T)* ptr, vector(T) value)
return dso_registry_fn;
}
-/* Depending on CTOR_P, builds and emits eiter a constructor or destructor
+/* Depending on CTOR_P, builds and emits either a constructor or destructor
calling _d_dso_registry if `dso_initialized' is `false' in a constructor
or `true' in a destructor. */
{
/* Don't write out label unless it is marked as used by the frontend.
This makes auto-vectorization possible in conditional loops.
- The only excemption to this is in the LabelStatement visitor,
+ The only exception to this is in the LabelStatement visitor,
in which all computed labels are marked regardless. */
if (TREE_USED (label))
add_stmt (build1 (LABEL_EXPR, void_type_node, label));
gcc_unreachable ();
}
- /* Do while statments implement simple loops. The body is executed, then
+ /* Do while statements implement simple loops. The body is executed, then
the condition is evaluated. */
void visit (DoStatement *s) final override
condition = fold (condition);
- /* Build LABEL_DECLs now so they can be refered to by goto case.
+ /* Build LABEL_DECLs now so they can be referred to by goto case.
Also checking the jump from the switch to the label is allowed. */
if (s->cases)
{
static Module *object_module;
/* Helper for create_frontend_tinfo_types. Creates a typeinfo class
- declaration incase one wasn't supplied by reading `object.d'. */
+ declaration in case one wasn't supplied by reading `object.d'. */
static void
make_frontend_typeinfo (Identifier *ident, ClassDeclaration *base = NULL)
finish_incomplete_fields (type);
}
-/* Returns true if the class or struct type TYPE has already been layed out by
+/* Returns true if the class or struct type TYPE has already been laid out by
the lowering of another front-end AST type. In which case, there will either
be a reuse of the back-end type, or a multiple definition error.
DECO is the uniquely mangled decoration for the type. */
projects / thirdparty / gcc.git / commitdiff
