Lines Matching +full:cancel +full:- +full:in +full:- +full:progress
1 //===-- CodeGenFunction.h - Per-Function state for LLVM CodeGen -*- C++ -*-===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This is the internal per-function state used for llvm translation.
11 //===----------------------------------------------------------------------===//
106 /// type. Basically, is the code in CGExprScalar, CGExprComplex, or
163 // If it's an instruction in the entry block, we don't need to save.
164 llvm::BasicBlock *block = cast<llvm::Instruction>(value)->getParent();
165 return (block != &block->getParent()->getEntryBlock());
241 // implementations in CGCleanup.cpp
255 /// CodeGenFunction - This class organizes the per-function state that is used
287 CodeGenModule &CGM; // Per-module state.
303 /// Since OMPCanonicalLoops are nested inside other statements (in particular
304 /// CapturedStmt generated by OMPExecutableDirective and non-perfectly nested
309 /// either means we start parsing a new loop nest (in which case the previous
310 /// loop nest goes out of scope) or a second loop in the same level in which
322 /// loop-associated directive.
333 // Codegen lambda for loop bounds in worksharing loop constructs
338 // Codegen lambda for loop bounds in dispatch-based loop implementation
349 /// CurFuncDecl - Holds the Decl for the current outermost
350 /// non-closure context.
352 /// CurCodeDecl - This is the inner-most code context, which includes blocks.
363 // in this header.
389 // It encapsulates SuspendExpr in a function, to separate it's body
391 // is lowered to this function call in CoroSplit pass
399 /// CurGD - The GlobalDecl for the current function being compiled.
402 /// PrologueCleanupDepth - The cleanup depth enclosing all the
406 /// ReturnBlock - Unified return block.
409 /// ReturnValue - The temporary alloca to hold the return
413 /// ReturnValuePointer - The temporary alloca to hold a pointer to sret.
414 /// This is invalid if sret is not in use.
421 /// Return true if a label was seen in the current scope.
424 return CurLexicalScope->hasLabels();
428 /// AllocaInsertPoint - This is an instruction in the entry block before which
433 /// PostAllocaInsertPt - This is a place in the prologue where code can be
438 /// appear in the source order immediately after all static allocas.
450 assert(AllocaInsertPt->getParent()->isEntryBlock() &&
452 PostAllocaInsertPt = AllocaInsertPt->clone();
453 PostAllocaInsertPt->setName("postallocapt");
454 PostAllocaInsertPt->insertAfter(AllocaInsertPt->getIterator());
470 S.getCapturedRecordDecl()->field_begin();
474 if (I->capturesThis())
476 else if (I->capturesVariable())
477 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
478 else if (I->capturesVariableByCopy())
479 CaptureFields[I->getCapturedVar()->getCanonicalDecl()] = *Field;
493 return CaptureFields.lookup(VD->getCanonicalDecl());
524 /// The base address of the captured record, passed in as the first
562 return FD->getNumParams();
563 return cast<ObjCMethodDecl>(CalleeDecl)->param_size();
567 return FD->getParamDecl(I);
568 return *(cast<ObjCMethodDecl>(CalleeDecl)->param_begin() + I);
586 /// In C++, whether we are code generating a thunk. This controls whether we
590 /// In ARC, whether we should autorelease the return value.
593 /// Whether we processed a Microsoft-style asm block during CodeGen. These can
627 /// Returns true if a function must make progress, which means the
635 // following (C++11 [intro.multithread]p24 and C++17 [intro.progress]p1):
636 // - terminate,
637 // - make a call to a library I/O function,
638 // - perform an access through a volatile glvalue, or
639 // - perform a synchronization operation or an atomic operation.
641 // Hence each function is 'mustprogress' in C++11 or later.
645 /// Returns true if a loop must make progress, which means the mustprogress
666 // full-expr.
669 // encountering branches out of expression (through stmt-expr or coroutine
691 for (size_t I = Stack.size(); I > OldDeactivateCleanupStackSize; I--) {
692 CGF.DeactivateCleanupBlock(Stack[I - 1].Cleanup,
693 Stack[I - 1].DominatingIP);
694 Stack[I - 1].DominatingIP->eraseFromParent();
727 // for -fextend-variable-liveness. They are placed at the end of a variable's
761 /// EHResumeBlock - Unified block containing a call to llvm.eh.resume.
785 /// Parent loop-based directive for scan directive.
833 /// ObjCEHValueStack - Stack of Objective-C exception values, used for
868 /// pushFullExprCleanup - Push a cleanup to be run at the end of the
869 /// current full-expression. Safe against the possibility that
870 /// we're currently inside a conditionally-evaluated expression.
873 // If we're not in a conditional branch, or if none of the
878 // Stash values in a tuple so we can guarantee the order of saves.
887 /// Queue a cleanup to be pushed after finishing the current full-expression,
940 /// full-expression cleanup.
948 /// PushDestructorCleanup - Push a cleanup to call the
949 /// complete-object destructor of an object of the given type at the
951 /// non-trivial destructor.
954 /// PushDestructorCleanup - Push a cleanup to call the
955 /// complete-object variant of the given destructor on the object at
960 /// PopCleanupBlock - Will pop the cleanup entry on the stack and
965 /// DeactivateCleanupBlock - Deactivates the given cleanup block.
969 /// \param DominatingIP - An instruction which is known to
976 /// ActivateCleanupBlock - Activates an initially-inactive cleanup.
979 /// \param DominatingIP - An instruction which is known to
1029 /// \param ValuesToReload - A list of values that need to be available at
1062 DI->EmitLexicalBlockStart(CGF.Builder, Range.getBegin());
1074 DI->EmitLexicalBlockEnd(CGF.Builder, Range.getEnd());
1116 /// Sets the address of the variable \p LocalVD to be \p TempAddr in
1121 LocalVD = LocalVD->getCanonicalDecl();
1128 SavedLocals.try_emplace(LocalVD, it->second);
1133 QualType VarTy = LocalVD->getType();
1134 if (VarTy->isReferenceType()) {
1162 /// Copy all the entries in the source map over the corresponding
1163 /// entries in the destination, which must exist.
1174 /// The scope used to remap some variables as private in the OpenMP loop body
1211 /// Exit scope - all the mapped variables are restored.
1217 /// Checks if the global variable is captured in current function.
1219 VD = VD->getCanonicalDecl();
1220 return !VD->isLocalVarDeclOrParm() && CGF.LocalDeclMap.count(VD) > 0;
1229 /// Save/restore original map of previously emitted local vars in case when we
1230 /// need to duplicate emission of the same code several times in the same
1249 /// that have been added, then adds all lifetime-extended cleanups from
1258 /// The given basic block lies in the current EH scope, but may be a
1259 /// target of a potentially scope-crossing jump; get a stable handle
1267 /// The given basic block lies in the current EH scope, but may be a
1268 /// target of a potentially scope-crossing jump; get a stable handle
1274 /// EmitBranchThroughCleanup - Emit a branch from the current insert
1279 /// isObviouslyBranchWithoutCleanups - Return true if a branch to the
1284 /// popCatchScope - Pops the catch scope at the top of the EHScope
1294 /// An object to manage conditionally-evaluated expressions.
1321 /// isInConditionalBranch - Return true if we're currently emitting
1328 llvm::BasicBlock *block = OutermostConditional->getStartingBlock();
1330 block->back().getIterator());
1331 store->setAlignment(addr.getAlignment().getAsAlign());
1339 /// We have to save the outermost conditional: cleanups in a
1358 /// all uses of a value have been realized in the IR.
1367 /// A non-RAII class containing all the information about a bound
1385 // gl-values should be bound as l-values for obvious reasons.
1386 // Records should be bound as l-values because IR generation
1387 // always keeps them in memory. Expressions of function type
1388 // act exactly like l-values but are formally required to be
1389 // r-values in C.
1390 return expr->isGLValue() ||
1391 expr->getType()->isFunctionType() ||
1392 hasAggregateEvaluationKind(expr->getType());
1419 // Work around an extremely aggressive peephole optimization in
1464 Data = OpaqueValueMappingData::bind(CGF, e->getOpaqueValue(),
1465 e->getCommon());
1473 assert(OV->getSourceExpr() && "wrong form of OpaqueValueMapping used "
1475 Data = OpaqueValueMappingData::bind(CGF, OV, OV->getSourceExpr());
1507 /// DidCallStackSave - Whether llvm.stacksave has been called. Used to avoid
1508 /// calling llvm.stacksave for multiple VLAs in the same scope.
1511 /// IndirectBranch - The first time an indirect goto is seen we create a block
1517 /// LocalDeclMap - This keeps track of the LLVM allocas or globals for local C
1521 // Keep track of the cleanups for callee-destructed parameters pushed to the
1526 /// SizeArguments - If a ParmVarDecl had the pass_object_size attribute, this
1536 /// LabelMap - This keeps track of the LLVM basic block for each C label.
1539 // BreakContinueStack - This keeps track of where break and continue
1550 /// Handles cancellation exit points in OpenMP-related constructs.
1552 /// Tracks cancellation exit point and join point for cancel-related exit
1591 /// Enter the cancel supporting \a Kind construct.
1592 /// \param Kind OpenMP directive that supports cancel constructs.
1593 /// \param HasCancel true, if the construct has inner cancel directive,
1597 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.exit")
1599 HasCancel ? CGF.getJumpDestInCurrentScope("cancel.cont")
1602 /// Emits default exit point for the cancel construct (if the special one
1603 /// has not be used) + join point for cancel/normal exits.
1653 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile) &&
1654 !CurFn->hasFnAttribute(llvm::Attribute::SkipProfile)) {
1664 !CurFn->hasFnAttribute(llvm::Attribute::NoProfile));
1678 const BinaryOperator *BOp = dyn_cast<BinaryOperator>(E->IgnoreParens());
1679 return (BOp && BOp->isLogicalOp());
1682 /// Zero-init the MCDC temp value.
1725 /// SwitchInsn - This is nearest current switch instruction. It is null if
1726 /// current context is not in a switch.
1734 /// CaseRangeBlock - This block holds if condition check for last case
1735 /// statement range in current switch instruction.
1738 /// OpaqueLValues - Keeps track of the current set of opaque value
1743 // VLASizeMap - This keeps track of the associated size for each VLA type.
1745 // in certain situations, like a const qualifier applied to an VLA typedef,
1755 /// Counts of the number return expressions in the function.
1758 /// Count the number of simple (constant) return expressions in the function.
1761 /// The last regular (non-return) debug location (breakpoint) in the function.
1916 RLFnCI->removeFromParent();
1936 /// Gets the OpenMP-specific address of the local variable /p VD.
1939 /// Get the platform-specific name separator.
1953 assert(IP.getBlock()->end() != IP.getPoint() &&
1957 llvm::BasicBlock *DestBB = IPBB->getUniqueSuccessor();
1961 IPBB->getTerminator()->eraseFromParent();
1984 if (llvm::Instruction *CodeGenIPBBTI = CodeGenIPBB->getTerminator())
1985 CodeGenIPBBTI->eraseFromParent();
1989 if (Fn->doesNotThrow())
1998 /// Emit the body of an OMP region that will be outlined in
2048 // Alloca insertion block should be in the entry block of the containing
2049 // function so it expects an empty AllocaIP in which case will reuse the
2050 // old alloca insertion point, or a new AllocaIP in the same block as
2053 CGF.AllocaInsertPt->getParent() == AllocaIP.getBlock()) &&
2054 "Insertion point should be in the entry block of containing "
2073 /// CXXThisDecl - When generating code for a C++ member function,
2093 /// CXXStructorImplicitParamDecl - When generating code for a constructor or
2098 /// OutermostConditional - Points to the outermost active
2110 /// BlockByrefInfos - For each __block variable, contains
2114 /// Used by -fsanitize=nullability-return to determine whether the return
2118 /// Check if -fsanitize=nullability-return instrumentation is required for
2141 /// Largest vector width used in ths function. Will be used to create a
2145 /// True if we need emit the life-time markers. This is initially set in
2174 /// which is assigned in every landing pad.
2206 //===--------------------------------------------------------------------===//
2208 //===--------------------------------------------------------------------===//
2277 //===--------------------------------------------------------------------===//
2278 // Objective-C
2279 //===--------------------------------------------------------------------===//
2285 /// GenerateObjCGetter - Synthesize an Objective-C property getter function.
2296 /// GenerateObjCSetter - Synthesize an Objective-C property setter function
2304 //===--------------------------------------------------------------------===//
2306 //===--------------------------------------------------------------------===//
2339 /// cleanup should be a no-op if the variable hasn't left the stack
2363 /// BuildBlockByrefAddress - Computes the location of the
2364 /// data in a variable which is declared as __block.
2415 EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
2425 /// FinishFunction - Complete IR generation of the current function. It is
2479 // VTableTrapMode - whether we guarantee that loading the
2487 /// GetVTablePtr - Return the Value of the vtable pointer member pointed
2510 /// EmitVTablePtrCheckForCall - Virtual method MD is being called via VTable.
2515 /// EmitVTablePtrCheck - Emit a check that VTable is a valid virtual table for
2520 /// If whole-program virtual table optimization is enabled, emit an assumption
2528 /// true when both vcall CFI and whole-program-vtables are enabled.
2537 /// EnterDtorCleanups - Enter the cleanups necessary to complete the
2539 /// should call destructors on members and base classes in reverse
2543 /// ShouldInstrumentFunction - Return true if the current function should be
2547 /// ShouldSkipSanitizerInstrumentation - Return true if the current function
2551 /// ShouldXRayInstrument - Return true if the current function should be
2555 /// AlwaysEmitXRayCustomEvents - Return true if we must unconditionally emit
2559 /// AlwaysEmitXRayTypedEvents - Return true if clang must unconditionally emit
2564 /// -fsanitize=function.
2567 /// EmitFunctionProlog - Emit the target specific LLVM code to load the
2574 /// EmitFunctionEpilog - Emit the target specific LLVM code to return the
2582 /// EmitStartEHSpec - Emit the start of the exception spec.
2585 /// EmitEndEHSpec - Emit the end of the exception spec.
2588 /// getTerminateLandingPad - Return a landing pad that just calls terminate.
2591 /// getTerminateLandingPad - Return a cleanup funclet that just calls
2595 /// getTerminateHandler - Return a handler (not a landing pad, just
2608 /// LoadObjCSelf - Load the value of self. This function is only valid while
2609 /// generating code for an Objective-C method.
2612 /// TypeOfSelfObject - Return type of object that this self represents.
2615 /// getEvaluationKind - Return the TypeEvaluationKind of QualType \c T.
2626 /// createBasicBlock - Create an LLVM basic block.
2633 /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
2637 /// SimplifyForwardingBlocks - If the given basic block is only a branch to
2642 /// EmitBlock - Emit the given block \arg BB and set it as the insert point,
2643 /// adding a fall-through branch from the current insert block if
2647 /// IsFinished - If true, indicates that the caller has finished emitting
2652 /// EmitBlockAfterUses - Emit the given block somewhere hopefully
2653 /// near its uses, and leave the insertion point in it.
2656 /// EmitBranch - Emit a branch to the specified basic block from the current
2666 /// HaveInsertPoint - True if an insertion point is defined. If not, this
2672 /// EnsureInsertPoint - Ensure that an insertion point is defined so that
2681 /// ErrorUnsupported - Print out an error that codegen doesn't support the
2685 //===--------------------------------------------------------------------===//
2687 //===--------------------------------------------------------------------===//
2696 PtrPhi->addIncoming(LHS.getBasePointer(), LHSBlock);
2697 PtrPhi->addIncoming(RHS.getBasePointer(), RHSBlock);
2754 /// an l-value with the natural pointee alignment of T.
2814 /// CreateTempAlloca - This creates an alloca and inserts it into the entry
2824 /// temporaries, as exposed in the source language. In certain
2830 /// common for most programming languages; OpenCL is an exception in that
2834 /// Because the address of a temporary is often exposed to the program in
2838 /// The cast is not performaed in CreateTempAllocaWithoutCast. This is
2850 /// CreateDefaultAlignedTempAlloca - This creates an alloca with the
2855 /// given IR type. This should only ever be used for function-local,
2856 /// IR-driven manipulations like saving and restoring a value. Do
2859 /// properly ABI-aligned value.
2863 /// CreateIRTemp - Create a temporary IR object of the given type, with
2867 /// for storing in memory.
2873 /// CreateMemTemp - Create a temporary memory object of the given type, with
2882 /// CreateMemTemp - Create a temporary memory object of the given type, with
2888 /// CreateAggTemp - Create a temporary memory object for the given
2898 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
2902 /// Retrieve the implicit cast expression of the rhs in a binary operator
2917 /// EmitIgnoredExpr - Emit an expression in a context which ignores the result.
2920 /// EmitAnyExpr - Emit code to compute the specified expression which can have
2930 // EmitVAListRef - Emit a "reference" to a va_list; this is either the address
2939 /// EmitAnyExprToTemp - Similarly to EmitAnyExpr(), however, the result will
2943 /// EmitAnyExprToMem - Emits the code necessary to evaluate an
2950 /// EmitInitializationToLValue - Emit an initializer to an LValue.
2955 /// EmitExprAsInit - Emits the code necessary to initialize a
2956 /// location in memory with the given initializer.
2960 /// hasVolatileMember - returns true if aggregate type has a volatile
2963 if (const RecordType *RT = T->getAs<RecordType>()) {
2964 const RecordDecl *RD = cast<RecordDecl>(RT->getDecl());
2965 return RD->hasVolatileMember();
2998 /// EmitAggregateCopy - Emit an aggregate copy.
3009 /// GetAddrOfLocalVar - Return the address of a local variable.
3014 return it->second;
3028 /// getAccessedFieldNo - Given an encoded value and a result number, return
3035 /// Check if \p E is a C++ "this" pointer wrapped in value-preserving casts.
3038 /// EmitNullInitialization - Generate code to set a value of the given type to
3040 /// to -1 in accordance with the Itanium C++ ABI.
3043 /// Emits a call to an LLVM variable-argument intrinsic, either
3051 /// Generate code to get an argument from the passed in pointer
3058 // instruction in LLVM instead once it works well enough.
3062 /// emitArrayLength - Compute the length of an array, even if it's a
3068 /// EmitVLASize - Capture all the sizes for the VLA expressions in
3069 /// the given variably-modified type and store them in the VLASizeMap.
3087 /// in non-variably-sized elements, of a variable length array type,
3088 /// plus that largest non-variably-sized element type. Assumes that
3093 /// LoadCXXThis - Load the value of 'this'. This function is only valid while
3101 /// LoadCXXVTT - Load the VTT parameter to base constructors/destructors have
3110 /// GetAddressOfBaseOfCompleteClass - Convert the given pointer to a
3120 /// GetAddressOfBaseClass - This function will add the necessary delta to the
3134 /// GetVTTParameter - Return the VTT parameter that should be passed to a
3136 /// FIXME: VTTs are Itanium ABI-specific, so the definition should move
3147 // is used to reduce duplication in the base and complete consturctors where
3182 /// most-derived class and not under construction of the object.
3242 /// Situations in which we might emit a check for the suitability of a
3243 /// pointer or glvalue. Needs to be kept in sync with ubsan_handlers.cpp in
3244 /// compiler-rt.
3250 /// Checking the bound value in a reference binding. Must be suitably sized
3254 /// Checking the object expression in a non-static data member access. Must
3257 /// Checking the 'this' pointer for a call to a non-static member function.
3287 /// Whether any type-checking sanitizers are enabled. If \c false,
3320 /// this expression is used as an lvalue, for instance in "&Arr[Idx]".
3328 // embedded inside multiple sub-structs, but must still be the last field.
3351 /// Get the record field index as represented in debug info.
3355 //===--------------------------------------------------------------------===//
3357 //===--------------------------------------------------------------------===//
3359 /// EmitDecl - Emit a declaration.
3364 /// EmitVarDecl - Emit a local variable declaration.
3375 /// Determine whether the given initializer is trivial in the sense
3379 /// EmitAutoVarDecl - Emit an auto variable declaration.
3405 /// Non-null if we should use lifetime annotations.
3461 /// dimension of an array. It registers the association of its (1-dimensional)
3511 /// EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
3514 /// protectFromPeepholes - Protect a value that we're intending to
3522 /// l-values, it's just that no existing peepholes work on pointers.
3544 //===--------------------------------------------------------------------===//
3546 //===--------------------------------------------------------------------===//
3548 /// EmitStopPoint - Emit a debug stoppoint if we are emitting debug info.
3551 /// EmitStmt - Emit the code for the statement \arg S. It is legal to call
3559 /// EmitSimpleStmt - Try to emit a "simple" statement which does not
3574 /// EmitLabel - Emit the block for the given label. It is legal to call this
3644 /// Emit simple code for OpenMP directives in Simd-only mode.
3653 /// Recovers the address of a local in a parent function. ParentVar is the
3654 /// address of the variable used in the immediate parent function. It can
3665 /// Controls insertion of cancellation exit blocks in worksharing constructs.
3707 /// \param DestVD Destination variable used in \a CopyExpr (for arrays, has
3709 /// \param SrcVD Source variable used in \a CopyExpr (for arrays, has type of
3723 /// \param IsXLHSInRHSPart true if \a X is LHS in RHS part of the update
3746 /// Emit code for copyin clause in \a D directive. The next code is
3765 /// proper codegen in internal captured statement.
3776 /// it is the last iteration of the loop code in associated directive, or to
3795 /// proper codegen in internal captured statement.
3993 /// TODO: The \p Depth paramter is not yet implemented and must be 1. In the
3994 /// future it is meant to be the number of loops expected in the loop nests
4011 /// \param PostIncGen Genrator for post-increment code (required for ordered
4020 /// Emit initial code for loop counters of loop-based directives.
4027 /// Emit code for the worksharing loop-based directive.
4028 /// \return true, if this construct has any lastprivate clause, false -
4034 /// Emit code for the distribute loop-based directive.
4051 /// struct with the values to be passed to the OpenMP loop-related functions
4106 //===--------------------------------------------------------------------===//
4108 //===--------------------------------------------------------------------===//
4110 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4111 // simply emitting its structured block, but in the future we will implement
4117 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4118 // simply emitting its loop, but in the future we will implement
4124 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4125 // simply emitting its loop, but in the future we will implement
4131 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4132 // simply emitting its structured block, but in the future we will implement
4138 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4139 // but in the future we will implement some sort of IR.
4143 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4144 // but in the future we will implement some sort of IR.
4148 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4149 // simply emitting its structured block, but in the future we will implement
4155 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4156 // but in the future we will implement some sort of IR.
4160 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4161 // but in the future we will implement some sort of IR.
4165 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4166 // but in the future we will implement some sort of IR.
4170 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4171 // but in the future we will implement some sort of IR.
4175 // TODO OpenACC: Implement this. It is currently implemented as a 'no-op',
4176 // but in the future we will implement some sort of IR.
4179 //===--------------------------------------------------------------------===//
4181 //===--------------------------------------------------------------------===//
4183 /// Create a check that a scalar RValue is non-null.
4186 /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
4189 /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
4195 /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue
4200 /// EmitLValue - Emit code to compute a designator that specifies the location
4204 /// reference. In either case, the LLVM Value* in the LValue structure is
4267 /// EmitToMemory - Change a scalar value from its value
4268 /// representation to its in-memory representation.
4271 /// EmitFromMemory - Change a scalar value from its memory
4282 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4298 /// EmitLoadOfScalar - Load a scalar value from an address, taking
4300 /// the LLVM value representation. The l-value must be a simple
4301 /// l-value.
4304 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4320 /// EmitStoreOfScalar - Store a scalar value to an address, taking
4322 /// the LLVM value representation. The l-value must be a simple
4323 /// l-value. The isInit flag indicates whether this is an initialization.
4324 /// If so, atomic qualifiers are ignored and the store is always non-atomic.
4327 /// EmitLoadOfLValue - Given an expression that represents a value lvalue,
4340 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
4347 /// EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints
4350 /// \param Result [out] - If non-null, this will be set to a Value* for the
4351 /// bit-field contents after the store, appropriate for use as the result of
4352 /// an assignment to the bit-field.
4356 /// Emit an l-value for an assignment (simple or compound) of complex type.
4427 refExpr->getType());
4453 /// EmitLValueForFieldInitialization - Like EmitLValueForField, except that
4455 /// and not the address of the value stored in the reference.
4475 //===--------------------------------------------------------------------===//
4477 //===--------------------------------------------------------------------===//
4479 /// EmitCall - Generate a call of the given function, expecting the given
4599 // These functions emit calls to the special functions of non-trivial C
4669 /// EmitTargetBuiltinExpr - Emit the given builtin call. Returns 0 if the call
4732 /// SVEBuiltinMemEltTy - Returns the memory element type for this memory
4857 /// Except under -fobjc-arc-eh, ARC cleanups are normal-only.
4935 /// Emits a reference binding to the passed in expression.
4938 //===--------------------------------------------------------------------===//
4940 //===--------------------------------------------------------------------===//
4944 /// EmitScalarExpr - Emit the computation of the specified expression of LLVM
4959 /// EmitAggExpr - Emit the computation of the specified expression
4964 /// EmitAggExprToLValue - Emit the computation of the specified expression of
4970 /// EmitAggFinalDestCopy - Emit copy of the specified aggregate into
4980 /// EmitExtendGCLifetime - Given a pointer to an Objective-C object,
4984 /// EmitComplexExpr - Emit the computation of the specified expression of
4990 /// EmitComplexExprIntoLValue - Emit the given expression of complex
4991 /// type and place its result into the specified l-value.
4994 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
4997 /// EmitLoadOfComplex - Load a complex number from the specified l-value.
5008 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
5019 /// EmitCXXGlobalVarDeclInit - Create the initializer for a C++
5048 /// Emit code in this function to perform a guarded variable
5064 /// GenerateCXXGlobalInitFunc - Generates code for initializing global
5071 /// GenerateCXXGlobalCleanUpFunc - Generates code for cleaning up global
5094 //===--------------------------------------------------------------------===//
5096 //===--------------------------------------------------------------------===//
5112 //===--------------------------------------------------------------------===//
5114 //===--------------------------------------------------------------------===//
5116 /// ContainsLabel - Return true if the statement contains a label in it. If
5121 /// containsBreak - Return true if the statement contains a break out of it.
5127 /// current scope, by being a (possibly-labelled) DeclStmt.
5130 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5132 /// constant folds return true and set the boolean result in Result.
5136 /// ConstantFoldsToSimpleInteger - If the specified expression does not fold
5142 /// Ignore parentheses and logical-NOT to track conditions consistently.
5145 /// isInstrumentedCondition - Determine whether the given condition is an
5149 /// EmitBranchToCounterBlock - Emit a conditional branch to a new block that
5160 /// EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g. for an
5211 /// Emit a description of a type in a format suitable for passing to
5219 /// Emit a description of a source location in a format suitable for
5226 /// Create a basic block that will either trap or call a handler function in
5235 /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath
5242 /// Emit a reached-unreachable diagnostic if \p Loc is valid and runtime
5247 /// conditional branch to it, for the -ftrapv checks.
5252 /// "trap-func-name" if specified.
5255 /// Emit a stub for the cross-DSO CFI check function.
5258 /// Emit a cross-DSO CFI failure handling function.
5262 /// declared as non-null.
5270 /// EmitWriteback - Emit callbacks for function.
5273 /// EmitCallArg - Emit a single call argument.
5276 /// EmitDelegateCallArg - We are performing a delegate call; that
5278 /// a r-value suitable for passing the given parameter.
5282 /// SetFPAccuracy - Set the minimum required accuracy of the given floating
5283 /// point operation, expressed as the maximum relative error in ulp.
5294 /// Set the codegen fast-math flags.
5327 assert(!LocalDeclMap.count(VD) && "Decl already exists in LocalDeclMap!");
5331 /// ExpandTypeFromArgs - Reconstruct a structure of type \arg Ty
5334 /// \param AI - The first function argument of the expansion.
5338 /// ExpandTypeToArgs - Expand an CallArg \arg Arg, with the LLVM type for \arg
5358 /// If EmittedExpr is non-null, this will use that instead of re-emitting E.
5382 ///! Language semantics require left-to-right evaluation.
5384 ///! Language semantics require right-to-left evaluation.
5403 /// EmitPointerWithAlignment - Given an expression with a pointer type,
5407 /// \param BaseInfo - If non-null, this will be initialized with
5408 /// information about the source of the alignment and the may-alias
5410 /// the type when it doesn't recognize the expression and may-alias will
5415 /// we're simply trying to ensure that sufficiently obvious uses of under-
5417 /// into the address of a local variable. In such a case, it's quite
5443 // options are already sorted in the proper order, with the 'default' option
5484 CGF.CGM.getDataLayout().getPrefTypeAlign(value->getType()));
5486 CGF.CreateTempAlloca(value->getType(), align, "cond-cleanup.save");
5497 // Otherwise, it should be an alloca instruction, as set up in save().
5499 return CGF.Builder.CreateAlignedLoad(alloca->getAllocatedType(), alloca,
5500 alloca->getAlign());
5506 // the corresponding enum in the IR.