diff options
Diffstat (limited to 'clang/lib/CodeGen')
34 files changed, 522 insertions, 522 deletions
diff --git a/clang/lib/CodeGen/CGAtomic.cpp b/clang/lib/CodeGen/CGAtomic.cpp index 47a82b602a0..f526eb4bb72 100644 --- a/clang/lib/CodeGen/CGAtomic.cpp +++ b/clang/lib/CodeGen/CGAtomic.cpp @@ -187,7 +187,7 @@ namespace { RValue convertAtomicTempToRValue(Address addr, AggValueSlot resultSlot, SourceLocation loc, bool AsValue) const; - /// \brief Converts a rvalue to integer value. + /// Converts a rvalue to integer value. llvm::Value *convertRValueToInt(RValue RVal) const; RValue ConvertIntToValueOrAtomic(llvm::Value *IntVal, @@ -208,13 +208,13 @@ namespace { LVal.getBaseInfo(), LVal.getTBAAInfo()); } - /// \brief Emits atomic load. + /// Emits atomic load. /// \returns Loaded value. RValue EmitAtomicLoad(AggValueSlot ResultSlot, SourceLocation Loc, bool AsValue, llvm::AtomicOrdering AO, bool IsVolatile); - /// \brief Emits atomic compare-and-exchange sequence. + /// Emits atomic compare-and-exchange sequence. /// \param Expected Expected value. /// \param Desired Desired value. /// \param Success Atomic ordering for success operation. @@ -230,13 +230,13 @@ namespace { llvm::AtomicOrdering::SequentiallyConsistent, bool IsWeak = false); - /// \brief Emits atomic update. + /// Emits atomic update. /// \param AO Atomic ordering. /// \param UpdateOp Update operation for the current lvalue. void EmitAtomicUpdate(llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp, bool IsVolatile); - /// \brief Emits atomic update. + /// Emits atomic update. /// \param AO Atomic ordering. void EmitAtomicUpdate(llvm::AtomicOrdering AO, RValue UpdateRVal, bool IsVolatile); @@ -244,25 +244,25 @@ namespace { /// Materialize an atomic r-value in atomic-layout memory. Address materializeRValue(RValue rvalue) const; - /// \brief Creates temp alloca for intermediate operations on atomic value. + /// Creates temp alloca for intermediate operations on atomic value. Address CreateTempAlloca() const; private: bool requiresMemSetZero(llvm::Type *type) const; - /// \brief Emits atomic load as a libcall. + /// Emits atomic load as a libcall. void EmitAtomicLoadLibcall(llvm::Value *AddForLoaded, llvm::AtomicOrdering AO, bool IsVolatile); - /// \brief Emits atomic load as LLVM instruction. + /// Emits atomic load as LLVM instruction. llvm::Value *EmitAtomicLoadOp(llvm::AtomicOrdering AO, bool IsVolatile); - /// \brief Emits atomic compare-and-exchange op as a libcall. + /// Emits atomic compare-and-exchange op as a libcall. llvm::Value *EmitAtomicCompareExchangeLibcall( llvm::Value *ExpectedAddr, llvm::Value *DesiredAddr, llvm::AtomicOrdering Success = llvm::AtomicOrdering::SequentiallyConsistent, llvm::AtomicOrdering Failure = llvm::AtomicOrdering::SequentiallyConsistent); - /// \brief Emits atomic compare-and-exchange op as LLVM instruction. + /// Emits atomic compare-and-exchange op as LLVM instruction. std::pair<llvm::Value *, llvm::Value *> EmitAtomicCompareExchangeOp( llvm::Value *ExpectedVal, llvm::Value *DesiredVal, llvm::AtomicOrdering Success = @@ -270,19 +270,19 @@ namespace { llvm::AtomicOrdering Failure = llvm::AtomicOrdering::SequentiallyConsistent, bool IsWeak = false); - /// \brief Emit atomic update as libcalls. + /// Emit atomic update as libcalls. void EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp, bool IsVolatile); - /// \brief Emit atomic update as LLVM instructions. + /// Emit atomic update as LLVM instructions. void EmitAtomicUpdateOp(llvm::AtomicOrdering AO, const llvm::function_ref<RValue(RValue)> &UpdateOp, bool IsVolatile); - /// \brief Emit atomic update as libcalls. + /// Emit atomic update as libcalls. void EmitAtomicUpdateLibcall(llvm::AtomicOrdering AO, RValue UpdateRVal, bool IsVolatile); - /// \brief Emit atomic update as LLVM instructions. + /// Emit atomic update as LLVM instructions. void EmitAtomicUpdateOp(llvm::AtomicOrdering AO, RValue UpdateRal, bool IsVolatile); }; diff --git a/clang/lib/CodeGen/CGBuilder.h b/clang/lib/CodeGen/CGBuilder.h index 3a4224873f4..5b9c7a3c46a 100644 --- a/clang/lib/CodeGen/CGBuilder.h +++ b/clang/lib/CodeGen/CGBuilder.h @@ -20,7 +20,7 @@ namespace CodeGen { class CodeGenFunction; -/// \brief This is an IRBuilder insertion helper that forwards to +/// This is an IRBuilder insertion helper that forwards to /// CodeGenFunction::InsertHelper, which adds necessary metadata to /// instructions. class CGBuilderInserter : protected llvm::IRBuilderDefaultInserter { @@ -29,7 +29,7 @@ public: explicit CGBuilderInserter(CodeGenFunction *CGF) : CGF(CGF) {} protected: - /// \brief This forwards to CodeGenFunction::InsertHelper. + /// This forwards to CodeGenFunction::InsertHelper. void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, llvm::BasicBlock::iterator InsertPt) const; diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 2740c17a19d..96d74b18444 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -189,7 +189,7 @@ static RValue EmitBinaryAtomicPost(CodeGenFunction &CGF, return RValue::get(Result); } -/// @brief Utility to insert an atomic cmpxchg instruction. +/// Utility to insert an atomic cmpxchg instruction. /// /// @param CGF The current codegen function. /// @param E Builtin call expression to convert to cmpxchg. @@ -320,7 +320,7 @@ static RValue emitLibraryCall(CodeGenFunction &CGF, const FunctionDecl *FD, return CGF.EmitCall(E->getCallee()->getType(), callee, E, ReturnValueSlot()); } -/// \brief Emit a call to llvm.{sadd,uadd,ssub,usub,smul,umul}.with.overflow.* +/// Emit a call to llvm.{sadd,uadd,ssub,usub,smul,umul}.with.overflow.* /// depending on IntrinsicID. /// /// \arg CGF The current codegen function. @@ -3667,7 +3667,7 @@ Value *CodeGenFunction::EmitNeonShiftVector(Value *V, llvm::Type *Ty, return ConstantInt::get(Ty, neg ? -SV : SV); } -// \brief Right-shift a vector by a constant. +// Right-shift a vector by a constant. Value *CodeGenFunction::EmitNeonRShiftImm(Value *Vec, Value *Shift, llvm::Type *Ty, bool usgn, const char *name) { diff --git a/clang/lib/CodeGen/CGCXXABI.h b/clang/lib/CodeGen/CGCXXABI.h index 1e4e13273a1..a1158d926c3 100644 --- a/clang/lib/CodeGen/CGCXXABI.h +++ b/clang/lib/CodeGen/CGCXXABI.h @@ -40,7 +40,7 @@ class CodeGenFunction; class CodeGenModule; struct CatchTypeInfo; -/// \brief Implements C++ ABI-specific code generation functions. +/// Implements C++ ABI-specific code generation functions. class CGCXXABI { protected: CodeGenModule &CGM; @@ -222,7 +222,7 @@ protected: /// is required. llvm::Constant *getMemberPointerAdjustment(const CastExpr *E); - /// \brief Computes the non-virtual adjustment needed for a member pointer + /// Computes the non-virtual adjustment needed for a member pointer /// conversion along an inheritance path stored in an APValue. Unlike /// getMemberPointerAdjustment(), the adjustment can be negative if the path /// is from a derived type to a base type. @@ -237,7 +237,7 @@ public: virtual void emitThrow(CodeGenFunction &CGF, const CXXThrowExpr *E) = 0; virtual llvm::GlobalVariable *getThrowInfo(QualType T) { return nullptr; } - /// \brief Determine whether it's possible to emit a vtable for \p RD, even + /// Determine whether it's possible to emit a vtable for \p RD, even /// though we do not know that the vtable has been marked as used by semantic /// analysis. virtual bool canSpeculativelyEmitVTable(const CXXRecordDecl *RD) const = 0; diff --git a/clang/lib/CodeGen/CGCall.h b/clang/lib/CodeGen/CGCall.h index da042e9906f..8adbe76fa6c 100644 --- a/clang/lib/CodeGen/CGCall.h +++ b/clang/lib/CodeGen/CGCall.h @@ -43,9 +43,9 @@ namespace CodeGen { /// Abstract information about a function or function prototype. class CGCalleeInfo { - /// \brief The function prototype of the callee. + /// The function prototype of the callee. const FunctionProtoType *CalleeProtoTy; - /// \brief The function declaration of the callee. + /// The function declaration of the callee. const Decl *CalleeDecl; public: @@ -334,7 +334,7 @@ public: llvm::Instruction *getStackBase() const { return StackBase; } void freeArgumentMemory(CodeGenFunction &CGF) const; - /// \brief Returns if we're using an inalloca struct to pass arguments in + /// Returns if we're using an inalloca struct to pass arguments in /// memory. bool isUsingInAlloca() const { return StackBase; } diff --git a/clang/lib/CodeGen/CGClass.cpp b/clang/lib/CodeGen/CGClass.cpp index 3b142d70522..db947d6514a 100644 --- a/clang/lib/CodeGen/CGClass.cpp +++ b/clang/lib/CodeGen/CGClass.cpp @@ -1739,7 +1739,7 @@ namespace { }; } // end anonymous namespace -/// \brief Emit all code that comes at the end of class's +/// Emit all code that comes at the end of class's /// destructor. This is to call destructors on members and base classes /// in reverse order of their construction. /// diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h index 5cd77177972..a692babef53 100644 --- a/clang/lib/CodeGen/CGDebugInfo.h +++ b/clang/lib/CodeGen/CGDebugInfo.h @@ -658,7 +658,7 @@ public: ~ApplyDebugLocation(); - /// \brief Apply TemporaryLocation if it is valid. Otherwise switch + /// Apply TemporaryLocation if it is valid. Otherwise switch /// to an artificial debug location that has a valid scope, but no /// line information. /// @@ -672,7 +672,7 @@ public: static ApplyDebugLocation CreateArtificial(CodeGenFunction &CGF) { return ApplyDebugLocation(CGF, false, SourceLocation()); } - /// \brief Apply TemporaryLocation if it is valid. Otherwise switch + /// Apply TemporaryLocation if it is valid. Otherwise switch /// to an artificial debug location that has a valid scope, but no /// line information. static ApplyDebugLocation diff --git a/clang/lib/CodeGen/CGDecl.cpp b/clang/lib/CodeGen/CGDecl.cpp index 75251df55bd..8c7bf882e7c 100644 --- a/clang/lib/CodeGen/CGDecl.cpp +++ b/clang/lib/CodeGen/CGDecl.cpp @@ -1283,7 +1283,7 @@ static bool isCapturedBy(const VarDecl &var, const Expr *e) { return false; } -/// \brief Determine whether the given initializer is trivial in the sense +/// Determine whether the given initializer is trivial in the sense /// that it requires no code to be generated. bool CodeGenFunction::isTrivialInitializer(const Expr *Init) { if (!Init) diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index 7b0f253944d..194eb412382 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -1791,7 +1791,7 @@ RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) { return RValue::get(Vec); } -/// @brief Generates lvalue for partial ext_vector access. +/// Generates lvalue for partial ext_vector access. Address CodeGenFunction::EmitExtVectorElementLValue(LValue LV) { Address VectorAddress = LV.getExtVectorAddress(); const VectorType *ExprVT = LV.getType()->getAs<VectorType>(); @@ -1813,7 +1813,7 @@ Address CodeGenFunction::EmitExtVectorElementLValue(LValue LV) { return VectorBasePtrPlusIx; } -/// @brief Load of global gamed gegisters are always calls to intrinsics. +/// Load of global gamed gegisters are always calls to intrinsics. RValue CodeGenFunction::EmitLoadOfGlobalRegLValue(LValue LV) { assert((LV.getType()->isIntegerType() || LV.getType()->isPointerType()) && "Bad type for register variable"); @@ -2073,7 +2073,7 @@ void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, Dst.isVolatileQualified()); } -/// @brief Store of global named registers are always calls to intrinsics. +/// Store of global named registers are always calls to intrinsics. void CodeGenFunction::EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst) { assert((Dst.getType()->isIntegerType() || Dst.getType()->isPointerType()) && "Bad type for register variable"); @@ -2710,7 +2710,7 @@ llvm::Value *CodeGenFunction::EmitCheckValue(llvm::Value *V) { return Builder.CreatePtrToInt(V, TargetTy); } -/// \brief Emit a representation of a SourceLocation for passing to a handler +/// Emit a representation of a SourceLocation for passing to a handler /// in a sanitizer runtime library. The format for this data is: /// \code /// struct SourceLocation { @@ -2769,7 +2769,7 @@ llvm::Constant *CodeGenFunction::EmitCheckSourceLocation(SourceLocation Loc) { } namespace { -/// \brief Specify under what conditions this check can be recovered +/// Specify under what conditions this check can be recovered enum class CheckRecoverableKind { /// Always terminate program execution if this check fails. Unrecoverable, diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp index 7e02a65bb69..713224ca12d 100644 --- a/clang/lib/CodeGen/CGExprAgg.cpp +++ b/clang/lib/CodeGen/CGExprAgg.cpp @@ -220,7 +220,7 @@ void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) { EmitFinalDestCopy(E->getType(), LV); } -/// \brief True if the given aggregate type requires special GC API calls. +/// True if the given aggregate type requires special GC API calls. bool AggExprEmitter::TypeRequiresGCollection(QualType T) { // Only record types have members that might require garbage collection. const RecordType *RecordTy = T->getAs<RecordType>(); @@ -369,7 +369,7 @@ void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest, dest.isVolatile() || src.isVolatile()); } -/// \brief Emit the initializer for a std::initializer_list initialized with a +/// Emit the initializer for a std::initializer_list initialized with a /// real initializer list. void AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { @@ -434,7 +434,7 @@ AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { } } -/// \brief Determine if E is a trivial array filler, that is, one that is +/// Determine if E is a trivial array filler, that is, one that is /// equivalent to zero-initialization. static bool isTrivialFiller(Expr *E) { if (!E) @@ -457,7 +457,7 @@ static bool isTrivialFiller(Expr *E) { return false; } -/// \brief Emit initialization of an array from an initializer list. +/// Emit initialization of an array from an initializer list. void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, QualType ArrayQTy, InitListExpr *E) { uint64_t NumInitElements = E->getNumInits(); diff --git a/clang/lib/CodeGen/CGExprComplex.cpp b/clang/lib/CodeGen/CGExprComplex.cpp index 30bbca4c02b..fb176093a74 100644 --- a/clang/lib/CodeGen/CGExprComplex.cpp +++ b/clang/lib/CodeGen/CGExprComplex.cpp @@ -595,7 +595,7 @@ ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { return ComplexPairTy(ResR, ResI); } -/// \brief Emit a libcall for a binary operation on complex types. +/// Emit a libcall for a binary operation on complex types. ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName, const BinOpInfo &Op) { CallArgList Args; @@ -633,7 +633,7 @@ ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName, return Res.getComplexVal(); } -/// \brief Lookup the libcall name for a given floating point type complex +/// Lookup the libcall name for a given floating point type complex /// multiply. static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) { switch (Ty->getTypeID()) { diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp index 9787f897d65..0edd1cbdaff 100644 --- a/clang/lib/CodeGen/CGExprScalar.cpp +++ b/clang/lib/CodeGen/CGExprScalar.cpp @@ -1145,7 +1145,7 @@ Value *ScalarExprEmitter::EmitNullValue(QualType Ty) { return CGF.EmitFromMemory(CGF.CGM.EmitNullConstant(Ty), Ty); } -/// \brief Emit a sanitization check for the given "binary" operation (which +/// Emit a sanitization check for the given "binary" operation (which /// might actually be a unary increment which has been lowered to a binary /// operation). The check passes if all values in \p Checks (which are \c i1), /// are \c true. diff --git a/clang/lib/CodeGen/CGLoopInfo.h b/clang/lib/CodeGen/CGLoopInfo.h index 15608c105dc..9d5f23ff9a2 100644 --- a/clang/lib/CodeGen/CGLoopInfo.h +++ b/clang/lib/CodeGen/CGLoopInfo.h @@ -32,62 +32,62 @@ class Attr; class ASTContext; namespace CodeGen { -/// \brief Attributes that may be specified on loops. +/// Attributes that may be specified on loops. struct LoopAttributes { explicit LoopAttributes(bool IsParallel = false); void clear(); - /// \brief Generate llvm.loop.parallel metadata for loads and stores. + /// Generate llvm.loop.parallel metadata for loads and stores. bool IsParallel; - /// \brief State of loop vectorization or unrolling. + /// State of loop vectorization or unrolling. enum LVEnableState { Unspecified, Enable, Disable, Full }; - /// \brief Value for llvm.loop.vectorize.enable metadata. + /// Value for llvm.loop.vectorize.enable metadata. LVEnableState VectorizeEnable; - /// \brief Value for llvm.loop.unroll.* metadata (enable, disable, or full). + /// Value for llvm.loop.unroll.* metadata (enable, disable, or full). LVEnableState UnrollEnable; - /// \brief Value for llvm.loop.vectorize.width metadata. + /// Value for llvm.loop.vectorize.width metadata. unsigned VectorizeWidth; - /// \brief Value for llvm.loop.interleave.count metadata. + /// Value for llvm.loop.interleave.count metadata. unsigned InterleaveCount; - /// \brief llvm.unroll. + /// llvm.unroll. unsigned UnrollCount; - /// \brief Value for llvm.loop.distribute.enable metadata. + /// Value for llvm.loop.distribute.enable metadata. LVEnableState DistributeEnable; }; -/// \brief Information used when generating a structured loop. +/// Information used when generating a structured loop. class LoopInfo { public: - /// \brief Construct a new LoopInfo for the loop with entry Header. + /// Construct a new LoopInfo for the loop with entry Header. LoopInfo(llvm::BasicBlock *Header, const LoopAttributes &Attrs, const llvm::DebugLoc &StartLoc, const llvm::DebugLoc &EndLoc); - /// \brief Get the loop id metadata for this loop. + /// Get the loop id metadata for this loop. llvm::MDNode *getLoopID() const { return LoopID; } - /// \brief Get the header block of this loop. + /// Get the header block of this loop. llvm::BasicBlock *getHeader() const { return Header; } - /// \brief Get the set of attributes active for this loop. + /// Get the set of attributes active for this loop. const LoopAttributes &getAttributes() const { return Attrs; } private: - /// \brief Loop ID metadata. + /// Loop ID metadata. llvm::MDNode *LoopID; - /// \brief Header block of this loop. + /// Header block of this loop. llvm::BasicBlock *Header; - /// \brief The attributes for this loop. + /// The attributes for this loop. LoopAttributes Attrs; }; -/// \brief A stack of loop information corresponding to loop nesting levels. +/// A stack of loop information corresponding to loop nesting levels. /// This stack can be used to prepare attributes which are applied when a loop /// is emitted. class LoopInfoStack { @@ -97,70 +97,70 @@ class LoopInfoStack { public: LoopInfoStack() {} - /// \brief Begin a new structured loop. The set of staged attributes will be + /// Begin a new structured loop. The set of staged attributes will be /// applied to the loop and then cleared. void push(llvm::BasicBlock *Header, const llvm::DebugLoc &StartLoc, const llvm::DebugLoc &EndLoc); - /// \brief Begin a new structured loop. Stage attributes from the Attrs list. + /// Begin a new structured loop. Stage attributes from the Attrs list. /// The staged attributes are applied to the loop and then cleared. void push(llvm::BasicBlock *Header, clang::ASTContext &Ctx, llvm::ArrayRef<const Attr *> Attrs, const llvm::DebugLoc &StartLoc, const llvm::DebugLoc &EndLoc); - /// \brief End the current loop. + /// End the current loop. void pop(); - /// \brief Return the top loop id metadata. + /// Return the top loop id metadata. llvm::MDNode *getCurLoopID() const { return getInfo().getLoopID(); } - /// \brief Return true if the top loop is parallel. + /// Return true if the top loop is parallel. bool getCurLoopParallel() const { return hasInfo() ? getInfo().getAttributes().IsParallel : false; } - /// \brief Function called by the CodeGenFunction when an instruction is + /// Function called by the CodeGenFunction when an instruction is /// created. void InsertHelper(llvm::Instruction *I) const; - /// \brief Set the next pushed loop as parallel. + /// Set the next pushed loop as parallel. void setParallel(bool Enable = true) { StagedAttrs.IsParallel = Enable; } - /// \brief Set the next pushed loop 'vectorize.enable' + /// Set the next pushed loop 'vectorize.enable' void setVectorizeEnable(bool Enable = true) { StagedAttrs.VectorizeEnable = Enable ? LoopAttributes::Enable : LoopAttributes::Disable; } - /// \brief Set the next pushed loop as a distribution candidate. + /// Set the next pushed loop as a distribution candidate. void setDistributeState(bool Enable = true) { StagedAttrs.DistributeEnable = Enable ? LoopAttributes::Enable : LoopAttributes::Disable; } - /// \brief Set the next pushed loop unroll state. + /// Set the next pushed loop unroll state. void setUnrollState(const LoopAttributes::LVEnableState &State) { StagedAttrs.UnrollEnable = State; } - /// \brief Set the vectorize width for the next loop pushed. + /// Set the vectorize width for the next loop pushed. void setVectorizeWidth(unsigned W) { StagedAttrs.VectorizeWidth = W; } - /// \brief Set the interleave count for the next loop pushed. + /// Set the interleave count for the next loop pushed. void setInterleaveCount(unsigned C) { StagedAttrs.InterleaveCount = C; } - /// \brief Set the unroll count for the next loop pushed. + /// Set the unroll count for the next loop pushed. void setUnrollCount(unsigned C) { StagedAttrs.UnrollCount = C; } private: - /// \brief Returns true if there is LoopInfo on the stack. + /// Returns true if there is LoopInfo on the stack. bool hasInfo() const { return !Active.empty(); } - /// \brief Return the LoopInfo for the current loop. HasInfo should be called + /// Return the LoopInfo for the current loop. HasInfo should be called /// first to ensure LoopInfo is present. const LoopInfo &getInfo() const { return Active.back(); } - /// \brief The set of attributes that will be applied to the next pushed loop. + /// The set of attributes that will be applied to the next pushed loop. LoopAttributes StagedAttrs; - /// \brief Stack of active loops. + /// Stack of active loops. llvm::SmallVector<LoopInfo, 4> Active; }; diff --git a/clang/lib/CodeGen/CGObjC.cpp b/clang/lib/CodeGen/CGObjC.cpp index b156737c185..81c1201c0e0 100644 --- a/clang/lib/CodeGen/CGObjC.cpp +++ b/clang/lib/CodeGen/CGObjC.cpp @@ -259,7 +259,7 @@ llvm::Value *CodeGenFunction::EmitObjCProtocolExpr(const ObjCProtocolExpr *E) { return CGM.getObjCRuntime().GenerateProtocolRef(*this, E->getProtocol()); } -/// \brief Adjust the type of an Objective-C object that doesn't match up due +/// Adjust the type of an Objective-C object that doesn't match up due /// to type erasure at various points, e.g., related result types or the use /// of parameterized classes. static RValue AdjustObjCObjectType(CodeGenFunction &CGF, QualType ExpT, @@ -803,7 +803,7 @@ PropertyImplStrategy::PropertyImplStrategy(CodeGenModule &CGM, Kind = Native; } -/// \brief Generate an Objective-C property getter function. +/// Generate an Objective-C property getter function. /// /// The given Decl must be an ObjCImplementationDecl. \@synthesize /// is illegal within a category. @@ -1336,7 +1336,7 @@ CodeGenFunction::generateObjCSetterBody(const ObjCImplementationDecl *classImpl, EmitStmt(&assign); } -/// \brief Generate an Objective-C property setter function. +/// Generate an Objective-C property setter function. /// /// The given Decl must be an ObjCImplementationDecl. \@synthesize /// is illegal within a category. diff --git a/clang/lib/CodeGen/CGObjCMac.cpp b/clang/lib/CodeGen/CGObjCMac.cpp index fa47aca57c0..0c766575dc2 100644 --- a/clang/lib/CodeGen/CGObjCMac.cpp +++ b/clang/lib/CodeGen/CGObjCMac.cpp @@ -888,7 +888,7 @@ protected: /// int * but is actually an Obj-C class pointer. llvm::WeakTrackingVH ConstantStringClassRef; - /// \brief The LLVM type corresponding to NSConstantString. + /// The LLVM type corresponding to NSConstantString. llvm::StructType *NSConstantStringType = nullptr; llvm::StringMap<llvm::GlobalVariable *> NSConstantStringMap; diff --git a/clang/lib/CodeGen/CGOpenCLRuntime.h b/clang/lib/CodeGen/CGOpenCLRuntime.h index 2df1acd2363..a513340827a 100644 --- a/clang/lib/CodeGen/CGOpenCLRuntime.h +++ b/clang/lib/CodeGen/CGOpenCLRuntime.h @@ -68,11 +68,11 @@ public: llvm::PointerType *getSamplerType(const Type *T); - // \brief Returns a value which indicates the size in bytes of the pipe + // Returns a value which indicates the size in bytes of the pipe // element. virtual llvm::Value *getPipeElemSize(const Expr *PipeArg); - // \brief Returns a value which indicates the alignment in bytes of the pipe + // Returns a value which indicates the alignment in bytes of the pipe // element. virtual llvm::Value *getPipeElemAlign(const Expr *PipeArg); @@ -83,7 +83,7 @@ public: EnqueuedBlockInfo emitOpenCLEnqueuedBlock(CodeGenFunction &CGF, const Expr *E); - /// \brief Record invoke function and block literal emitted during normal + /// Record invoke function and block literal emitted during normal /// codegen for a block expression. The information is used by /// emitOpenCLEnqueuedBlock to emit wrapper kernel. /// diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.cpp b/clang/lib/CodeGen/CGOpenMPRuntime.cpp index 5ccc77c5cfb..59c0540e89c 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntime.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntime.cpp @@ -34,20 +34,20 @@ using namespace clang; using namespace CodeGen; namespace { -/// \brief Base class for handling code generation inside OpenMP regions. +/// Base class for handling code generation inside OpenMP regions. class CGOpenMPRegionInfo : public CodeGenFunction::CGCapturedStmtInfo { public: - /// \brief Kinds of OpenMP regions used in codegen. + /// Kinds of OpenMP regions used in codegen. enum CGOpenMPRegionKind { - /// \brief Region with outlined function for standalone 'parallel' + /// Region with outlined function for standalone 'parallel' /// directive. ParallelOutlinedRegion, - /// \brief Region with outlined function for standalone 'task' directive. + /// Region with outlined function for standalone 'task' directive. TaskOutlinedRegion, - /// \brief Region for constructs that do not require function outlining, + /// Region for constructs that do not require function outlining, /// like 'for', 'sections', 'atomic' etc. directives. InlinedRegion, - /// \brief Region with outlined function for standalone 'target' directive. + /// Region with outlined function for standalone 'target' directive. TargetRegion, }; @@ -64,14 +64,14 @@ public: : CGCapturedStmtInfo(CR_OpenMP), RegionKind(RegionKind), CodeGen(CodeGen), Kind(Kind), HasCancel(HasCancel) {} - /// \brief Get a variable or parameter for storing global thread id + /// Get a variable or parameter for storing global thread id /// inside OpenMP construct. virtual const VarDecl *getThreadIDVariable() const = 0; - /// \brief Emit the captured statement body. + /// Emit the captured statement body. void EmitBody(CodeGenFunction &CGF, const Stmt *S) override; - /// \brief Get an LValue for the current ThreadID variable. + /// Get an LValue for the current ThreadID variable. /// \return LValue for thread id variable. This LValue always has type int32*. virtual LValue getThreadIDVariableLValue(CodeGenFunction &CGF); @@ -96,7 +96,7 @@ protected: bool HasCancel; }; -/// \brief API for captured statement code generation in OpenMP constructs. +/// API for captured statement code generation in OpenMP constructs. class CGOpenMPOutlinedRegionInfo final : public CGOpenMPRegionInfo { public: CGOpenMPOutlinedRegionInfo(const CapturedStmt &CS, const VarDecl *ThreadIDVar, @@ -109,11 +109,11 @@ public: assert(ThreadIDVar != nullptr && "No ThreadID in OpenMP region."); } - /// \brief Get a variable or parameter for storing global thread id + /// Get a variable or parameter for storing global thread id /// inside OpenMP construct. const VarDecl *getThreadIDVariable() const override { return ThreadIDVar; } - /// \brief Get the name of the capture helper. + /// Get the name of the capture helper. StringRef getHelperName() const override { return HelperName; } static bool classof(const CGCapturedStmtInfo *Info) { @@ -123,13 +123,13 @@ public: } private: - /// \brief A variable or parameter storing global thread id for OpenMP + /// A variable or parameter storing global thread id for OpenMP /// constructs. const VarDecl *ThreadIDVar; StringRef HelperName; }; -/// \brief API for captured statement code generation in OpenMP constructs. +/// API for captured statement code generation in OpenMP constructs. class CGOpenMPTaskOutlinedRegionInfo final : public CGOpenMPRegionInfo { public: class UntiedTaskActionTy final : public PrePostActionTy { @@ -190,14 +190,14 @@ public: assert(ThreadIDVar != nullptr && "No ThreadID in OpenMP region."); } - /// \brief Get a variable or parameter for storing global thread id + /// Get a variable or parameter for storing global thread id /// inside OpenMP construct. const VarDecl *getThreadIDVariable() const override { return ThreadIDVar; } - /// \brief Get an LValue for the current ThreadID variable. + /// Get an LValue for the current ThreadID variable. LValue getThreadIDVariableLValue(CodeGenFunction &CGF) override; - /// \brief Get the name of the capture helper. + /// Get the name of the capture helper. StringRef getHelperName() const override { return ".omp_outlined."; } void emitUntiedSwitch(CodeGenFunction &CGF) override { @@ -211,14 +211,14 @@ public: } private: - /// \brief A variable or parameter storing global thread id for OpenMP + /// A variable or parameter storing global thread id for OpenMP /// constructs. const VarDecl *ThreadIDVar; /// Action for emitting code for untied tasks. const UntiedTaskActionTy &Action; }; -/// \brief API for inlined captured statement code generation in OpenMP +/// API for inlined captured statement code generation in OpenMP /// constructs. class CGOpenMPInlinedRegionInfo : public CGOpenMPRegionInfo { public: @@ -229,7 +229,7 @@ public: OldCSI(OldCSI), OuterRegionInfo(dyn_cast_or_null<CGOpenMPRegionInfo>(OldCSI)) {} - // \brief Retrieve the value of the context parameter. + // Retrieve the value of the context parameter. llvm::Value *getContextValue() const override { if (OuterRegionInfo) return OuterRegionInfo->getContextValue(); @@ -244,7 +244,7 @@ public: llvm_unreachable("No context value for inlined OpenMP region"); } - /// \brief Lookup the captured field decl for a variable. + /// Lookup the captured field decl for a variable. const FieldDecl *lookup(const VarDecl *VD) const override { if (OuterRegionInfo) return OuterRegionInfo->lookup(VD); @@ -259,7 +259,7 @@ public: return nullptr; } - /// \brief Get a variable or parameter for storing global thread id + /// Get a variable or parameter for storing global thread id /// inside OpenMP construct. const VarDecl *getThreadIDVariable() const override { if (OuterRegionInfo) @@ -267,14 +267,14 @@ public: return nullptr; } - /// \brief Get an LValue for the current ThreadID variable. + /// Get an LValue for the current ThreadID variable. LValue getThreadIDVariableLValue(CodeGenFunction &CGF) override { if (OuterRegionInfo) return OuterRegionInfo->getThreadIDVariableLValue(CGF); llvm_unreachable("No LValue for inlined OpenMP construct"); } - /// \brief Get the name of the capture helper. + /// Get the name of the capture helper. StringRef getHelperName() const override { if (auto *OuterRegionInfo = getOldCSI()) return OuterRegionInfo->getHelperName(); @@ -296,12 +296,12 @@ public: ~CGOpenMPInlinedRegionInfo() override = default; private: - /// \brief CodeGen info about outer OpenMP region. + /// CodeGen info about outer OpenMP region. CodeGenFunction::CGCapturedStmtInfo *OldCSI; CGOpenMPRegionInfo *OuterRegionInfo; }; -/// \brief API for captured statement code generation in OpenMP target +/// API for captured statement code generation in OpenMP target /// constructs. For this captures, implicit parameters are used instead of the /// captured fields. The name of the target region has to be unique in a given /// application so it is provided by the client, because only the client has @@ -314,11 +314,11 @@ public: /*HasCancel=*/false), HelperName(HelperName) {} - /// \brief This is unused for target regions because each starts executing + /// This is unused for target regions because each starts executing /// with a single thread. const VarDecl *getThreadIDVariable() const override { return nullptr; } - /// \brief Get the name of the capture helper. + /// Get the name of the capture helper. StringRef getHelperName() const override { return HelperName; } static bool classof(const CGCapturedStmtInfo *Info) { @@ -333,7 +333,7 @@ private: static void EmptyCodeGen(CodeGenFunction &, PrePostActionTy &) { llvm_unreachable("No codegen for expressions"); } -/// \brief API for generation of expressions captured in a innermost OpenMP +/// API for generation of expressions captured in a innermost OpenMP /// region. class CGOpenMPInnerExprInfo final : public CGOpenMPInlinedRegionInfo { public: @@ -363,25 +363,25 @@ public: (void)PrivScope.Privatize(); } - /// \brief Lookup the captured field decl for a variable. + /// Lookup the captured field decl for a variable. const FieldDecl *lookup(const VarDecl *VD) const override { if (const FieldDecl *FD = CGOpenMPInlinedRegionInfo::lookup(VD)) return FD; return nullptr; } - /// \brief Emit the captured statement body. + /// Emit the captured statement body. void EmitBody(CodeGenFunction &CGF, const Stmt *S) override { llvm_unreachable("No body for expressions"); } - /// \brief Get a variable or parameter for storing global thread id + /// Get a variable or parameter for storing global thread id /// inside OpenMP construct. const VarDecl *getThreadIDVariable() const override { llvm_unreachable("No thread id for expressions"); } - /// \brief Get the name of the capture helper. + /// Get the name of the capture helper. StringRef getHelperName() const override { llvm_unreachable("No helper name for expressions"); } @@ -393,7 +393,7 @@ private: CodeGenFunction::OMPPrivateScope PrivScope; }; -/// \brief RAII for emitting code of OpenMP constructs. +/// RAII for emitting code of OpenMP constructs. class InlinedOpenMPRegionRAII { CodeGenFunction &CGF; llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields; @@ -401,7 +401,7 @@ class InlinedOpenMPRegionRAII { const CodeGen::CGBlockInfo *BlockInfo = nullptr; public: - /// \brief Constructs region for combined constructs. + /// Constructs region for combined constructs. /// \param CodeGen Code generation sequence for combined directives. Includes /// a list of functions used for code generation of implicitly inlined /// regions. @@ -430,25 +430,25 @@ public: } }; -/// \brief Values for bit flags used in the ident_t to describe the fields. +/// Values for bit flags used in the ident_t to describe the fields. /// All enumeric elements are named and described in accordance with the code /// from http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h enum OpenMPLocationFlags : unsigned { - /// \brief Use trampoline for internal microtask. + /// Use trampoline for internal microtask. OMP_IDENT_IMD = 0x01, - /// \brief Use c-style ident structure. + /// Use c-style ident structure. OMP_IDENT_KMPC = 0x02, - /// \brief Atomic reduction option for kmpc_reduce. + /// Atomic reduction option for kmpc_reduce. OMP_ATOMIC_REDUCE = 0x10, - /// \brief Explicit 'barrier' directive. + /// Explicit 'barrier' directive. OMP_IDENT_BARRIER_EXPL = 0x20, - /// \brief Implicit barrier in code. + /// Implicit barrier in code. OMP_IDENT_BARRIER_IMPL = 0x40, - /// \brief Implicit barrier in 'for' directive. + /// Implicit barrier in 'for' directive. OMP_IDENT_BARRIER_IMPL_FOR = 0x40, - /// \brief Implicit barrier in 'sections' directive. + /// Implicit barrier in 'sections' directive. OMP_IDENT_BARRIER_IMPL_SECTIONS = 0xC0, - /// \brief Implicit barrier in 'single' directive. + /// Implicit barrier in 'single' directive. OMP_IDENT_BARRIER_IMPL_SINGLE = 0x140, /// Call of __kmp_for_static_init for static loop. OMP_IDENT_WORK_LOOP = 0x200, @@ -459,7 +459,7 @@ enum OpenMPLocationFlags : unsigned { LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/OMP_IDENT_WORK_DISTRIBUTE) }; -/// \brief Describes ident structure that describes a source location. +/// Describes ident structure that describes a source location. /// All descriptions are taken from /// http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h /// Original structure: @@ -486,24 +486,24 @@ enum OpenMPLocationFlags : unsigned { /// */ /// } ident_t; enum IdentFieldIndex { - /// \brief might be used in Fortran + /// might be used in Fortran IdentField_Reserved_1, - /// \brief OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member. + /// OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member. IdentField_Flags, - /// \brief Not really used in Fortran any more + /// Not really used in Fortran any more IdentField_Reserved_2, - /// \brief Source[4] in Fortran, do not use for C++ + /// Source[4] in Fortran, do not use for C++ IdentField_Reserved_3, - /// \brief String describing the source location. The string is composed of + /// String describing the source location. The string is composed of /// semi-colon separated fields which describe the source file, the function /// and a pair of line numbers that delimit the construct. IdentField_PSource }; -/// \brief Schedule types for 'omp for' loops (these enumerators are taken from +/// Schedule types for 'omp for' loops (these enumerators are taken from /// the enum sched_type in kmp.h). enum OpenMPSchedType { - /// \brief Lower bound for default (unordered) versions. + /// Lower bound for default (unordered) versions. OMP_sch_lower = 32, OMP_sch_static_chunked = 33, OMP_sch_static = 34, @@ -513,7 +513,7 @@ enum OpenMPSchedType { OMP_sch_auto = 38, /// static with chunk adjustment (e.g., simd) OMP_sch_static_balanced_chunked = 45, - /// \brief Lower bound for 'ordered' versions. + /// Lower bound for 'ordered' versions. OMP_ord_lower = 64, OMP_ord_static_chunked = 65, OMP_ord_static = 66, @@ -522,7 +522,7 @@ enum OpenMPSchedType { OMP_ord_runtime = 69, OMP_ord_auto = 70, OMP_sch_default = OMP_sch_static, - /// \brief dist_schedule types + /// dist_schedule types OMP_dist_sch_static_chunked = 91, OMP_dist_sch_static = 92, /// Support for OpenMP 4.5 monotonic and nonmonotonic schedule modifiers. @@ -533,13 +533,13 @@ enum OpenMPSchedType { }; enum OpenMPRTLFunction { - /// \brief Call to void __kmpc_fork_call(ident_t *loc, kmp_int32 argc, + /// Call to void __kmpc_fork_call(ident_t *loc, kmp_int32 argc, /// kmpc_micro microtask, ...); OMPRTL__kmpc_fork_call, - /// \brief Call to void *__kmpc_threadprivate_cached(ident_t *loc, + /// Call to void *__kmpc_threadprivate_cached(ident_t *loc, /// kmp_int32 global_tid, void *data, size_t size, void ***cache); OMPRTL__kmpc_threadprivate_cached, - /// \brief Call to void __kmpc_threadprivate_register( ident_t *, + /// Call to void __kmpc_threadprivate_register( ident_t *, /// void *data, kmpc_ctor ctor, kmpc_cctor cctor, kmpc_dtor dtor); OMPRTL__kmpc_threadprivate_register, // Call to __kmpc_int32 kmpc_global_thread_num(ident_t *loc); @@ -808,7 +808,7 @@ static void emitInitWithReductionInitializer(CodeGenFunction &CGF, } } -/// \brief Emit initialization of arrays of complex types. +/// Emit initialization of arrays of complex types. /// \param DestAddr Address of the array. /// \param Type Type of array. /// \param Init Initial expression of array. @@ -2608,7 +2608,7 @@ llvm::Function *CGOpenMPRuntime::emitThreadPrivateVarDefinition( return nullptr; } -/// \brief Obtain information that uniquely identifies a target entry. This +/// Obtain information that uniquely identifies a target entry. This /// consists of the file and device IDs as well as line number associated with /// the relevant entry source location. static void getTargetEntryUniqueInfo(ASTContext &C, SourceLocation Loc, @@ -3242,7 +3242,7 @@ void CGOpenMPRuntime::emitBarrierCall(CodeGenFunction &CGF, SourceLocation Loc, CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_barrier), Args); } -/// \brief Map the OpenMP loop schedule to the runtime enumeration. +/// Map the OpenMP loop schedule to the runtime enumeration. static OpenMPSchedType getRuntimeSchedule(OpenMPScheduleClauseKind ScheduleKind, bool Chunked, bool Ordered) { switch (ScheduleKind) { @@ -3264,7 +3264,7 @@ static OpenMPSchedType getRuntimeSchedule(OpenMPScheduleClauseKind ScheduleKind, llvm_unreachable("Unexpected runtime schedule"); } -/// \brief Map the OpenMP distribute schedule to the runtime enumeration. +/// Map the OpenMP distribute schedule to the runtime enumeration. static OpenMPSchedType getRuntimeSchedule(OpenMPDistScheduleClauseKind ScheduleKind, bool Chunked) { // only static is allowed for dist_schedule @@ -3557,13 +3557,13 @@ void CGOpenMPRuntime::emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *>, } namespace { -/// \brief Indexes of fields for type kmp_task_t. +/// Indexes of fields for type kmp_task_t. enum KmpTaskTFields { - /// \brief List of shared variables. + /// List of shared variables. KmpTaskTShareds, - /// \brief Task routine. + /// Task routine. KmpTaskTRoutine, - /// \brief Partition id for the untied tasks. + /// Partition id for the untied tasks. KmpTaskTPartId, /// Function with call of destructors for private variables. Data1, @@ -3587,7 +3587,7 @@ bool CGOpenMPRuntime::OffloadEntriesInfoManagerTy::empty() const { OffloadEntriesDeviceGlobalVar.empty(); } -/// \brief Initialize target region entry. +/// Initialize target region entry. void CGOpenMPRuntime::OffloadEntriesInfoManagerTy:: initializeTargetRegionEntryInfo(unsigned DeviceID, unsigned FileID, StringRef ParentName, unsigned LineNum, @@ -3994,7 +3994,7 @@ void CGOpenMPRuntime::createOffloadEntriesAndInfoMetadata() { } } -/// \brief Loads all the offload entries information from the host IR +/// Loads all the offload entries information from the host IR /// metadata. void CGOpenMPRuntime::loadOffloadInfoMetadata() { // If we are in target mode, load the metadata from the host IR. This code has @@ -4257,7 +4257,7 @@ createKmpTaskTWithPrivatesRecordDecl(CodeGenModule &CGM, QualType KmpTaskTQTy, return RD; } -/// \brief Emit a proxy function which accepts kmp_task_t as the second +/// Emit a proxy function which accepts kmp_task_t as the second /// argument. /// \code /// kmp_int32 .omp_task_entry.(kmp_int32 gtid, kmp_task_t *tt) { @@ -4421,7 +4421,7 @@ static llvm::Value *emitDestructorsFunction(CodeGenModule &CGM, return DestructorFn; } -/// \brief Emit a privates mapping function for correct handling of private and +/// Emit a privates mapping function for correct handling of private and /// firstprivate variables. /// \code /// void .omp_task_privates_map.(const .privates. *noalias privs, <ty1> @@ -5214,7 +5214,7 @@ void CGOpenMPRuntime::emitTaskLoopCall(CodeGenFunction &CGF, SourceLocation Loc, CGF.EmitRuntimeCall(createRuntimeFunction(OMPRTL__kmpc_taskloop), TaskArgs); } -/// \brief Emit reduction operation for each element of array (required for +/// Emit reduction operation for each element of array (required for /// array sections) LHS op = RHS. /// \param Type Type of array. /// \param LHSVar Variable on the left side of the reduction operation @@ -6477,39 +6477,39 @@ emitNumThreadsForTargetDirective(CGOpenMPRuntime &OMPRuntime, } namespace { -// \brief Utility to handle information from clauses associated with a given +// Utility to handle information from clauses associated with a given // construct that use mappable expressions (e.g. 'map' clause, 'to' clause). // It provides a convenient interface to obtain the information and generate // code for that information. class MappableExprsHandler { public: - /// \brief Values for bit flags used to specify the mapping type for + /// Values for bit flags used to specify the mapping type for /// offloading. enum OpenMPOffloadMappingFlags { - /// \brief Allocate memory on the device and move data from host to device. + /// Allocate memory on the device and move data from host to device. OMP_MAP_TO = 0x01, - /// \brief Allocate memory on the device and move data from device to host. + /// Allocate memory on the device and move data from device to host. OMP_MAP_FROM = 0x02, - /// \brief Always perform the requested mapping action on the element, even + /// Always perform the requested mapping action on the element, even /// if it was already mapped before. OMP_MAP_ALWAYS = 0x04, - /// \brief Delete the element from the device environment, ignoring the + /// Delete the element from the device environment, ignoring the /// current reference count associated with the element. OMP_MAP_DELETE = 0x08, - /// \brief The element being mapped is a pointer-pointee pair; both the + /// The element being mapped is a pointer-pointee pair; both the /// pointer and the pointee should be mapped. OMP_MAP_PTR_AND_OBJ = 0x10, - /// \brief This flags signals that the base address of an entry should be + /// This flags signals that the base address of an entry should be /// passed to the target kernel as an argument. OMP_MAP_TARGET_PARAM = 0x20, - /// \brief Signal that the runtime library has to return the device pointer + /// Signal that the runtime library has to return the device pointer /// in the current position for the data being mapped. Used when we have the /// use_device_ptr clause. OMP_MAP_RETURN_PARAM = 0x40, - /// \brief This flag signals that the reference being passed is a pointer to + /// This flag signals that the reference being passed is a pointer to /// private data. OMP_MAP_PRIVATE = 0x80, - /// \brief Pass the element to the device by value. + /// Pass the element to the device by value. OMP_MAP_LITERAL = 0x100, /// Implicit map OMP_MAP_IMPLICIT = 0x200, @@ -6537,13 +6537,13 @@ public: typedef SmallVector<uint64_t, 16> MapFlagsArrayTy; private: - /// \brief Directive from where the map clauses were extracted. + /// Directive from where the map clauses were extracted. const OMPExecutableDirective &CurDir; - /// \brief Function the directive is being generated for. + /// Function the directive is being generated for. CodeGenFunction &CGF; - /// \brief Set of all first private variables in the current directive. + /// Set of all first private variables in the current directive. llvm::SmallPtrSet<const VarDecl *, 8> FirstPrivateDecls; /// Set of all reduction variables in the current directive. llvm::SmallPtrSet<const VarDecl *, 8> ReductionDecls; @@ -6597,7 +6597,7 @@ private: return CGF.getTypeSize(ExprTy); } - /// \brief Return the corresponding bits for a given map clause modifier. Add + /// Return the corresponding bits for a given map clause modifier. Add /// a flag marking the map as a pointer if requested. Add a flag marking the /// map as the first one of a series of maps that relate to the same map /// expression. @@ -6638,7 +6638,7 @@ private: return Bits; } - /// \brief Return true if the provided expression is a final array section. A + /// Return true if the provided expression is a final array section. A /// final array section, is one whose length can't be proved to be one. bool isFinalArraySectionExpression(const Expr *E) const { const auto *OASE = dyn_cast<OMPArraySectionExpr>(E); @@ -6676,7 +6676,7 @@ private: return ConstLength.getSExtValue() != 1; } - /// \brief Return the adjusted map modifiers if the declaration a capture + /// Return the adjusted map modifiers if the declaration a capture /// refers to appears in a first-private clause. This is expected to be used /// only with directives that start with 'target'. unsigned adjustMapModifiersForPrivateClauses(const CapturedStmt::Capture &Cap, @@ -6720,7 +6720,7 @@ public: DevPointersMap[L.first].push_back(L.second); } - /// \brief Generate the base pointers, section pointers, sizes and map type + /// Generate the base pointers, section pointers, sizes and map type /// bits for the provided map type, map modifier, and expression components. /// \a IsFirstComponent should be set to true if the provided set of /// components is the first associated with a capture. @@ -6982,7 +6982,7 @@ public: } } - /// \brief Generate all the base pointers, section pointers, sizes and map + /// Generate all the base pointers, section pointers, sizes and map /// types for the extracted mappable expressions. Also, for each item that /// relates with a device pointer, a pair of the relevant declaration and /// index where it occurs is appended to the device pointers info array. @@ -7146,7 +7146,7 @@ public: } } - /// \brief Generate the base pointers, section pointers, sizes and map types + /// Generate the base pointers, section pointers, sizes and map types /// associated to a given capture. void generateInfoForCapture(const CapturedStmt::Capture *Cap, llvm::Value *Arg, @@ -7212,7 +7212,7 @@ public: return; } - /// \brief Generate the default map information for a given capture \a CI, + /// Generate the default map information for a given capture \a CI, /// record field declaration \a RI and captured value \a CV. void generateDefaultMapInfo(const CapturedStmt::Capture &CI, const FieldDecl &RI, llvm::Value *CV, @@ -7264,13 +7264,13 @@ public: }; enum OpenMPOffloadingReservedDeviceIDs { - /// \brief Device ID if the device was not defined, runtime should get it + /// Device ID if the device was not defined, runtime should get it /// from environment variables in the spec. OMP_DEVICEID_UNDEF = -1, }; } // anonymous namespace -/// \brief Emit the arrays used to pass the captures and map information to the +/// Emit the arrays used to pass the captures and map information to the /// offloading runtime library. If there is no map or capture information, /// return nullptr by reference. static void @@ -7384,7 +7384,7 @@ emitOffloadingArrays(CodeGenFunction &CGF, } } } -/// \brief Emit the arguments to be passed to the runtime library based on the +/// Emit the arguments to be passed to the runtime library based on the /// arrays of pointers, sizes and map types. static void emitOffloadingArraysArgument( CodeGenFunction &CGF, llvm::Value *&BasePointersArrayArg, diff --git a/clang/lib/CodeGen/CGOpenMPRuntime.h b/clang/lib/CodeGen/CGOpenMPRuntime.h index 4546da4746f..599b3ba01fb 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntime.h +++ b/clang/lib/CodeGen/CGOpenMPRuntime.h @@ -219,13 +219,13 @@ protected: explicit CGOpenMPRuntime(CodeGenModule &CGM, StringRef FirstSeparator, StringRef Separator); - /// \brief Creates offloading entry for the provided entry ID \a ID, + /// Creates offloading entry for the provided entry ID \a ID, /// address \a Addr, size \a Size, and flags \a Flags. virtual void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr, uint64_t Size, int32_t Flags, llvm::GlobalValue::LinkageTypes Linkage); - /// \brief Helper to emit outlined function for 'target' directive. + /// Helper to emit outlined function for 'target' directive. /// \param D Directive to emit. /// \param ParentName Name of the function that encloses the target region. /// \param OutlinedFn Outlined function value to be defined by this call. @@ -241,7 +241,7 @@ protected: bool IsOffloadEntry, const RegionCodeGenTy &CodeGen); - /// \brief Emits code for OpenMP 'if' clause using specified \a CodeGen + /// Emits code for OpenMP 'if' clause using specified \a CodeGen /// function. Here is the logic: /// if (Cond) { /// ThenGen(); @@ -252,20 +252,20 @@ protected: const RegionCodeGenTy &ThenGen, const RegionCodeGenTy &ElseGen); - /// \brief Emits object of ident_t type with info for source location. + /// Emits object of ident_t type with info for source location. /// \param Flags Flags for OpenMP location. /// llvm::Value *emitUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc, unsigned Flags = 0); - /// \brief Returns pointer to ident_t type. + /// Returns pointer to ident_t type. llvm::Type *getIdentTyPointerTy(); - /// \brief Gets thread id value for the current thread. + /// Gets thread id value for the current thread. /// llvm::Value *getThreadID(CodeGenFunction &CGF, SourceLocation Loc); - /// \brief Get the function name of an outlined region. + /// Get the function name of an outlined region. // The name can be customized depending on the target. // virtual StringRef getOutlinedHelperName() const { return ".omp_outlined."; } @@ -274,34 +274,34 @@ protected: void emitCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *Callee, ArrayRef<llvm::Value *> Args = llvm::None) const; - /// \brief Emits address of the word in a memory where current thread id is + /// Emits address of the word in a memory where current thread id is /// stored. virtual Address emitThreadIDAddress(CodeGenFunction &CGF, SourceLocation Loc); private: - /// \brief Default const ident_t object used for initialization of all other + /// Default const ident_t object used for initialization of all other /// ident_t objects. llvm::Constant *DefaultOpenMPPSource = nullptr; - /// \brief Map of flags and corresponding default locations. + /// Map of flags and corresponding default locations. typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy; OpenMPDefaultLocMapTy OpenMPDefaultLocMap; Address getOrCreateDefaultLocation(unsigned Flags); QualType IdentQTy; llvm::StructType *IdentTy = nullptr; - /// \brief Map for SourceLocation and OpenMP runtime library debug locations. + /// Map for SourceLocation and OpenMP runtime library debug locations. typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy; OpenMPDebugLocMapTy OpenMPDebugLocMap; - /// \brief The type for a microtask which gets passed to __kmpc_fork_call(). + /// The type for a microtask which gets passed to __kmpc_fork_call(). /// Original representation is: /// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...); llvm::FunctionType *Kmpc_MicroTy = nullptr; - /// \brief Stores debug location and ThreadID for the function. + /// Stores debug location and ThreadID for the function. struct DebugLocThreadIdTy { llvm::Value *DebugLoc; llvm::Value *ThreadID; }; - /// \brief Map of local debug location, ThreadId and functions. + /// Map of local debug location, ThreadId and functions. typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy> OpenMPLocThreadIDMapTy; OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap; @@ -319,20 +319,20 @@ private: IdentifierInfo *Out = nullptr; IdentifierInfo *Priv = nullptr; IdentifierInfo *Orig = nullptr; - /// \brief Type kmp_critical_name, originally defined as typedef kmp_int32 + /// Type kmp_critical_name, originally defined as typedef kmp_int32 /// kmp_critical_name[8]; llvm::ArrayType *KmpCriticalNameTy; - /// \brief An ordered map of auto-generated variables to their unique names. + /// An ordered map of auto-generated variables to their unique names. /// It stores variables with the following names: 1) ".gomp_critical_user_" + /// <critical_section_name> + ".var" for "omp critical" directives; 2) /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate /// variables. llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator> InternalVars; - /// \brief Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *); + /// Type typedef kmp_int32 (* kmp_routine_entry_t)(kmp_int32, void *); llvm::Type *KmpRoutineEntryPtrTy = nullptr; QualType KmpRoutineEntryPtrQTy; - /// \brief Type typedef struct kmp_task { + /// Type typedef struct kmp_task { /// void * shareds; /**< pointer to block of pointers to /// shared vars */ /// kmp_routine_entry_t routine; /**< pointer to routine to call for @@ -346,7 +346,7 @@ private: QualType SavedKmpTaskTQTy; /// Saved kmp_task_t for taskloop-based directive. QualType SavedKmpTaskloopTQTy; - /// \brief Type typedef struct kmp_depend_info { + /// Type typedef struct kmp_depend_info { /// kmp_intptr_t base_addr; /// size_t len; /// struct { @@ -361,7 +361,7 @@ private: /// kmp_int64 st; // stride /// }; QualType KmpDimTy; - /// \brief Type struct __tgt_offload_entry{ + /// Type struct __tgt_offload_entry{ /// void *addr; // Pointer to the offload entry info. /// // (function or global) /// char *name; // Name of the function or global. @@ -389,12 +389,12 @@ private: /// // entries (non inclusive). /// }; QualType TgtBinaryDescriptorQTy; - /// \brief Entity that registers the offloading constants that were emitted so + /// Entity that registers the offloading constants that were emitted so /// far. class OffloadEntriesInfoManagerTy { CodeGenModule &CGM; - /// \brief Number of entries registered so far. + /// Number of entries registered so far. unsigned OffloadingEntriesNum = 0; public: @@ -600,68 +600,68 @@ private: bool ShouldMarkAsGlobal = true; llvm::SmallDenseSet<const FunctionDecl *> AlreadyEmittedTargetFunctions; - /// \brief Creates and registers offloading binary descriptor for the current + /// Creates and registers offloading binary descriptor for the current /// compilation unit. The function that does the registration is returned. llvm::Function *createOffloadingBinaryDescriptorRegistration(); - /// \brief Creates all the offload entries in the current compilation unit + /// Creates all the offload entries in the current compilation unit /// along with the associated metadata. void createOffloadEntriesAndInfoMetadata(); - /// \brief Loads all the offload entries information from the host IR + /// Loads all the offload entries information from the host IR /// metadata. void loadOffloadInfoMetadata(); - /// \brief Returns __tgt_offload_entry type. + /// Returns __tgt_offload_entry type. QualType getTgtOffloadEntryQTy(); - /// \brief Returns __tgt_device_image type. + /// Returns __tgt_device_image type. QualType getTgtDeviceImageQTy(); - /// \brief Returns __tgt_bin_desc type. + /// Returns __tgt_bin_desc type. QualType getTgtBinaryDescriptorQTy(); - /// \brief Start scanning from statement \a S and and emit all target regions + /// Start scanning from statement \a S and and emit all target regions /// found along the way. /// \param S Starting statement. /// \param ParentName Name of the function declaration that is being scanned. void scanForTargetRegionsFunctions(const Stmt *S, StringRef ParentName); - /// \brief Build type kmp_routine_entry_t (if not built yet). + /// Build type kmp_routine_entry_t (if not built yet). void emitKmpRoutineEntryT(QualType KmpInt32Ty); - /// \brief Returns pointer to kmpc_micro type. + /// Returns pointer to kmpc_micro type. llvm::Type *getKmpc_MicroPointerTy(); - /// \brief Returns specified OpenMP runtime function. + /// Returns specified OpenMP runtime function. /// \param Function OpenMP runtime function. /// \return Specified function. llvm::Constant *createRuntimeFunction(unsigned Function); - /// \brief Returns __kmpc_for_static_init_* runtime function for the specified + /// Returns __kmpc_for_static_init_* runtime function for the specified /// size \a IVSize and sign \a IVSigned. llvm::Constant *createForStaticInitFunction(unsigned IVSize, bool IVSigned); - /// \brief Returns __kmpc_dispatch_init_* runtime function for the specified + /// Returns __kmpc_dispatch_init_* runtime function for the specified /// size \a IVSize and sign \a IVSigned. llvm::Constant *createDispatchInitFunction(unsigned IVSize, bool IVSigned); - /// \brief Returns __kmpc_dispatch_next_* runtime function for the specified + /// Returns __kmpc_dispatch_next_* runtime function for the specified /// size \a IVSize and sign \a IVSigned. llvm::Constant *createDispatchNextFunction(unsigned IVSize, bool IVSigned); - /// \brief Returns __kmpc_dispatch_fini_* runtime function for the specified + /// Returns __kmpc_dispatch_fini_* runtime function for the specified /// size \a IVSize and sign \a IVSigned. llvm::Constant *createDispatchFiniFunction(unsigned IVSize, bool IVSigned); - /// \brief If the specified mangled name is not in the module, create and + /// If the specified mangled name is not in the module, create and /// return threadprivate cache object. This object is a pointer's worth of /// storage that's reserved for use by the OpenMP runtime. /// \param VD Threadprivate variable. /// \return Cache variable for the specified threadprivate. llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD); - /// \brief Gets (if variable with the given name already exist) or creates + /// Gets (if variable with the given name already exist) or creates /// internal global variable with the specified Name. The created variable has /// linkage CommonLinkage by default and is initialized by null value. /// \param Ty Type of the global variable. If it is exist already the type @@ -670,13 +670,13 @@ private: llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty, const llvm::Twine &Name); - /// \brief Set of threadprivate variables with the generated initializer. + /// Set of threadprivate variables with the generated initializer. llvm::SmallPtrSet<const VarDecl *, 4> ThreadPrivateWithDefinition; /// Set of declare target variables with the generated initializer. llvm::SmallPtrSet<const VarDecl *, 4> DeclareTargetWithDefinition; - /// \brief Emits initialization code for the threadprivate variables. + /// Emits initialization code for the threadprivate variables. /// \param VDAddr Address of the global variable \a VD. /// \param Ctor Pointer to a global init function for \a VD. /// \param CopyCtor Pointer to a global copy function for \a VD. @@ -686,7 +686,7 @@ private: llvm::Value *Ctor, llvm::Value *CopyCtor, llvm::Value *Dtor, SourceLocation Loc); - /// \brief Returns corresponding lock object for the specified critical region + /// Returns corresponding lock object for the specified critical region /// name. If the lock object does not exist it is created, otherwise the /// reference to the existing copy is returned. /// \param CriticalName Name of the critical region. @@ -744,7 +744,7 @@ public: virtual std::pair<llvm::Function *, llvm::Function *> getUserDefinedReduction(const OMPDeclareReductionDecl *D); - /// \brief Emits outlined function for the specified OpenMP parallel directive + /// Emits outlined function for the specified OpenMP parallel directive /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, /// kmp_int32 BoundID, struct context_vars*). /// \param D OpenMP directive. @@ -756,7 +756,7 @@ public: const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); - /// \brief Emits outlined function for the specified OpenMP teams directive + /// Emits outlined function for the specified OpenMP teams directive /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, /// kmp_int32 BoundID, struct context_vars*). /// \param D OpenMP directive. @@ -768,7 +768,7 @@ public: const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen); - /// \brief Emits outlined function for the OpenMP task directive \a D. This + /// Emits outlined function for the OpenMP task directive \a D. This /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t* /// TaskT). /// \param D OpenMP directive. @@ -789,11 +789,11 @@ public: OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts); - /// \brief Cleans up references to the objects in finished function. + /// Cleans up references to the objects in finished function. /// virtual void functionFinished(CodeGenFunction &CGF); - /// \brief Emits code for parallel or serial call of the \a OutlinedFn with + /// Emits code for parallel or serial call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// \param OutlinedFn Outlined function to be run in parallel threads. Type of @@ -808,7 +808,7 @@ public: ArrayRef<llvm::Value *> CapturedVars, const Expr *IfCond); - /// \brief Emits a critical region. + /// Emits a critical region. /// \param CriticalName Name of the critical region. /// \param CriticalOpGen Generator for the statement associated with the given /// critical region. @@ -818,24 +818,24 @@ public: SourceLocation Loc, const Expr *Hint = nullptr); - /// \brief Emits a master region. + /// Emits a master region. /// \param MasterOpGen Generator for the statement associated with the given /// master region. virtual void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc); - /// \brief Emits code for a taskyield directive. + /// Emits code for a taskyield directive. virtual void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc); - /// \brief Emit a taskgroup region. + /// Emit a taskgroup region. /// \param TaskgroupOpGen Generator for the statement associated with the /// given taskgroup region. virtual void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc); - /// \brief Emits a single region. + /// Emits a single region. /// \param SingleOpGen Generator for the statement associated with the given /// single region. virtual void emitSingleRegion(CodeGenFunction &CGF, @@ -846,14 +846,14 @@ public: ArrayRef<const Expr *> SrcExprs, ArrayRef<const Expr *> AssignmentOps); - /// \brief Emit an ordered region. + /// Emit an ordered region. /// \param OrderedOpGen Generator for the statement associated with the given /// ordered region. virtual void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads); - /// \brief Emit an implicit/explicit barrier for OpenMP threads. + /// Emit an implicit/explicit barrier for OpenMP threads. /// \param Kind Directive for which this implicit barrier call must be /// generated. Must be OMPD_barrier for explicit barrier generation. /// \param EmitChecks true if need to emit checks for cancellation barriers. @@ -866,7 +866,7 @@ public: bool EmitChecks = true, bool ForceSimpleCall = false); - /// \brief Check if the specified \a ScheduleKind is static non-chunked. + /// Check if the specified \a ScheduleKind is static non-chunked. /// This kind of worksharing directive is emitted without outer loop. /// \param ScheduleKind Schedule kind specified in the 'schedule' clause. /// \param Chunked True if chunk is specified in the clause. @@ -874,7 +874,7 @@ public: virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind, bool Chunked) const; - /// \brief Check if the specified \a ScheduleKind is static non-chunked. + /// Check if the specified \a ScheduleKind is static non-chunked. /// This kind of distribute directive is emitted without outer loop. /// \param ScheduleKind Schedule kind specified in the 'dist_schedule' clause. /// \param Chunked True if chunk is specified in the clause. @@ -882,7 +882,7 @@ public: virtual bool isStaticNonchunked(OpenMPDistScheduleClauseKind ScheduleKind, bool Chunked) const; - /// \brief Check if the specified \a ScheduleKind is dynamic. + /// Check if the specified \a ScheduleKind is dynamic. /// This kind of worksharing directive is emitted without outer loop. /// \param ScheduleKind Schedule Kind specified in the 'schedule' clause. /// @@ -955,7 +955,7 @@ public: : IVSize(IVSize), IVSigned(IVSigned), Ordered(Ordered), IL(IL), LB(LB), UB(UB), ST(ST), Chunk(Chunk) {} }; - /// \brief Call the appropriate runtime routine to initialize it before start + /// Call the appropriate runtime routine to initialize it before start /// of loop. /// /// This is used only in case of static schedule, when the user did not @@ -986,7 +986,7 @@ public: OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values); - /// \brief Call the appropriate runtime routine to notify that we finished + /// Call the appropriate runtime routine to notify that we finished /// iteration of the ordered loop with the dynamic scheduling. /// /// \param CGF Reference to current CodeGenFunction. @@ -998,7 +998,7 @@ public: SourceLocation Loc, unsigned IVSize, bool IVSigned); - /// \brief Call the appropriate runtime routine to notify that we finished + /// Call the appropriate runtime routine to notify that we finished /// all the work with current loop. /// /// \param CGF Reference to current CodeGenFunction. @@ -1027,7 +1027,7 @@ public: Address IL, Address LB, Address UB, Address ST); - /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 + /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads' /// clause. /// \param NumThreads An integer value of threads. @@ -1035,13 +1035,13 @@ public: llvm::Value *NumThreads, SourceLocation Loc); - /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 + /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause. virtual void emitProcBindClause(CodeGenFunction &CGF, OpenMPProcBindClauseKind ProcBind, SourceLocation Loc); - /// \brief Returns address of the threadprivate variable for the current + /// Returns address of the threadprivate variable for the current /// thread. /// \param VD Threadprivate variable. /// \param VDAddr Address of the global variable \a VD. @@ -1056,7 +1056,7 @@ public: /// clause. virtual Address getAddrOfDeclareTargetLink(const VarDecl *VD); - /// \brief Emit a code for initialization of threadprivate variable. It emits + /// Emit a code for initialization of threadprivate variable. It emits /// a call to runtime library which adds initial value to the newly created /// threadprivate variable (if it is not constant) and registers destructor /// for the variable (if any). @@ -1069,7 +1069,7 @@ public: SourceLocation Loc, bool PerformInit, CodeGenFunction *CGF = nullptr); - /// \brief Emit a code for initialization of declare target variable. + /// Emit a code for initialization of declare target variable. /// \param VD Declare target variable. /// \param Addr Address of the global variable \a VD. /// \param PerformInit true if initialization expression is not constant. @@ -1085,12 +1085,12 @@ public: QualType VarType, StringRef Name); - /// \brief Emit flush of the variables specified in 'omp flush' directive. + /// Emit flush of the variables specified in 'omp flush' directive. /// \param Vars List of variables to flush. virtual void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars, SourceLocation Loc); - /// \brief Emit task region for the task directive. The task region is + /// Emit task region for the task directive. The task region is /// emitted in several steps: /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, @@ -1157,7 +1157,7 @@ public: llvm::Value *TaskFunction, QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data); - /// \brief Emit code for the directive that does not require outlining. + /// Emit code for the directive that does not require outlining. /// /// \param InnermostKind Kind of innermost directive (for simple directives it /// is a directive itself, for combined - its innermost directive). @@ -1195,7 +1195,7 @@ public: bool SimpleReduction; OpenMPDirectiveKind ReductionKind; }; - /// \brief Emit a code for reduction clause. Next code should be emitted for + /// Emit a code for reduction clause. Next code should be emitted for /// reduction: /// \code /// @@ -1289,10 +1289,10 @@ public: llvm::Value *ReductionsPtr, LValue SharedLVal); - /// \brief Emit code for 'taskwait' directive. + /// Emit code for 'taskwait' directive. virtual void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc); - /// \brief Emit code for 'cancellation point' construct. + /// Emit code for 'cancellation point' construct. /// \param CancelRegion Region kind for which the cancellation point must be /// emitted. /// @@ -1300,7 +1300,7 @@ public: SourceLocation Loc, OpenMPDirectiveKind CancelRegion); - /// \brief Emit code for 'cancel' construct. + /// Emit code for 'cancel' construct. /// \param IfCond Condition in the associated 'if' clause, if it was /// specified, nullptr otherwise. /// \param CancelRegion Region kind for which the cancel must be emitted. @@ -1309,7 +1309,7 @@ public: const Expr *IfCond, OpenMPDirectiveKind CancelRegion); - /// \brief Emit outilined function for 'target' directive. + /// Emit outilined function for 'target' directive. /// \param D Directive to emit. /// \param ParentName Name of the function that encloses the target region. /// \param OutlinedFn Outlined function value to be defined by this call. @@ -1325,7 +1325,7 @@ public: bool IsOffloadEntry, const RegionCodeGenTy &CodeGen); - /// \brief Emit the target offloading code associated with \a D. The emitted + /// Emit the target offloading code associated with \a D. The emitted /// code attempts offloading the execution to the device, an the event of /// a failure it executes the host version outlined in \a OutlinedFn. /// \param D Directive to emit. @@ -1341,13 +1341,13 @@ public: llvm::Value *OutlinedFnID, const Expr *IfCond, const Expr *Device); - /// \brief Emit the target regions enclosed in \a GD function definition or + /// Emit the target regions enclosed in \a GD function definition or /// the function itself in case it is a valid device function. Returns true if /// \a GD was dealt with successfully. /// \param GD Function to scan. virtual bool emitTargetFunctions(GlobalDecl GD); - /// \brief Emit the global variable if it is a valid device global variable. + /// Emit the global variable if it is a valid device global variable. /// Returns true if \a GD was dealt with successfully. /// \param GD Variable declaration to emit. virtual bool emitTargetGlobalVariable(GlobalDecl GD); @@ -1357,17 +1357,17 @@ public: virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr); - /// \brief Emit the global \a GD if it is meaningful for the target. Returns + /// Emit the global \a GD if it is meaningful for the target. Returns /// if it was emitted successfully. /// \param GD Global to scan. virtual bool emitTargetGlobal(GlobalDecl GD); - /// \brief Creates the offloading descriptor in the event any target region + /// Creates the offloading descriptor in the event any target region /// was emitted in the current module and return the function that registers /// it. virtual llvm::Function *emitRegistrationFunction(); - /// \brief Emits code for teams call of the \a OutlinedFn with + /// Emits code for teams call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// \param OutlinedFn Outlined function to be run by team masters. Type of @@ -1380,7 +1380,7 @@ public: SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef<llvm::Value *> CapturedVars); - /// \brief Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 + /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code /// for num_teams clause. /// \param NumTeams An integer expression of teams. @@ -1428,7 +1428,7 @@ public: bool requiresDevicePointerInfo() { return RequiresDevicePointerInfo; } }; - /// \brief Emit the target data mapping code associated with \a D. + /// Emit the target data mapping code associated with \a D. /// \param D Directive to emit. /// \param IfCond Expression evaluated in if clause associated with the /// target directive, or null if no device clause is used. @@ -1442,7 +1442,7 @@ public: const RegionCodeGenTy &CodeGen, TargetDataInfo &Info); - /// \brief Emit the data mapping/movement code associated with the directive + /// Emit the data mapping/movement code associated with the directive /// \a D that should be of the form 'target [{enter|exit} data | update]'. /// \param D Directive to emit. /// \param IfCond Expression evaluated in if clause associated with the target @@ -1515,7 +1515,7 @@ public: explicit CGOpenMPSIMDRuntime(CodeGenModule &CGM) : CGOpenMPRuntime(CGM) {} ~CGOpenMPSIMDRuntime() override {} - /// \brief Emits outlined function for the specified OpenMP parallel directive + /// Emits outlined function for the specified OpenMP parallel directive /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, /// kmp_int32 BoundID, struct context_vars*). /// \param D OpenMP directive. @@ -1529,7 +1529,7 @@ public: OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override; - /// \brief Emits outlined function for the specified OpenMP teams directive + /// Emits outlined function for the specified OpenMP teams directive /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, /// kmp_int32 BoundID, struct context_vars*). /// \param D OpenMP directive. @@ -1543,7 +1543,7 @@ public: OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override; - /// \brief Emits outlined function for the OpenMP task directive \a D. This + /// Emits outlined function for the OpenMP task directive \a D. This /// outlined function has type void(*)(kmp_int32 ThreadID, struct task_t* /// TaskT). /// \param D OpenMP directive. @@ -1564,7 +1564,7 @@ public: OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen, bool Tied, unsigned &NumberOfParts) override; - /// \brief Emits code for parallel or serial call of the \a OutlinedFn with + /// Emits code for parallel or serial call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// \param OutlinedFn Outlined function to be run in parallel threads. Type of @@ -1579,7 +1579,7 @@ public: ArrayRef<llvm::Value *> CapturedVars, const Expr *IfCond) override; - /// \brief Emits a critical region. + /// Emits a critical region. /// \param CriticalName Name of the critical region. /// \param CriticalOpGen Generator for the statement associated with the given /// critical region. @@ -1589,24 +1589,24 @@ public: SourceLocation Loc, const Expr *Hint = nullptr) override; - /// \brief Emits a master region. + /// Emits a master region. /// \param MasterOpGen Generator for the statement associated with the given /// master region. void emitMasterRegion(CodeGenFunction &CGF, const RegionCodeGenTy &MasterOpGen, SourceLocation Loc) override; - /// \brief Emits code for a taskyield directive. + /// Emits code for a taskyield directive. void emitTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc) override; - /// \brief Emit a taskgroup region. + /// Emit a taskgroup region. /// \param TaskgroupOpGen Generator for the statement associated with the /// given taskgroup region. void emitTaskgroupRegion(CodeGenFunction &CGF, const RegionCodeGenTy &TaskgroupOpGen, SourceLocation Loc) override; - /// \brief Emits a single region. + /// Emits a single region. /// \param SingleOpGen Generator for the statement associated with the given /// single region. void emitSingleRegion(CodeGenFunction &CGF, @@ -1616,14 +1616,14 @@ public: ArrayRef<const Expr *> SrcExprs, ArrayRef<const Expr *> AssignmentOps) override; - /// \brief Emit an ordered region. + /// Emit an ordered region. /// \param OrderedOpGen Generator for the statement associated with the given /// ordered region. void emitOrderedRegion(CodeGenFunction &CGF, const RegionCodeGenTy &OrderedOpGen, SourceLocation Loc, bool IsThreads) override; - /// \brief Emit an implicit/explicit barrier for OpenMP threads. + /// Emit an implicit/explicit barrier for OpenMP threads. /// \param Kind Directive for which this implicit barrier call must be /// generated. Must be OMPD_barrier for explicit barrier generation. /// \param EmitChecks true if need to emit checks for cancellation barriers. @@ -1656,7 +1656,7 @@ public: unsigned IVSize, bool IVSigned, bool Ordered, const DispatchRTInput &DispatchValues) override; - /// \brief Call the appropriate runtime routine to initialize it before start + /// Call the appropriate runtime routine to initialize it before start /// of loop. /// /// This is used only in case of static schedule, when the user did not @@ -1686,7 +1686,7 @@ public: OpenMPDistScheduleClauseKind SchedKind, const StaticRTInput &Values) override; - /// \brief Call the appropriate runtime routine to notify that we finished + /// Call the appropriate runtime routine to notify that we finished /// iteration of the ordered loop with the dynamic scheduling. /// /// \param CGF Reference to current CodeGenFunction. @@ -1697,7 +1697,7 @@ public: void emitForOrderedIterationEnd(CodeGenFunction &CGF, SourceLocation Loc, unsigned IVSize, bool IVSigned) override; - /// \brief Call the appropriate runtime routine to notify that we finished + /// Call the appropriate runtime routine to notify that we finished /// all the work with current loop. /// /// \param CGF Reference to current CodeGenFunction. @@ -1725,20 +1725,20 @@ public: unsigned IVSize, bool IVSigned, Address IL, Address LB, Address UB, Address ST) override; - /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 + /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads' /// clause. /// \param NumThreads An integer value of threads. void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc) override; - /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 + /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause. void emitProcBindClause(CodeGenFunction &CGF, OpenMPProcBindClauseKind ProcBind, SourceLocation Loc) override; - /// \brief Returns address of the threadprivate variable for the current + /// Returns address of the threadprivate variable for the current /// thread. /// \param VD Threadprivate variable. /// \param VDAddr Address of the global variable \a VD. @@ -1747,7 +1747,7 @@ public: Address getAddrOfThreadPrivate(CodeGenFunction &CGF, const VarDecl *VD, Address VDAddr, SourceLocation Loc) override; - /// \brief Emit a code for initialization of threadprivate variable. It emits + /// Emit a code for initialization of threadprivate variable. It emits /// a call to runtime library which adds initial value to the newly created /// threadprivate variable (if it is not constant) and registers destructor /// for the variable (if any). @@ -1768,12 +1768,12 @@ public: QualType VarType, StringRef Name) override; - /// \brief Emit flush of the variables specified in 'omp flush' directive. + /// Emit flush of the variables specified in 'omp flush' directive. /// \param Vars List of variables to flush. void emitFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars, SourceLocation Loc) override; - /// \brief Emit task region for the task directive. The task region is + /// Emit task region for the task directive. The task region is /// emitted in several steps: /// 1. Emit a call to kmp_task_t *__kmpc_omp_task_alloc(ident_t *, kmp_int32 /// gtid, kmp_int32 flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds, @@ -1839,7 +1839,7 @@ public: QualType SharedsTy, Address Shareds, const Expr *IfCond, const OMPTaskDataTy &Data) override; - /// \brief Emit a code for reduction clause. Next code should be emitted for + /// Emit a code for reduction clause. Next code should be emitted for /// reduction: /// \code /// @@ -1932,17 +1932,17 @@ public: llvm::Value *ReductionsPtr, LValue SharedLVal) override; - /// \brief Emit code for 'taskwait' directive. + /// Emit code for 'taskwait' directive. void emitTaskwaitCall(CodeGenFunction &CGF, SourceLocation Loc) override; - /// \brief Emit code for 'cancellation point' construct. + /// Emit code for 'cancellation point' construct. /// \param CancelRegion Region kind for which the cancellation point must be /// emitted. /// void emitCancellationPointCall(CodeGenFunction &CGF, SourceLocation Loc, OpenMPDirectiveKind CancelRegion) override; - /// \brief Emit code for 'cancel' construct. + /// Emit code for 'cancel' construct. /// \param IfCond Condition in the associated 'if' clause, if it was /// specified, nullptr otherwise. /// \param CancelRegion Region kind for which the cancel must be emitted. @@ -1951,7 +1951,7 @@ public: const Expr *IfCond, OpenMPDirectiveKind CancelRegion) override; - /// \brief Emit outilined function for 'target' directive. + /// Emit outilined function for 'target' directive. /// \param D Directive to emit. /// \param ParentName Name of the function that encloses the target region. /// \param OutlinedFn Outlined function value to be defined by this call. @@ -1967,7 +1967,7 @@ public: bool IsOffloadEntry, const RegionCodeGenTy &CodeGen) override; - /// \brief Emit the target offloading code associated with \a D. The emitted + /// Emit the target offloading code associated with \a D. The emitted /// code attempts offloading the execution to the device, an the event of /// a failure it executes the host version outlined in \a OutlinedFn. /// \param D Directive to emit. @@ -1981,28 +1981,28 @@ public: llvm::Value *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond, const Expr *Device) override; - /// \brief Emit the target regions enclosed in \a GD function definition or + /// Emit the target regions enclosed in \a GD function definition or /// the function itself in case it is a valid device function. Returns true if /// \a GD was dealt with successfully. /// \param GD Function to scan. bool emitTargetFunctions(GlobalDecl GD) override; - /// \brief Emit the global variable if it is a valid device global variable. + /// Emit the global variable if it is a valid device global variable. /// Returns true if \a GD was dealt with successfully. /// \param GD Variable declaration to emit. bool emitTargetGlobalVariable(GlobalDecl GD) override; - /// \brief Emit the global \a GD if it is meaningful for the target. Returns + /// Emit the global \a GD if it is meaningful for the target. Returns /// if it was emitted successfully. /// \param GD Global to scan. bool emitTargetGlobal(GlobalDecl GD) override; - /// \brief Creates the offloading descriptor in the event any target region + /// Creates the offloading descriptor in the event any target region /// was emitted in the current module and return the function that registers /// it. llvm::Function *emitRegistrationFunction() override; - /// \brief Emits code for teams call of the \a OutlinedFn with + /// Emits code for teams call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// \param OutlinedFn Outlined function to be run by team masters. Type of @@ -2014,7 +2014,7 @@ public: SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef<llvm::Value *> CapturedVars) override; - /// \brief Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 + /// Emits call to void __kmpc_push_num_teams(ident_t *loc, kmp_int32 /// global_tid, kmp_int32 num_teams, kmp_int32 thread_limit) to generate code /// for num_teams clause. /// \param NumTeams An integer expression of teams. @@ -2022,7 +2022,7 @@ public: void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc) override; - /// \brief Emit the target data mapping code associated with \a D. + /// Emit the target data mapping code associated with \a D. /// \param D Directive to emit. /// \param IfCond Expression evaluated in if clause associated with the /// target directive, or null if no device clause is used. @@ -2035,7 +2035,7 @@ public: const Expr *Device, const RegionCodeGenTy &CodeGen, TargetDataInfo &Info) override; - /// \brief Emit the data mapping/movement code associated with the directive + /// Emit the data mapping/movement code associated with the directive /// \a D that should be of the form 'target [{enter|exit} data | update]'. /// \param D Directive to emit. /// \param IfCond Expression evaluated in if clause associated with the target diff --git a/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp b/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp index 19b3147d26b..cee5ca65fc6 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp +++ b/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp @@ -24,24 +24,24 @@ using namespace CodeGen; namespace { enum OpenMPRTLFunctionNVPTX { - /// \brief Call to void __kmpc_kernel_init(kmp_int32 thread_limit, + /// Call to void __kmpc_kernel_init(kmp_int32 thread_limit, /// int16_t RequiresOMPRuntime); OMPRTL_NVPTX__kmpc_kernel_init, - /// \brief Call to void __kmpc_kernel_deinit(int16_t IsOMPRuntimeInitialized); + /// Call to void __kmpc_kernel_deinit(int16_t IsOMPRuntimeInitialized); OMPRTL_NVPTX__kmpc_kernel_deinit, - /// \brief Call to void __kmpc_spmd_kernel_init(kmp_int32 thread_limit, + /// Call to void __kmpc_spmd_kernel_init(kmp_int32 thread_limit, /// int16_t RequiresOMPRuntime, int16_t RequiresDataSharing); OMPRTL_NVPTX__kmpc_spmd_kernel_init, - /// \brief Call to void __kmpc_spmd_kernel_deinit(); + /// Call to void __kmpc_spmd_kernel_deinit(); OMPRTL_NVPTX__kmpc_spmd_kernel_deinit, - /// \brief Call to void __kmpc_kernel_prepare_parallel(void + /// Call to void __kmpc_kernel_prepare_parallel(void /// *outlined_function, int16_t /// IsOMPRuntimeInitialized); OMPRTL_NVPTX__kmpc_kernel_prepare_parallel, - /// \brief Call to bool __kmpc_kernel_parallel(void **outlined_function, + /// Call to bool __kmpc_kernel_parallel(void **outlined_function, /// int16_t IsOMPRuntimeInitialized); OMPRTL_NVPTX__kmpc_kernel_parallel, - /// \brief Call to void __kmpc_kernel_end_parallel(); + /// Call to void __kmpc_kernel_end_parallel(); OMPRTL_NVPTX__kmpc_kernel_end_parallel, /// Call to void __kmpc_serialized_parallel(ident_t *loc, kmp_int32 /// global_tid); @@ -49,25 +49,25 @@ enum OpenMPRTLFunctionNVPTX { /// Call to void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32 /// global_tid); OMPRTL_NVPTX__kmpc_end_serialized_parallel, - /// \brief Call to int32_t __kmpc_shuffle_int32(int32_t element, + /// Call to int32_t __kmpc_shuffle_int32(int32_t element, /// int16_t lane_offset, int16_t warp_size); OMPRTL_NVPTX__kmpc_shuffle_int32, - /// \brief Call to int64_t __kmpc_shuffle_int64(int64_t element, + /// Call to int64_t __kmpc_shuffle_int64(int64_t element, /// int16_t lane_offset, int16_t warp_size); OMPRTL_NVPTX__kmpc_shuffle_int64, - /// \brief Call to __kmpc_nvptx_parallel_reduce_nowait(kmp_int32 + /// Call to __kmpc_nvptx_parallel_reduce_nowait(kmp_int32 /// global_tid, kmp_int32 num_vars, size_t reduce_size, void* reduce_data, /// void (*kmp_ShuffleReductFctPtr)(void *rhsData, int16_t lane_id, int16_t /// lane_offset, int16_t shortCircuit), /// void (*kmp_InterWarpCopyFctPtr)(void* src, int32_t warp_num)); OMPRTL_NVPTX__kmpc_parallel_reduce_nowait, - /// \brief Call to __kmpc_nvptx_simd_reduce_nowait(kmp_int32 + /// Call to __kmpc_nvptx_simd_reduce_nowait(kmp_int32 /// global_tid, kmp_int32 num_vars, size_t reduce_size, void* reduce_data, /// void (*kmp_ShuffleReductFctPtr)(void *rhsData, int16_t lane_id, int16_t /// lane_offset, int16_t shortCircuit), /// void (*kmp_InterWarpCopyFctPtr)(void* src, int32_t warp_num)); OMPRTL_NVPTX__kmpc_simd_reduce_nowait, - /// \brief Call to __kmpc_nvptx_teams_reduce_nowait(int32_t global_tid, + /// Call to __kmpc_nvptx_teams_reduce_nowait(int32_t global_tid, /// int32_t num_vars, size_t reduce_size, void *reduce_data, /// void (*kmp_ShuffleReductFctPtr)(void *rhs, int16_t lane_id, int16_t /// lane_offset, int16_t shortCircuit), @@ -77,21 +77,21 @@ enum OpenMPRTLFunctionNVPTX { /// void (*kmp_LoadReduceFctPtr)(void *reduce_data, void * scratchpad, int32_t /// index, int32_t width, int32_t reduce)) OMPRTL_NVPTX__kmpc_teams_reduce_nowait, - /// \brief Call to __kmpc_nvptx_end_reduce_nowait(int32_t global_tid); + /// Call to __kmpc_nvptx_end_reduce_nowait(int32_t global_tid); OMPRTL_NVPTX__kmpc_end_reduce_nowait, - /// \brief Call to void __kmpc_data_sharing_init_stack(); + /// Call to void __kmpc_data_sharing_init_stack(); OMPRTL_NVPTX__kmpc_data_sharing_init_stack, - /// \brief Call to void* __kmpc_data_sharing_push_stack(size_t size, + /// Call to void* __kmpc_data_sharing_push_stack(size_t size, /// int16_t UseSharedMemory); OMPRTL_NVPTX__kmpc_data_sharing_push_stack, - /// \brief Call to void __kmpc_data_sharing_pop_stack(void *a); + /// Call to void __kmpc_data_sharing_pop_stack(void *a); OMPRTL_NVPTX__kmpc_data_sharing_pop_stack, - /// \brief Call to void __kmpc_begin_sharing_variables(void ***args, + /// Call to void __kmpc_begin_sharing_variables(void ***args, /// size_t n_args); OMPRTL_NVPTX__kmpc_begin_sharing_variables, - /// \brief Call to void __kmpc_end_sharing_variables(); + /// Call to void __kmpc_end_sharing_variables(); OMPRTL_NVPTX__kmpc_end_sharing_variables, - /// \brief Call to void __kmpc_get_shared_variables(void ***GlobalArgs) + /// Call to void __kmpc_get_shared_variables(void ***GlobalArgs) OMPRTL_NVPTX__kmpc_get_shared_variables, /// Call to uint16_t __kmpc_parallel_level(ident_t *loc, kmp_int32 /// global_tid); @@ -1078,7 +1078,7 @@ void CGOpenMPRuntimeNVPTX::emitWorkerLoop(CodeGenFunction &CGF, CGF.EmitBlock(ExitBB); } -/// \brief Returns specified OpenMP runtime function for the current OpenMP +/// Returns specified OpenMP runtime function for the current OpenMP /// implementation. Specialized for the NVPTX device. /// \param Function OpenMP runtime function. /// \return Specified function. diff --git a/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h b/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h index ac8011dc790..88420b90497 100644 --- a/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h +++ b/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h @@ -46,18 +46,18 @@ private: bool isInSpmdExecutionMode() const; - /// \brief Emit the worker function for the current target region. + /// Emit the worker function for the current target region. void emitWorkerFunction(WorkerFunctionState &WST); - /// \brief Helper for worker function. Emit body of worker loop. + /// Helper for worker function. Emit body of worker loop. void emitWorkerLoop(CodeGenFunction &CGF, WorkerFunctionState &WST); - /// \brief Helper for non-SPMD target entry function. Guide the master and + /// Helper for non-SPMD target entry function. Guide the master and /// worker threads to their respective locations. void emitNonSPMDEntryHeader(CodeGenFunction &CGF, EntryFunctionState &EST, WorkerFunctionState &WST); - /// \brief Signal termination of OMP execution for non-SPMD target entry + /// Signal termination of OMP execution for non-SPMD target entry /// function. void emitNonSPMDEntryFooter(CodeGenFunction &CGF, EntryFunctionState &EST); @@ -67,24 +67,24 @@ private: /// Helper for generic variables globalization epilog. void emitGenericVarsEpilog(CodeGenFunction &CGF); - /// \brief Helper for Spmd mode target directive's entry function. + /// Helper for Spmd mode target directive's entry function. void emitSpmdEntryHeader(CodeGenFunction &CGF, EntryFunctionState &EST, const OMPExecutableDirective &D); - /// \brief Signal termination of Spmd mode execution. + /// Signal termination of Spmd mode execution. void emitSpmdEntryFooter(CodeGenFunction &CGF, EntryFunctionState &EST); // // Base class overrides. // - /// \brief Creates offloading entry for the provided entry ID \a ID, + /// Creates offloading entry for the provided entry ID \a ID, /// address \a Addr, size \a Size, and flags \a Flags. void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr, uint64_t Size, int32_t Flags, llvm::GlobalValue::LinkageTypes Linkage) override; - /// \brief Emit outlined function specialized for the Fork-Join + /// Emit outlined function specialized for the Fork-Join /// programming model for applicable target directives on the NVPTX device. /// \param D Directive to emit. /// \param ParentName Name of the function that encloses the target region. @@ -98,7 +98,7 @@ private: llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen); - /// \brief Emit outlined function specialized for the Single Program + /// Emit outlined function specialized for the Single Program /// Multiple Data programming model for applicable target directives on the /// NVPTX device. /// \param D Directive to emit. @@ -114,7 +114,7 @@ private: llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen); - /// \brief Emit outlined function for 'target' directive on the NVPTX + /// Emit outlined function for 'target' directive on the NVPTX /// device. /// \param D Directive to emit. /// \param ParentName Name of the function that encloses the target region. @@ -130,7 +130,7 @@ private: bool IsOffloadEntry, const RegionCodeGenTy &CodeGen) override; - /// \brief Emits code for parallel or serial call of the \a OutlinedFn with + /// Emits code for parallel or serial call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// This call is for the Non-SPMD Execution Mode. @@ -145,7 +145,7 @@ private: ArrayRef<llvm::Value *> CapturedVars, const Expr *IfCond); - /// \brief Emits code for parallel or serial call of the \a OutlinedFn with + /// Emits code for parallel or serial call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// This call is for a parallel directive within an SPMD target directive. @@ -162,7 +162,7 @@ private: const Expr *IfCond); protected: - /// \brief Get the function name of an outlined region. + /// Get the function name of an outlined region. // The name can be customized depending on the target. // StringRef getOutlinedHelperName() const override { @@ -172,13 +172,13 @@ protected: public: explicit CGOpenMPRuntimeNVPTX(CodeGenModule &CGM); - /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 + /// Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause. virtual void emitProcBindClause(CodeGenFunction &CGF, OpenMPProcBindClauseKind ProcBind, SourceLocation Loc) override; - /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 + /// Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads' /// clause. /// \param NumThreads An integer value of threads. @@ -186,7 +186,7 @@ public: llvm::Value *NumThreads, SourceLocation Loc) override; - /// \brief This function ought to emit, in the general case, a call to + /// This function ought to emit, in the general case, a call to // the openmp runtime kmpc_push_num_teams. In NVPTX backend it is not needed // as these numbers are obtained through the PTX grid and block configuration. /// \param NumTeams An integer expression of teams. @@ -194,7 +194,7 @@ public: void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc) override; - /// \brief Emits inlined function for the specified OpenMP parallel + /// Emits inlined function for the specified OpenMP parallel // directive. /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, /// kmp_int32 BoundID, struct context_vars*). @@ -209,7 +209,7 @@ public: OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override; - /// \brief Emits inlined function for the specified OpenMP teams + /// Emits inlined function for the specified OpenMP teams // directive. /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID, /// kmp_int32 BoundID, struct context_vars*). @@ -224,7 +224,7 @@ public: OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override; - /// \brief Emits code for teams call of the \a OutlinedFn with + /// Emits code for teams call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// \param OutlinedFn Outlined function to be run by team masters. Type of @@ -236,7 +236,7 @@ public: SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef<llvm::Value *> CapturedVars) override; - /// \brief Emits code for parallel or serial call of the \a OutlinedFn with + /// Emits code for parallel or serial call of the \a OutlinedFn with /// variables captured in a record which address is stored in \a /// CapturedStruct. /// \param OutlinedFn Outlined function to be run in parallel threads. Type of diff --git a/clang/lib/CodeGen/CGRecordLayout.h b/clang/lib/CodeGen/CGRecordLayout.h index 7b9c27d1d77..41084294ab9 100644 --- a/clang/lib/CodeGen/CGRecordLayout.h +++ b/clang/lib/CodeGen/CGRecordLayout.h @@ -23,7 +23,7 @@ namespace llvm { namespace clang { namespace CodeGen { -/// \brief Structure with information about how a bitfield should be accessed. +/// Structure with information about how a bitfield should be accessed. /// /// Often we layout a sequence of bitfields as a contiguous sequence of bits. /// When the AST record layout does this, we represent it in the LLVM IR's type @@ -92,7 +92,7 @@ struct CGBitFieldInfo { void print(raw_ostream &OS) const; void dump() const; - /// \brief Given a bit-field decl, build an appropriate helper object for + /// Given a bit-field decl, build an appropriate helper object for /// accessing that field (which is expected to have the given offset and /// size). static CGBitFieldInfo MakeInfo(class CodeGenTypes &Types, @@ -156,31 +156,31 @@ public: IsZeroInitializable(IsZeroInitializable), IsZeroInitializableAsBase(IsZeroInitializableAsBase) {} - /// \brief Return the "complete object" LLVM type associated with + /// Return the "complete object" LLVM type associated with /// this record. llvm::StructType *getLLVMType() const { return CompleteObjectType; } - /// \brief Return the "base subobject" LLVM type associated with + /// Return the "base subobject" LLVM type associated with /// this record. llvm::StructType *getBaseSubobjectLLVMType() const { return BaseSubobjectType; } - /// \brief Check whether this struct can be C++ zero-initialized + /// Check whether this struct can be C++ zero-initialized /// with a zeroinitializer. bool isZeroInitializable() const { return IsZeroInitializable; } - /// \brief Check whether this struct can be C++ zero-initialized + /// Check whether this struct can be C++ zero-initialized /// with a zeroinitializer when considered as a base subobject. bool isZeroInitializableAsBase() const { return IsZeroInitializableAsBase; } - /// \brief Return llvm::StructType element number that corresponds to the + /// Return llvm::StructType element number that corresponds to the /// field FD. unsigned getLLVMFieldNo(const FieldDecl *FD) const { FD = FD->getCanonicalDecl(); @@ -193,14 +193,14 @@ public: return NonVirtualBases.lookup(RD); } - /// \brief Return the LLVM field index corresponding to the given + /// Return the LLVM field index corresponding to the given /// virtual base. Only valid when operating on the complete object. unsigned getVirtualBaseIndex(const CXXRecordDecl *base) const { assert(CompleteObjectVirtualBases.count(base) && "Invalid virtual base!"); return CompleteObjectVirtualBases.lookup(base); } - /// \brief Return the BitFieldInfo that corresponds to the field FD. + /// Return the BitFieldInfo that corresponds to the field FD. const CGBitFieldInfo &getBitFieldInfo(const FieldDecl *FD) const { FD = FD->getCanonicalDecl(); assert(FD->isBitField() && "Invalid call for non-bit-field decl!"); diff --git a/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp b/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp index aac4e80c7b2..2d8f071de68 100644 --- a/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp +++ b/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp @@ -95,7 +95,7 @@ struct CGRecordLowering { // The constructor. CGRecordLowering(CodeGenTypes &Types, const RecordDecl *D, bool Packed); // Short helper routines. - /// \brief Constructs a MemberInfo instance from an offset and llvm::Type *. + /// Constructs a MemberInfo instance from an offset and llvm::Type *. MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) { return MemberInfo(Offset, MemberInfo::Field, Data); } @@ -118,19 +118,19 @@ struct CGRecordLowering { return !Context.getTargetInfo().getCXXABI().isMicrosoft(); } - /// \brief Wraps llvm::Type::getIntNTy with some implicit arguments. + /// Wraps llvm::Type::getIntNTy with some implicit arguments. llvm::Type *getIntNType(uint64_t NumBits) { return llvm::Type::getIntNTy(Types.getLLVMContext(), (unsigned)llvm::alignTo(NumBits, 8)); } - /// \brief Gets an llvm type of size NumBytes and alignment 1. + /// Gets an llvm type of size NumBytes and alignment 1. llvm::Type *getByteArrayType(CharUnits NumBytes) { assert(!NumBytes.isZero() && "Empty byte arrays aren't allowed."); llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext()); return NumBytes == CharUnits::One() ? Type : (llvm::Type *)llvm::ArrayType::get(Type, NumBytes.getQuantity()); } - /// \brief Gets the storage type for a field decl and handles storage + /// Gets the storage type for a field decl and handles storage /// for itanium bitfields that are smaller than their declared type. llvm::Type *getStorageType(const FieldDecl *FD) { llvm::Type *Type = Types.ConvertTypeForMem(FD->getType()); @@ -139,7 +139,7 @@ struct CGRecordLowering { return getIntNType(std::min(FD->getBitWidthValue(Context), (unsigned)Context.toBits(getSize(Type)))); } - /// \brief Gets the llvm Basesubobject type from a CXXRecordDecl. + /// Gets the llvm Basesubobject type from a CXXRecordDecl. llvm::Type *getStorageType(const CXXRecordDecl *RD) { return Types.getCGRecordLayout(RD).getBaseSubobjectLLVMType(); } @@ -168,7 +168,7 @@ struct CGRecordLowering { // Layout routines. void setBitFieldInfo(const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType); - /// \brief Lowers an ASTRecordLayout to a llvm type. + /// Lowers an ASTRecordLayout to a llvm type. void lower(bool NonVirtualBaseType); void lowerUnion(); void accumulateFields(); @@ -177,18 +177,18 @@ struct CGRecordLowering { void accumulateBases(); void accumulateVPtrs(); void accumulateVBases(); - /// \brief Recursively searches all of the bases to find out if a vbase is + /// Recursively searches all of the bases to find out if a vbase is /// not the primary vbase of some base class. bool hasOwnStorage(const CXXRecordDecl *Decl, const CXXRecordDecl *Query); void calculateZeroInit(); - /// \brief Lowers bitfield storage types to I8 arrays for bitfields with tail + /// Lowers bitfield storage types to I8 arrays for bitfields with tail /// padding that is or can potentially be used. void clipTailPadding(); - /// \brief Determines if we need a packed llvm struct. + /// Determines if we need a packed llvm struct. void determinePacked(bool NVBaseType); - /// \brief Inserts padding everywhere it's needed. + /// Inserts padding everywhere it's needed. void insertPadding(); - /// \brief Fills out the structures that are ultimately consumed. + /// Fills out the structures that are ultimately consumed. void fillOutputFields(); // Input memoization fields. CodeGenTypes &Types; diff --git a/clang/lib/CodeGen/CGValue.h b/clang/lib/CodeGen/CGValue.h index ea997c18d66..418bda1f41b 100644 --- a/clang/lib/CodeGen/CGValue.h +++ b/clang/lib/CodeGen/CGValue.h @@ -401,7 +401,7 @@ public: return R; } - /// \brief Create a new object to represent a bit-field access. + /// Create a new object to represent a bit-field access. /// /// \param Addr - The base address of the bit-field sequence this /// bit-field refers to. diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp index 93e95a2dd88..9b9f562f855 100644 --- a/clang/lib/CodeGen/CodeGenAction.cpp +++ b/clang/lib/CodeGen/CodeGenAction.cpp @@ -341,17 +341,17 @@ namespace clang { SourceLocation LocCookie); void DiagnosticHandlerImpl(const llvm::DiagnosticInfo &DI); - /// \brief Specialized handler for InlineAsm diagnostic. + /// Specialized handler for InlineAsm diagnostic. /// \return True if the diagnostic has been successfully reported, false /// otherwise. bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D); - /// \brief Specialized handler for StackSize diagnostic. + /// Specialized handler for StackSize diagnostic. /// \return True if the diagnostic has been successfully reported, false /// otherwise. bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D); - /// \brief Specialized handler for unsupported backend feature diagnostic. + /// Specialized handler for unsupported backend feature diagnostic. void UnsupportedDiagHandler(const llvm::DiagnosticInfoUnsupported &D); - /// \brief Specialized handlers for optimization remarks. + /// Specialized handlers for optimization remarks. /// Note that these handlers only accept remarks and they always handle /// them. void EmitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &D, @@ -697,7 +697,7 @@ void BackendConsumer::OptimizationFailureHandler( EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure); } -/// \brief This function is invoked when the backend needs +/// This function is invoked when the backend needs /// to report something to the user. void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) { unsigned DiagID = diag::err_fe_inline_asm; diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index 7889d089074..98fc9ade733 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -201,7 +201,7 @@ public: Address UB)> CodeGenDispatchBoundsTy; - /// \brief CGBuilder insert helper. This function is called after an + /// CGBuilder insert helper. This function is called after an /// instruction is created using Builder. void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB, @@ -255,7 +255,7 @@ public: /// we prefer to insert allocas. llvm::AssertingVH<llvm::Instruction> AllocaInsertPt; - /// \brief API for captured statement code generation. + /// API for captured statement code generation. class CGCapturedStmtInfo { public: explicit CGCapturedStmtInfo(CapturedRegionKind K = CR_Default) @@ -283,10 +283,10 @@ public: CapturedRegionKind getKind() const { return Kind; } virtual void setContextValue(llvm::Value *V) { ThisValue = V; } - // \brief Retrieve the value of the context parameter. + // Retrieve the value of the context parameter. virtual llvm::Value *getContextValue() const { return ThisValue; } - /// \brief Lookup the captured field decl for a variable. + /// Lookup the captured field decl for a variable. virtual const FieldDecl *lookup(const VarDecl *VD) const { return CaptureFields.lookup(VD->getCanonicalDecl()); } @@ -298,32 +298,32 @@ public: return true; } - /// \brief Emit the captured statement body. + /// Emit the captured statement body. virtual void EmitBody(CodeGenFunction &CGF, const Stmt *S) { CGF.incrementProfileCounter(S); CGF.EmitStmt(S); } - /// \brief Get the name of the capture helper. + /// Get the name of the capture helper. virtual StringRef getHelperName() const { return "__captured_stmt"; } private: - /// \brief The kind of captured statement being generated. + /// The kind of captured statement being generated. CapturedRegionKind Kind; - /// \brief Keep the map between VarDecl and FieldDecl. + /// Keep the map between VarDecl and FieldDecl. llvm::SmallDenseMap<const VarDecl *, FieldDecl *> CaptureFields; - /// \brief The base address of the captured record, passed in as the first + /// The base address of the captured record, passed in as the first /// argument of the parallel region function. llvm::Value *ThisValue; - /// \brief Captured 'this' type. + /// Captured 'this' type. FieldDecl *CXXThisFieldDecl; }; CGCapturedStmtInfo *CapturedStmtInfo; - /// \brief RAII for correct setting/restoring of CapturedStmtInfo. + /// RAII for correct setting/restoring of CapturedStmtInfo. class CGCapturedStmtRAII { private: CodeGenFunction &CGF; @@ -362,13 +362,13 @@ public: } }; - /// \brief Sanitizers enabled for this function. + /// Sanitizers enabled for this function. SanitizerSet SanOpts; - /// \brief True if CodeGen currently emits code implementing sanitizer checks. + /// True if CodeGen currently emits code implementing sanitizer checks. bool IsSanitizerScope; - /// \brief RAII object to set/unset CodeGenFunction::IsSanitizerScope. + /// RAII object to set/unset CodeGenFunction::IsSanitizerScope. class SanitizerScope { CodeGenFunction *CGF; public: @@ -399,7 +399,7 @@ public: llvm::DenseMap<const VarDecl *, FieldDecl *> LambdaCaptureFields; FieldDecl *LambdaThisCaptureField; - /// \brief A mapping from NRVO variables to the flags used to indicate + /// A mapping from NRVO variables to the flags used to indicate /// when the NRVO has been applied to this variable. llvm::DenseMap<const VarDecl *, llvm::Value *> NRVOFlags; @@ -525,7 +525,7 @@ public: initFullExprCleanup(); } - /// \brief Queue a cleanup to be pushed after finishing the current + /// Queue a cleanup to be pushed after finishing the current /// full-expression. template <class T, class... As> void pushCleanupAfterFullExpr(CleanupKind Kind, As... A) { @@ -584,7 +584,7 @@ public: void ActivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP); - /// \brief Enters a new scope for capturing cleanups, all of which + /// Enters a new scope for capturing cleanups, all of which /// will be executed once the scope is exited. class RunCleanupsScope { EHScopeStack::stable_iterator CleanupStackDepth, OldCleanupScopeDepth; @@ -601,7 +601,7 @@ public: CodeGenFunction& CGF; public: - /// \brief Enter a new cleanup scope. + /// Enter a new cleanup scope. explicit RunCleanupsScope(CodeGenFunction &CGF) : PerformCleanup(true), CGF(CGF) { @@ -614,18 +614,18 @@ public: CGF.CurrentCleanupScopeDepth = CleanupStackDepth; } - /// \brief Exit this cleanup scope, emitting any accumulated cleanups. + /// Exit this cleanup scope, emitting any accumulated cleanups. ~RunCleanupsScope() { if (PerformCleanup) ForceCleanup(); } - /// \brief Determine whether this scope requires any cleanups. + /// Determine whether this scope requires any cleanups. bool requiresCleanups() const { return CGF.EHStack.stable_begin() != CleanupStackDepth; } - /// \brief Force the emission of cleanups now, instead of waiting + /// Force the emission of cleanups now, instead of waiting /// until this object is destroyed. /// \param ValuesToReload - A list of values that need to be available at /// the insertion point after cleanup emission. If cleanup emission created @@ -654,7 +654,7 @@ public: void operator=(const LexicalScope &) = delete; public: - /// \brief Enter a new cleanup scope. + /// Enter a new cleanup scope. explicit LexicalScope(CodeGenFunction &CGF, SourceRange Range) : RunCleanupsScope(CGF), Range(Range), ParentScope(CGF.CurLexicalScope) { CGF.CurLexicalScope = this; @@ -667,7 +667,7 @@ public: Labels.push_back(label); } - /// \brief Exit this cleanup scope, emitting any accumulated + /// Exit this cleanup scope, emitting any accumulated /// cleanups. ~LexicalScope() { if (CGDebugInfo *DI = CGF.getDebugInfo()) @@ -681,7 +681,7 @@ public: } } - /// \brief Force the emission of cleanups now, instead of waiting + /// Force the emission of cleanups now, instead of waiting /// until this object is destroyed. void ForceCleanup() { CGF.CurLexicalScope = ParentScope; @@ -828,13 +828,13 @@ public: } }; - /// \brief Takes the old cleanup stack size and emits the cleanup blocks + /// Takes the old cleanup stack size and emits the cleanup blocks /// that have been added. void PopCleanupBlocks(EHScopeStack::stable_iterator OldCleanupStackSize, std::initializer_list<llvm::Value **> ValuesToReload = {}); - /// \brief Takes the old cleanup stack size and emits the cleanup blocks + /// Takes the old cleanup stack size and emits the cleanup blocks /// that have been added, then adds all lifetime-extended cleanups from /// the given position to the stack. void @@ -1667,7 +1667,7 @@ public: void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo); - /// \brief Emit code for the start of a function. + /// Emit code for the start of a function. /// \param Loc The location to be associated with the function. /// \param StartLoc The location of the function body. void StartFunction(GlobalDecl GD, @@ -1693,7 +1693,7 @@ public: void EmitLambdaStaticInvokeBody(const CXXMethodDecl *MD); void EmitAsanPrologueOrEpilogue(bool Prologue); - /// \brief Emit the unified return block, trying to avoid its emission when + /// Emit the unified return block, trying to avoid its emission when /// possible. /// \return The debug location of the user written return statement if the /// return block is is avoided. @@ -1766,7 +1766,7 @@ public: CFITCK_ICall, }; - /// \brief Derived is the presumed address of an object of type T after a + /// Derived is the presumed address of an object of type T after a /// cast. If T is a polymorphic class type, emit a check that the virtual /// table for Derived belongs to a class derived from T. void EmitVTablePtrCheckForCast(QualType T, llvm::Value *Derived, @@ -2406,7 +2406,7 @@ public: llvm::Value *EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE); Address EmitCXXUuidofExpr(const CXXUuidofExpr *E); - /// \brief Situations in which we might emit a check for the suitability of a + /// Situations in which we might emit a check for the suitability of a /// pointer or glvalue. enum TypeCheckKind { /// Checking the operand of a load. Must be suitably sized and aligned. @@ -2450,17 +2450,17 @@ public: /// Determine whether the pointer type check \p TCK requires a vptr check. static bool isVptrCheckRequired(TypeCheckKind TCK, QualType Ty); - /// \brief Whether any type-checking sanitizers are enabled. If \c false, + /// Whether any type-checking sanitizers are enabled. If \c false, /// calls to EmitTypeCheck can be skipped. bool sanitizePerformTypeCheck() const; - /// \brief Emit a check that \p V is the address of storage of the + /// Emit a check that \p V is the address of storage of the /// appropriate size and alignment for an object of type \p Type. void EmitTypeCheck(TypeCheckKind TCK, SourceLocation Loc, llvm::Value *V, QualType Type, CharUnits Alignment = CharUnits::Zero(), SanitizerSet SkippedChecks = SanitizerSet()); - /// \brief Emit a check that \p Base points into an array object, which + /// Emit a check that \p Base points into an array object, which /// we can access at index \p Index. \p Accessed should be \c false if we /// this expression is used as an lvalue, for instance in "&Arr[Idx]". void EmitBoundsCheck(const Expr *E, const Expr *Base, llvm::Value *Index, @@ -2501,7 +2501,7 @@ public: typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl &D, llvm::Value *Address); - /// \brief Determine whether the given initializer is trivial in the sense + /// Determine whether the given initializer is trivial in the sense /// that it requires no code to be generated. bool isTrivialInitializer(const Expr *Init); @@ -2776,7 +2776,7 @@ public: SmallVectorImpl<llvm::Value *> &CapturedVars); void emitOMPSimpleStore(LValue LVal, RValue RVal, QualType RValTy, SourceLocation Loc); - /// \brief Perform element by element copying of arrays with type \a + /// Perform element by element copying of arrays with type \a /// OriginalType from \a SrcAddr to \a DestAddr using copying procedure /// generated by \a CopyGen. /// @@ -2788,7 +2788,7 @@ public: void EmitOMPAggregateAssign( Address DestAddr, Address SrcAddr, QualType OriginalType, const llvm::function_ref<void(Address, Address)> CopyGen); - /// \brief Emit proper copying of data from one variable to another. + /// Emit proper copying of data from one variable to another. /// /// \param OriginalType Original type of the copied variables. /// \param DestAddr Destination address. @@ -2803,7 +2803,7 @@ public: Address DestAddr, Address SrcAddr, const VarDecl *DestVD, const VarDecl *SrcVD, const Expr *Copy); - /// \brief Emit atomic update code for constructs: \a X = \a X \a BO \a E or + /// Emit atomic update code for constructs: \a X = \a X \a BO \a E or /// \a X = \a E \a BO \a E. /// /// \param X Value to be updated. @@ -2827,7 +2827,7 @@ public: void EmitOMPUseDevicePtrClause( const OMPClause &C, OMPPrivateScope &PrivateScope, const llvm::DenseMap<const ValueDecl *, Address> &CaptureDeviceAddrMap); - /// \brief Emit code for copyin clause in \a D directive. The next code is + /// Emit code for copyin clause in \a D directive. The next code is /// generated at the start of outlined functions for directives: /// \code /// threadprivate_var1 = master_threadprivate_var1; @@ -2839,7 +2839,7 @@ public: /// \param D OpenMP directive possibly with 'copyin' clause(s). /// \returns true if at least one copyin variable is found, false otherwise. bool EmitOMPCopyinClause(const OMPExecutableDirective &D); - /// \brief Emit initial code for lastprivate variables. If some variable is + /// Emit initial code for lastprivate variables. If some variable is /// not also firstprivate, then the default initialization is used. Otherwise /// initialization of this variable is performed by EmitOMPFirstprivateClause /// method. @@ -2852,7 +2852,7 @@ public: /// otherwise. bool EmitOMPLastprivateClauseInit(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope); - /// \brief Emit final copying of lastprivate values to original variables at + /// Emit final copying of lastprivate values to original variables at /// the end of the worksharing or simd directive. /// /// \param D Directive that has at least one 'lastprivate' directives. @@ -2871,7 +2871,7 @@ public: void EmitOMPLinearClauseFinal( const OMPLoopDirective &D, const llvm::function_ref<llvm::Value *(CodeGenFunction &)> CondGen); - /// \brief Emit initial code for reduction variables. Creates reduction copies + /// Emit initial code for reduction variables. Creates reduction copies /// and initializes them with the values according to OpenMP standard. /// /// \param D Directive (possibly) with the 'reduction' clause. @@ -2880,14 +2880,14 @@ public: /// void EmitOMPReductionClauseInit(const OMPExecutableDirective &D, OMPPrivateScope &PrivateScope); - /// \brief Emit final update of reduction values to original variables at + /// Emit final update of reduction values to original variables at /// the end of the directive. /// /// \param D Directive that has at least one 'reduction' directives. /// \param ReductionKind The kind of reduction to perform. void EmitOMPReductionClauseFinal(const OMPExecutableDirective &D, const OpenMPDirectiveKind ReductionKind); - /// \brief Emit initial code for linear variables. Creates private copies + /// Emit initial code for linear variables. Creates private copies /// and initializes them with the values according to OpenMP standard. /// /// \param D Directive (possibly) with the 'linear' clause. @@ -3019,7 +3019,7 @@ public: static void EmitOMPTargetTeamsDistributeParallelForDeviceFunction( CodeGenModule &CGM, StringRef ParentName, const OMPTargetTeamsDistributeParallelForDirective &S); - /// \brief Emit inner loop of the worksharing/simd construct. + /// Emit inner loop of the worksharing/simd construct. /// /// \param S Directive, for which the inner loop must be emitted. /// \param RequiresCleanup true, if directive has some associated private @@ -3043,7 +3043,7 @@ public: /// Helper for the OpenMP loop directives. void EmitOMPLoopBody(const OMPLoopDirective &D, JumpDest LoopExit); - /// \brief Emit code for the worksharing loop-based directive. + /// Emit code for the worksharing loop-based directive. /// \return true, if this construct has any lastprivate clause, false - /// otherwise. bool EmitOMPWorksharingLoop(const OMPLoopDirective &S, Expr *EUB, @@ -3116,7 +3116,7 @@ private: OMPPrivateScope &LoopScope, const OMPLoopArguments &LoopArgs, const CodeGenLoopTy &CodeGenLoopContent); - /// \brief Emit code for sections directive. + /// Emit code for sections directive. void EmitSections(const OMPExecutableDirective &S); public: @@ -3157,7 +3157,7 @@ public: /// LValue EmitLValue(const Expr *E); - /// \brief Same as EmitLValue but additionally we generate checking code to + /// Same as EmitLValue but additionally we generate checking code to /// guard against undefined behavior. This is only suitable when we know /// that the address will be used to access the object. LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK); @@ -3634,7 +3634,7 @@ public: void EmitObjCAutoreleasePoolCleanup(llvm::Value *Ptr); void EmitObjCMRRAutoreleasePoolPop(llvm::Value *Ptr); - /// \brief Emits a reference binding to the passed in expression. + /// Emits a reference binding to the passed in expression. RValue EmitReferenceBindingToExpr(const Expr *E); //===--------------------------------------------------------------------===// @@ -3851,26 +3851,26 @@ public: /// enabled, a runtime check specified by \p Kind is also emitted. llvm::Value *EmitCheckedArgForBuiltin(const Expr *E, BuiltinCheckKind Kind); - /// \brief Emit a description of a type in a format suitable for passing to + /// Emit a description of a type in a format suitable for passing to /// a runtime sanitizer handler. llvm::Constant *EmitCheckTypeDescriptor(QualType T); - /// \brief Convert a value into a format suitable for passing to a runtime + /// Convert a value into a format suitable for passing to a runtime /// sanitizer handler. llvm::Value *EmitCheckValue(llvm::Value *V); - /// \brief Emit a description of a source location in a format suitable for + /// Emit a description of a source location in a format suitable for /// passing to a runtime sanitizer handler. llvm::Constant *EmitCheckSourceLocation(SourceLocation Loc); - /// \brief Create a basic block that will call a handler function in a + /// Create a basic block that will call a handler function in a /// sanitizer runtime with the provided arguments, and create a conditional /// branch to it. void EmitCheck(ArrayRef<std::pair<llvm::Value *, SanitizerMask>> Checked, SanitizerHandler Check, ArrayRef<llvm::Constant *> StaticArgs, ArrayRef<llvm::Value *> DynamicArgs); - /// \brief Emit a slow path cross-DSO CFI check which calls __cfi_slowpath + /// Emit a slow path cross-DSO CFI check which calls __cfi_slowpath /// if Cond if false. void EmitCfiSlowPathCheck(SanitizerMask Kind, llvm::Value *Cond, llvm::ConstantInt *TypeId, llvm::Value *Ptr, @@ -3880,21 +3880,21 @@ public: /// checking is enabled. Otherwise, just emit an unreachable instruction. void EmitUnreachable(SourceLocation Loc); - /// \brief Create a basic block that will call the trap intrinsic, and emit a + /// Create a basic block that will call the trap intrinsic, and emit a /// conditional branch to it, for the -ftrapv checks. void EmitTrapCheck(llvm::Value *Checked); - /// \brief Emit a call to trap or debugtrap and attach function attribute + /// Emit a call to trap or debugtrap and attach function attribute /// "trap-func-name" if specified. llvm::CallInst *EmitTrapCall(llvm::Intrinsic::ID IntrID); - /// \brief Emit a stub for the cross-DSO CFI check function. + /// Emit a stub for the cross-DSO CFI check function. void EmitCfiCheckStub(); - /// \brief Emit a cross-DSO CFI failure handling function. + /// Emit a cross-DSO CFI failure handling function. void EmitCfiCheckFail(); - /// \brief Create a check for a function parameter that may potentially be + /// Create a check for a function parameter that may potentially be /// declared as non-null. void EmitNonNullArgCheck(RValue RV, QualType ArgType, SourceLocation ArgLoc, AbstractCallee AC, unsigned ParmNum); @@ -3949,7 +3949,7 @@ private: std::string &ConstraintStr, SourceLocation Loc); - /// \brief Attempts to statically evaluate the object size of E. If that + /// Attempts to statically evaluate the object size of E. If that /// fails, emits code to figure the size of E out for us. This is /// pass_object_size aware. /// @@ -3958,7 +3958,7 @@ private: llvm::IntegerType *ResType, llvm::Value *EmittedE); - /// \brief Emits the size of E, as required by __builtin_object_size. This + /// Emits the size of E, as required by __builtin_object_size. This /// function is aware of pass_object_size parameters, and will act accordingly /// if E is a parameter with the pass_object_size attribute. llvm::Value *emitBuiltinObjectSize(const Expr *E, unsigned Type, diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index 4bb3c7b0d3b..bfdd1e65e2c 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -1548,7 +1548,7 @@ void CodeGenModule::AddDependentLib(StringRef Lib) { LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts)); } -/// \brief Add link options implied by the given module, including modules +/// Add link options implied by the given module, including modules /// it depends on, using a postorder walk. static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl<llvm::MDNode *> &Metadata, diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h index 76af56b56c3..04a9f64e60e 100644 --- a/clang/lib/CodeGen/CodeGenModule.h +++ b/clang/lib/CodeGen/CodeGenModule.h @@ -391,10 +391,10 @@ private: llvm::GlobalValue *> StaticExternCMap; StaticExternCMap StaticExternCValues; - /// \brief thread_local variables defined or used in this TU. + /// thread_local variables defined or used in this TU. std::vector<const VarDecl *> CXXThreadLocals; - /// \brief thread_local variables with initializers that need to run + /// thread_local variables with initializers that need to run /// before any thread_local variable in this TU is odr-used. std::vector<llvm::Function *> CXXThreadLocalInits; std::vector<const VarDecl *> CXXThreadLocalInitVars; @@ -425,14 +425,14 @@ private: /// Global destructor functions and arguments that need to run on termination. std::vector<std::pair<llvm::WeakTrackingVH, llvm::Constant *>> CXXGlobalDtors; - /// \brief The complete set of modules that has been imported. + /// The complete set of modules that has been imported. llvm::SetVector<clang::Module *> ImportedModules; - /// \brief The set of modules for which the module initializers + /// The set of modules for which the module initializers /// have been emitted. llvm::SmallPtrSet<clang::Module *, 16> EmittedModuleInitializers; - /// \brief A vector of metadata strings. + /// A vector of metadata strings. SmallVector<llvm::MDNode *, 16> LinkerOptionsMetadata; /// @name Cache for Objective-C runtime types @@ -442,7 +442,7 @@ private: /// int * but is actually an Obj-C class pointer. llvm::WeakTrackingVH CFConstantStringClassRef; - /// \brief The type used to describe the state of a fast enumeration in + /// The type used to describe the state of a fast enumeration in /// Objective-C's for..in loop. QualType ObjCFastEnumerationStateType; @@ -900,12 +900,12 @@ public: void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE, llvm::GlobalVariable *GV); - /// \brief Returns a pointer to a global variable representing a temporary + /// Returns a pointer to a global variable representing a temporary /// with static or thread storage duration. ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner); - /// \brief Retrieve the record type that describes the state of an + /// Retrieve the record type that describes the state of an /// Objective-C fast enumeration loop (for..in). QualType getObjCFastEnumerationStateType(); @@ -933,22 +933,22 @@ public: /// Emit code for a single top level declaration. void EmitTopLevelDecl(Decl *D); - /// \brief Stored a deferred empty coverage mapping for an unused + /// Stored a deferred empty coverage mapping for an unused /// and thus uninstrumented top level declaration. void AddDeferredUnusedCoverageMapping(Decl *D); - /// \brief Remove the deferred empty coverage mapping as this + /// Remove the deferred empty coverage mapping as this /// declaration is actually instrumented. void ClearUnusedCoverageMapping(const Decl *D); - /// \brief Emit all the deferred coverage mappings + /// Emit all the deferred coverage mappings /// for the uninstrumented functions. void EmitDeferredUnusedCoverageMappings(); /// Tell the consumer that this variable has been instantiated. void HandleCXXStaticMemberVarInstantiation(VarDecl *VD); - /// \brief If the declaration has internal linkage but is inside an + /// If the declaration has internal linkage but is inside an /// extern "C" linkage specification, prepare to emit an alias for it /// to the expected name. template<typename SomeDecl> @@ -997,7 +997,7 @@ public: llvm::Constant *getMemberPointerConstant(const UnaryOperator *e); - /// \brief Emit type info if type of an expression is a variably modified + /// Emit type info if type of an expression is a variably modified /// type. Also emit proper debug info for cast types. void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF = nullptr); @@ -1096,13 +1096,13 @@ public: void RefreshTypeCacheForClass(const CXXRecordDecl *Class); - /// \brief Appends Opts to the "llvm.linker.options" metadata value. + /// Appends Opts to the "llvm.linker.options" metadata value. void AppendLinkerOptions(StringRef Opts); - /// \brief Appends a detect mismatch command to the linker options. + /// Appends a detect mismatch command to the linker options. void AddDetectMismatch(StringRef Name, StringRef Value); - /// \brief Appends a dependent lib to the "llvm.linker.options" metadata + /// Appends a dependent lib to the "llvm.linker.options" metadata /// value. void AddDependentLib(StringRef Lib); @@ -1197,11 +1197,11 @@ public: void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C); - /// \brief Emit a code for threadprivate directive. + /// Emit a code for threadprivate directive. /// \param D Threadprivate declaration. void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D); - /// \brief Emit a code for declare reduction construct. + /// Emit a code for declare reduction construct. void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF = nullptr); @@ -1237,7 +1237,7 @@ public: void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD); - /// \brief Get the declaration of std::terminate for the platform. + /// Get the declaration of std::terminate for the platform. llvm::Constant *getTerminateFn(); llvm::SanitizerStatReport &getSanStats(); @@ -1291,7 +1291,7 @@ private: void EmitDeclContext(const DeclContext *DC); void EmitLinkageSpec(const LinkageSpecDecl *D); - /// \brief Emit the function that initializes C++ thread_local variables. + /// Emit the function that initializes C++ thread_local variables. void EmitCXXThreadLocalInitFunc(); /// Emit the function that initializes C++ globals. @@ -1354,16 +1354,16 @@ private: /// Emit the llvm.used and llvm.compiler.used metadata. void emitLLVMUsed(); - /// \brief Emit the link options introduced by imported modules. + /// Emit the link options introduced by imported modules. void EmitModuleLinkOptions(); - /// \brief Emit aliases for internal-linkage declarations inside "C" language + /// Emit aliases for internal-linkage declarations inside "C" language /// linkage specifications, giving them the "expected" name where possible. void EmitStaticExternCAliases(); void EmitDeclMetadata(); - /// \brief Emit the Clang version as llvm.ident metadata. + /// Emit the Clang version as llvm.ident metadata. void EmitVersionIdentMetadata(); /// Emits target specific Metadata for global declarations. diff --git a/clang/lib/CodeGen/CodeGenPGO.cpp b/clang/lib/CodeGen/CodeGenPGO.cpp index 295893c64fb..c8c2a1b956b 100644 --- a/clang/lib/CodeGen/CodeGenPGO.cpp +++ b/clang/lib/CodeGen/CodeGenPGO.cpp @@ -58,7 +58,7 @@ enum PGOHashVersion : unsigned { }; namespace { -/// \brief Stable hasher for PGO region counters. +/// Stable hasher for PGO region counters. /// /// PGOHash produces a stable hash of a given function's control flow. /// @@ -79,7 +79,7 @@ class PGOHash { static const unsigned TooBig = 1u << NumBitsPerType; public: - /// \brief Hash values for AST nodes. + /// Hash values for AST nodes. /// /// Distinct values for AST nodes that have region counters attached. /// @@ -978,7 +978,7 @@ void CodeGenPGO::loadRegionCounts(llvm::IndexedInstrProfReader *PGOReader, RegionCounts = ProfRecord->Counts; } -/// \brief Calculate what to divide by to scale weights. +/// Calculate what to divide by to scale weights. /// /// Given the maximum weight, calculate a divisor that will scale all the /// weights to strictly less than UINT32_MAX. @@ -986,7 +986,7 @@ static uint64_t calculateWeightScale(uint64_t MaxWeight) { return MaxWeight < UINT32_MAX ? 1 : MaxWeight / UINT32_MAX + 1; } -/// \brief Scale an individual branch weight (and add 1). +/// Scale an individual branch weight (and add 1). /// /// Scale a 64-bit weight down to 32-bits using \c Scale. /// diff --git a/clang/lib/CodeGen/CodeGenTypes.h b/clang/lib/CodeGen/CodeGenTypes.h index 8cae1863d0b..fb8d3168429 100644 --- a/clang/lib/CodeGen/CodeGenTypes.h +++ b/clang/lib/CodeGen/CodeGenTypes.h @@ -184,7 +184,7 @@ public: /// ConvertType - Convert type T into a llvm::Type. llvm::Type *ConvertType(QualType T); - /// \brief Converts the GlobalDecl into an llvm::Type. This should be used + /// Converts the GlobalDecl into an llvm::Type. This should be used /// when we know the target of the function we want to convert. This is /// because some functions (explicitly, those with pass_object_size /// parameters) may not have the same signature as their type portrays, and @@ -225,7 +225,7 @@ public: /// replace the 'opaque' type we previously made for it if applicable. void UpdateCompletedType(const TagDecl *TD); - /// \brief Remove stale types from the type cache when an inheritance model + /// Remove stale types from the type cache when an inheritance model /// gets assigned to a class. void RefreshTypeCacheForClass(const CXXRecordDecl *RD); @@ -335,7 +335,7 @@ public: ArrayRef<FunctionProtoType::ExtParameterInfo> paramInfos, RequiredArgs args); - /// \brief Compute a new LLVM record layout object for the given record. + /// Compute a new LLVM record layout object for the given record. CGRecordLayout *ComputeRecordLayout(const RecordDecl *D, llvm::StructType *Ty); diff --git a/clang/lib/CodeGen/CoverageMappingGen.cpp b/clang/lib/CodeGen/CoverageMappingGen.cpp index 97139ef69bc..04e2661518d 100644 --- a/clang/lib/CodeGen/CoverageMappingGen.cpp +++ b/clang/lib/CodeGen/CoverageMappingGen.cpp @@ -35,14 +35,14 @@ void CoverageSourceInfo::SourceRangeSkipped(SourceRange Range, SourceLocation) { namespace { -/// \brief A region of source code that can be mapped to a counter. +/// A region of source code that can be mapped to a counter. class SourceMappingRegion { Counter Count; - /// \brief The region's starting location. + /// The region's starting location. Optional<SourceLocation> LocStart; - /// \brief The region's ending location. + /// The region's ending location. Optional<SourceLocation> LocEnd; /// Whether this region should be emitted after its parent is emitted. @@ -126,7 +126,7 @@ struct SpellingRegion { } }; -/// \brief Provides the common functionality for the different +/// Provides the common functionality for the different /// coverage mapping region builders. class CoverageMappingBuilder { public: @@ -135,17 +135,17 @@ public: const LangOptions &LangOpts; private: - /// \brief Map of clang's FileIDs to IDs used for coverage mapping. + /// Map of clang's FileIDs to IDs used for coverage mapping. llvm::SmallDenseMap<FileID, std::pair<unsigned, SourceLocation>, 8> FileIDMapping; public: - /// \brief The coverage mapping regions for this function + /// The coverage mapping regions for this function llvm::SmallVector<CounterMappingRegion, 32> MappingRegions; - /// \brief The source mapping regions for this function. + /// The source mapping regions for this function. std::vector<SourceMappingRegion> SourceRegions; - /// \brief A set of regions which can be used as a filter. + /// A set of regions which can be used as a filter. /// /// It is produced by emitExpansionRegions() and is used in /// emitSourceRegions() to suppress producing code regions if @@ -157,7 +157,7 @@ public: const LangOptions &LangOpts) : CVM(CVM), SM(SM), LangOpts(LangOpts) {} - /// \brief Return the precise end location for the given token. + /// Return the precise end location for the given token. SourceLocation getPreciseTokenLocEnd(SourceLocation Loc) { // We avoid getLocForEndOfToken here, because it doesn't do what we want for // macro locations, which we just treat as expanded files. @@ -166,14 +166,14 @@ public: return Loc.getLocWithOffset(TokLen); } - /// \brief Return the start location of an included file or expanded macro. + /// Return the start location of an included file or expanded macro. SourceLocation getStartOfFileOrMacro(SourceLocation Loc) { if (Loc.isMacroID()) return Loc.getLocWithOffset(-SM.getFileOffset(Loc)); return SM.getLocForStartOfFile(SM.getFileID(Loc)); } - /// \brief Return the end location of an included file or expanded macro. + /// Return the end location of an included file or expanded macro. SourceLocation getEndOfFileOrMacro(SourceLocation Loc) { if (Loc.isMacroID()) return Loc.getLocWithOffset(SM.getFileIDSize(SM.getFileID(Loc)) - @@ -181,18 +181,18 @@ public: return SM.getLocForEndOfFile(SM.getFileID(Loc)); } - /// \brief Find out where the current file is included or macro is expanded. + /// Find out where the current file is included or macro is expanded. SourceLocation getIncludeOrExpansionLoc(SourceLocation Loc) { return Loc.isMacroID() ? SM.getImmediateExpansionRange(Loc).getBegin() : SM.getIncludeLoc(SM.getFileID(Loc)); } - /// \brief Return true if \c Loc is a location in a built-in macro. + /// Return true if \c Loc is a location in a built-in macro. bool isInBuiltin(SourceLocation Loc) { return SM.getBufferName(SM.getSpellingLoc(Loc)) == "<built-in>"; } - /// \brief Check whether \c Loc is included or expanded from \c Parent. + /// Check whether \c Loc is included or expanded from \c Parent. bool isNestedIn(SourceLocation Loc, FileID Parent) { do { Loc = getIncludeOrExpansionLoc(Loc); @@ -202,7 +202,7 @@ public: return true; } - /// \brief Get the start of \c S ignoring macro arguments and builtin macros. + /// Get the start of \c S ignoring macro arguments and builtin macros. SourceLocation getStart(const Stmt *S) { SourceLocation Loc = S->getLocStart(); while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc)) @@ -210,7 +210,7 @@ public: return Loc; } - /// \brief Get the end of \c S ignoring macro arguments and builtin macros. + /// Get the end of \c S ignoring macro arguments and builtin macros. SourceLocation getEnd(const Stmt *S) { SourceLocation Loc = S->getLocEnd(); while (SM.isMacroArgExpansion(Loc) || isInBuiltin(Loc)) @@ -218,7 +218,7 @@ public: return getPreciseTokenLocEnd(Loc); } - /// \brief Find the set of files we have regions for and assign IDs + /// Find the set of files we have regions for and assign IDs /// /// Fills \c Mapping with the virtual file mapping needed to write out /// coverage and collects the necessary file information to emit source and @@ -258,7 +258,7 @@ public: } } - /// \brief Get the coverage mapping file ID for \c Loc. + /// Get the coverage mapping file ID for \c Loc. /// /// If such file id doesn't exist, return None. Optional<unsigned> getCoverageFileID(SourceLocation Loc) { @@ -268,7 +268,7 @@ public: return None; } - /// \brief Gather all the regions that were skipped by the preprocessor + /// Gather all the regions that were skipped by the preprocessor /// using the constructs like #if. void gatherSkippedRegions() { /// An array of the minimum lineStarts and the maximum lineEnds @@ -305,7 +305,7 @@ public: } } - /// \brief Generate the coverage counter mapping regions from collected + /// Generate the coverage counter mapping regions from collected /// source regions. void emitSourceRegions(const SourceRegionFilter &Filter) { for (const auto &Region : SourceRegions) { @@ -350,7 +350,7 @@ public: } } - /// \brief Generate expansion regions for each virtual file we've seen. + /// Generate expansion regions for each virtual file we've seen. SourceRegionFilter emitExpansionRegions() { SourceRegionFilter Filter; for (const auto &FM : FileIDMapping) { @@ -380,7 +380,7 @@ public: } }; -/// \brief Creates unreachable coverage regions for the functions that +/// Creates unreachable coverage regions for the functions that /// are not emitted. struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder { EmptyCoverageMappingBuilder(CoverageMappingModuleGen &CVM, SourceManager &SM, @@ -414,7 +414,7 @@ struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder { SourceRegions.emplace_back(Counter(), Start, End); } - /// \brief Write the mapping data to the output stream + /// Write the mapping data to the output stream void write(llvm::raw_ostream &OS) { SmallVector<unsigned, 16> FileIDMapping; gatherFileIDs(FileIDMapping); @@ -428,15 +428,15 @@ struct EmptyCoverageMappingBuilder : public CoverageMappingBuilder { } }; -/// \brief A StmtVisitor that creates coverage mapping regions which map +/// A StmtVisitor that creates coverage mapping regions which map /// from the source code locations to the PGO counters. struct CounterCoverageMappingBuilder : public CoverageMappingBuilder, public ConstStmtVisitor<CounterCoverageMappingBuilder> { - /// \brief The map of statements to count values. + /// The map of statements to count values. llvm::DenseMap<const Stmt *, unsigned> &CounterMap; - /// \brief A stack of currently live regions. + /// A stack of currently live regions. std::vector<SourceMappingRegion> RegionStack; /// The currently deferred region: its end location and count can be set once @@ -445,7 +445,7 @@ struct CounterCoverageMappingBuilder CounterExpressionBuilder Builder; - /// \brief A location in the most recently visited file or macro. + /// A location in the most recently visited file or macro. /// /// This is used to adjust the active source regions appropriately when /// expressions cross file or macro boundaries. @@ -454,12 +454,12 @@ struct CounterCoverageMappingBuilder /// Location of the last terminated region. Optional<std::pair<SourceLocation, size_t>> LastTerminatedRegion; - /// \brief Return a counter for the subtraction of \c RHS from \c LHS + /// Return a counter for the subtraction of \c RHS from \c LHS Counter subtractCounters(Counter LHS, Counter RHS) { return Builder.subtract(LHS, RHS); } - /// \brief Return a counter for the sum of \c LHS and \c RHS. + /// Return a counter for the sum of \c LHS and \c RHS. Counter addCounters(Counter LHS, Counter RHS) { return Builder.add(LHS, RHS); } @@ -468,14 +468,14 @@ struct CounterCoverageMappingBuilder return addCounters(addCounters(C1, C2), C3); } - /// \brief Return the region counter for the given statement. + /// Return the region counter for the given statement. /// /// This should only be called on statements that have a dedicated counter. Counter getRegionCounter(const Stmt *S) { return Counter::getCounter(CounterMap[S]); } - /// \brief Push a region onto the stack. + /// Push a region onto the stack. /// /// Returns the index on the stack where the region was pushed. This can be /// used with popRegions to exit a "scope", ending the region that was pushed. @@ -552,7 +552,7 @@ struct CounterCoverageMappingBuilder completeDeferred(Count, DeferredEndLoc); } - /// \brief Pop regions from the stack into the function's list of regions. + /// Pop regions from the stack into the function's list of regions. /// /// Adds all regions from \c ParentIndex to the top of the stack to the /// function's \c SourceRegions. @@ -619,13 +619,13 @@ struct CounterCoverageMappingBuilder assert(!ParentOfDeferredRegion && "Deferred region with no parent"); } - /// \brief Return the currently active region. + /// Return the currently active region. SourceMappingRegion &getRegion() { assert(!RegionStack.empty() && "statement has no region"); return RegionStack.back(); } - /// \brief Propagate counts through the children of \c S. + /// Propagate counts through the children of \c S. Counter propagateCounts(Counter TopCount, const Stmt *S) { SourceLocation StartLoc = getStart(S); SourceLocation EndLoc = getEnd(S); @@ -642,7 +642,7 @@ struct CounterCoverageMappingBuilder return ExitCount; } - /// \brief Check whether a region with bounds \c StartLoc and \c EndLoc + /// Check whether a region with bounds \c StartLoc and \c EndLoc /// is already added to \c SourceRegions. bool isRegionAlreadyAdded(SourceLocation StartLoc, SourceLocation EndLoc) { return SourceRegions.rend() != @@ -653,7 +653,7 @@ struct CounterCoverageMappingBuilder }); } - /// \brief Adjust the most recently visited location to \c EndLoc. + /// Adjust the most recently visited location to \c EndLoc. /// /// This should be used after visiting any statements in non-source order. void adjustForOutOfOrderTraversal(SourceLocation EndLoc) { @@ -670,7 +670,7 @@ struct CounterCoverageMappingBuilder MostRecentLocation = getIncludeOrExpansionLoc(MostRecentLocation); } - /// \brief Adjust regions and state when \c NewLoc exits a file. + /// Adjust regions and state when \c NewLoc exits a file. /// /// If moving from our most recently tracked location to \c NewLoc exits any /// files, this adjusts our current region stack and creates the file regions @@ -737,7 +737,7 @@ struct CounterCoverageMappingBuilder MostRecentLocation = NewLoc; } - /// \brief Ensure that \c S is included in the current region. + /// Ensure that \c S is included in the current region. void extendRegion(const Stmt *S) { SourceMappingRegion &Region = getRegion(); SourceLocation StartLoc = getStart(S); @@ -749,7 +749,7 @@ struct CounterCoverageMappingBuilder completeDeferred(Region.getCounter(), StartLoc); } - /// \brief Mark \c S as a terminator, starting a zero region. + /// Mark \c S as a terminator, starting a zero region. void terminateRegion(const Stmt *S) { extendRegion(S); SourceMappingRegion &Region = getRegion(); @@ -794,7 +794,7 @@ struct CounterCoverageMappingBuilder popRegions(Index); } - /// \brief Keep counts of breaks and continues inside loops. + /// Keep counts of breaks and continues inside loops. struct BreakContinue { Counter BreakCount; Counter ContinueCount; @@ -808,7 +808,7 @@ struct CounterCoverageMappingBuilder : CoverageMappingBuilder(CVM, SM, LangOpts), CounterMap(CounterMap), DeferredRegion(None) {} - /// \brief Write the mapping data to the output stream + /// Write the mapping data to the output stream void write(llvm::raw_ostream &OS) { llvm::SmallVector<unsigned, 8> VirtualFileMapping; gatherFileIDs(VirtualFileMapping); diff --git a/clang/lib/CodeGen/CoverageMappingGen.h b/clang/lib/CodeGen/CoverageMappingGen.h index d07ed5ebcf2..b08ad896d7a 100644 --- a/clang/lib/CodeGen/CoverageMappingGen.h +++ b/clang/lib/CodeGen/CoverageMappingGen.h @@ -31,7 +31,7 @@ class Preprocessor; class Decl; class Stmt; -/// \brief Stores additional source code information like skipped ranges which +/// Stores additional source code information like skipped ranges which /// is required by the coverage mapping generator and is obtained from /// the preprocessor. class CoverageSourceInfo : public PPCallbacks { @@ -46,7 +46,7 @@ namespace CodeGen { class CodeGenModule; -/// \brief Organizes the cross-function state that is used while generating +/// Organizes the cross-function state that is used while generating /// code coverage mapping data. class CoverageMappingModuleGen { CodeGenModule &CGM; @@ -65,7 +65,7 @@ public: return SourceInfo; } - /// \brief Add a function's coverage mapping record to the collection of the + /// Add a function's coverage mapping record to the collection of the /// function mapping records. void addFunctionMappingRecord(llvm::GlobalVariable *FunctionName, StringRef FunctionNameValue, @@ -73,15 +73,15 @@ public: const std::string &CoverageMapping, bool IsUsed = true); - /// \brief Emit the coverage mapping data for a translation unit. + /// Emit the coverage mapping data for a translation unit. void emit(); - /// \brief Return the coverage mapping translation unit file id + /// Return the coverage mapping translation unit file id /// for the given file. unsigned getFileID(const FileEntry *File); }; -/// \brief Organizes the per-function state that is used while generating +/// Organizes the per-function state that is used while generating /// code coverage mapping data. class CoverageMappingGen { CoverageMappingModuleGen &CVM; @@ -99,12 +99,12 @@ public: llvm::DenseMap<const Stmt *, unsigned> *CounterMap) : CVM(CVM), SM(SM), LangOpts(LangOpts), CounterMap(CounterMap) {} - /// \brief Emit the coverage mapping data which maps the regions of + /// Emit the coverage mapping data which maps the regions of /// code to counters that will be used to find the execution /// counts for those regions. void emitCounterMapping(const Decl *D, llvm::raw_ostream &OS); - /// \brief Emit the coverage mapping data for an unused function. + /// Emit the coverage mapping data for an unused function. /// It creates mapping regions with the counter of zero. void emitEmptyMapping(const Decl *D, llvm::raw_ostream &OS); }; diff --git a/clang/lib/CodeGen/ItaniumCXXABI.cpp b/clang/lib/CodeGen/ItaniumCXXABI.cpp index bfabdf0830c..168dbcb2893 100644 --- a/clang/lib/CodeGen/ItaniumCXXABI.cpp +++ b/clang/lib/CodeGen/ItaniumCXXABI.cpp @@ -1171,7 +1171,7 @@ static llvm::Constant *getBadCastFn(CodeGenFunction &CGF) { return CGF.CGM.CreateRuntimeFunction(FTy, "__cxa_bad_cast"); } -/// \brief Compute the src2dst_offset hint as described in the +/// Compute the src2dst_offset hint as described in the /// Itanium C++ ABI [2.9.7] static CharUnits computeOffsetHint(ASTContext &Context, const CXXRecordDecl *Src, @@ -3006,7 +3006,7 @@ void ItaniumRTTIBuilder::BuildVTablePointer(const Type *Ty) { Fields.push_back(VTable); } -/// \brief Return the linkage that the type info and type info name constants +/// Return the linkage that the type info and type info name constants /// should have for the given type. static llvm::GlobalVariable::LinkageTypes getTypeInfoLinkage(CodeGenModule &CGM, QualType Ty) { diff --git a/clang/lib/CodeGen/MicrosoftCXXABI.cpp b/clang/lib/CodeGen/MicrosoftCXXABI.cpp index ab5bad45703..75e461cc0c9 100644 --- a/clang/lib/CodeGen/MicrosoftCXXABI.cpp +++ b/clang/lib/CodeGen/MicrosoftCXXABI.cpp @@ -567,7 +567,7 @@ private: GetNullMemberPointerFields(const MemberPointerType *MPT, llvm::SmallVectorImpl<llvm::Constant *> &fields); - /// \brief Shared code for virtual base adjustment. Returns the offset from + /// Shared code for virtual base adjustment. Returns the offset from /// the vbptr to the virtual base. Optionally returns the address of the /// vbptr itself. llvm::Value *GetVBaseOffsetFromVBPtr(CodeGenFunction &CGF, @@ -591,14 +591,14 @@ private: performBaseAdjustment(CodeGenFunction &CGF, Address Value, QualType SrcRecordTy); - /// \brief Performs a full virtual base adjustment. Used to dereference + /// Performs a full virtual base adjustment. Used to dereference /// pointers to members of virtual bases. llvm::Value *AdjustVirtualBase(CodeGenFunction &CGF, const Expr *E, const CXXRecordDecl *RD, Address Base, llvm::Value *VirtualBaseAdjustmentOffset, llvm::Value *VBPtrOffset /* optional */); - /// \brief Emits a full member pointer with the fields common to data and + /// Emits a full member pointer with the fields common to data and /// function member pointers. llvm::Constant *EmitFullMemberPointer(llvm::Constant *FirstField, bool IsMemberFunction, @@ -609,13 +609,13 @@ private: bool MemberPointerConstantIsNull(const MemberPointerType *MPT, llvm::Constant *MP); - /// \brief - Initialize all vbptrs of 'this' with RD as the complete type. + /// - Initialize all vbptrs of 'this' with RD as the complete type. void EmitVBPtrStores(CodeGenFunction &CGF, const CXXRecordDecl *RD); - /// \brief Caching wrapper around VBTableBuilder::enumerateVBTables(). + /// Caching wrapper around VBTableBuilder::enumerateVBTables(). const VBTableGlobals &enumerateVBTables(const CXXRecordDecl *RD); - /// \brief Generate a thunk for calling a virtual member function MD. + /// Generate a thunk for calling a virtual member function MD. llvm::Function *EmitVirtualMemPtrThunk(const CXXMethodDecl *MD, const MethodVFTableLocation &ML); @@ -761,15 +761,15 @@ private: typedef std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy; typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalVariable *> VTablesMapTy; typedef llvm::DenseMap<VFTableIdTy, llvm::GlobalValue *> VFTablesMapTy; - /// \brief All the vftables that have been referenced. + /// All the vftables that have been referenced. VFTablesMapTy VFTablesMap; VTablesMapTy VTablesMap; - /// \brief This set holds the record decls we've deferred vtable emission for. + /// This set holds the record decls we've deferred vtable emission for. llvm::SmallPtrSet<const CXXRecordDecl *, 4> DeferredVFTables; - /// \brief All the vbtables which have been referenced. + /// All the vbtables which have been referenced. llvm::DenseMap<const CXXRecordDecl *, VBTableGlobals> VBTablesMap; /// Info on the global variable used to guard initialization of static locals. @@ -3387,7 +3387,7 @@ static llvm::GlobalVariable *getTypeInfoVTable(CodeGenModule &CGM) { namespace { -/// \brief A Helper struct that stores information about a class in a class +/// A Helper struct that stores information about a class in a class /// hierarchy. The information stored in these structs struct is used during /// the generation of ClassHierarchyDescriptors and BaseClassDescriptors. // During RTTI creation, MSRTTIClasses are stored in a contiguous array with @@ -3414,7 +3414,7 @@ struct MSRTTIClass { uint32_t Flags, NumBases, OffsetInVBase; }; -/// \brief Recursively initialize the base class array. +/// Recursively initialize the base class array. uint32_t MSRTTIClass::initialize(const MSRTTIClass *Parent, const CXXBaseSpecifier *Specifier) { Flags = HasHierarchyDescriptor; @@ -3461,7 +3461,7 @@ static llvm::GlobalValue::LinkageTypes getLinkageForRTTI(QualType Ty) { llvm_unreachable("Invalid linkage!"); } -/// \brief An ephemeral helper class for building MS RTTI types. It caches some +/// An ephemeral helper class for building MS RTTI types. It caches some /// calls to the module and information about the most derived class in a /// hierarchy. struct MSRTTIBuilder { @@ -3494,7 +3494,7 @@ struct MSRTTIBuilder { } // namespace -/// \brief Recursively serializes a class hierarchy in pre-order depth first +/// Recursively serializes a class hierarchy in pre-order depth first /// order. static void serializeClassHierarchy(SmallVectorImpl<MSRTTIClass> &Classes, const CXXRecordDecl *RD) { @@ -3503,7 +3503,7 @@ static void serializeClassHierarchy(SmallVectorImpl<MSRTTIClass> &Classes, serializeClassHierarchy(Classes, Base.getType()->getAsCXXRecordDecl()); } -/// \brief Find ambiguity among base classes. +/// Find ambiguity among base classes. static void detectAmbiguousBases(SmallVectorImpl<MSRTTIClass> &Classes) { llvm::SmallPtrSet<const CXXRecordDecl *, 8> VirtualBases; @@ -3769,7 +3769,7 @@ MicrosoftCXXABI::getAddrOfCXXCatchHandlerType(QualType Type, Flags}; } -/// \brief Gets a TypeDescriptor. Returns a llvm::Constant * rather than a +/// Gets a TypeDescriptor. Returns a llvm::Constant * rather than a /// llvm::GlobalVariable * because different type descriptors have different /// types, and need to be abstracted. They are abstracting by casting the /// address to an Int8PtrTy. @@ -3811,7 +3811,7 @@ llvm::Constant *MicrosoftCXXABI::getAddrOfRTTIDescriptor(QualType Type) { return llvm::ConstantExpr::getBitCast(Var, CGM.Int8PtrTy); } -/// \brief Gets or a creates a Microsoft CompleteObjectLocator. +/// Gets or a creates a Microsoft CompleteObjectLocator. llvm::GlobalVariable * MicrosoftCXXABI::getMSCompleteObjectLocator(const CXXRecordDecl *RD, const VPtrInfo &Info) { diff --git a/clang/lib/CodeGen/TargetInfo.cpp b/clang/lib/CodeGen/TargetInfo.cpp index 99e4b0de3e9..4e25c72cfb6 100644 --- a/clang/lib/CodeGen/TargetInfo.cpp +++ b/clang/lib/CodeGen/TargetInfo.cpp @@ -749,7 +749,7 @@ public: : TargetCodeGenInfo(new WebAssemblyABIInfo(CGT)) {} }; -/// \brief Classify argument of given type \p Ty. +/// Classify argument of given type \p Ty. ABIArgInfo WebAssemblyABIInfo::classifyArgumentType(QualType Ty) const { Ty = useFirstFieldIfTransparentUnion(Ty); @@ -844,7 +844,7 @@ Address PNaClABIInfo::EmitVAArg(CodeGenFunction &CGF, Address VAListAddr, return EmitVAArgInstr(CGF, VAListAddr, Ty, ABIArgInfo::getDirect()); } -/// \brief Classify argument of given type \p Ty. +/// Classify argument of given type \p Ty. ABIArgInfo PNaClABIInfo::classifyArgumentType(QualType Ty) const { if (isAggregateTypeForABI(Ty)) { if (CGCXXABI::RecordArgABI RAA = getRecordArgABI(Ty, getCXXABI())) @@ -945,7 +945,7 @@ static ABIArgInfo getDirectX86Hva(llvm::Type* T = nullptr) { // X86-32 ABI Implementation //===----------------------------------------------------------------------===// -/// \brief Similar to llvm::CCState, but for Clang. +/// Similar to llvm::CCState, but for Clang. struct CCState { CCState(unsigned CC) : CC(CC), FreeRegs(0), FreeSSERegs(0) {} @@ -998,14 +998,14 @@ class X86_32ABIInfo : public SwiftABIInfo { ABIArgInfo getIndirectReturnResult(QualType Ty, CCState &State) const; - /// \brief Return the alignment to use for the given type on the stack. + /// Return the alignment to use for the given type on the stack. unsigned getTypeStackAlignInBytes(QualType Ty, unsigned Align) const; Class classify(QualType Ty) const; ABIArgInfo classifyReturnType(QualType RetTy, CCState &State) const; ABIArgInfo classifyArgumentType(QualType RetTy, CCState &State) const; - /// \brief Updates the number of available free registers, returns + /// Updates the number of available free registers, returns /// true if any registers were allocated. bool updateFreeRegs(QualType Ty, CCState &State) const; @@ -1015,7 +1015,7 @@ class X86_32ABIInfo : public SwiftABIInfo { bool canExpandIndirectArgument(QualType Ty) const; - /// \brief Rewrite the function info so that all memory arguments use + /// Rewrite the function info so that all memory arguments use /// inalloca. void rewriteWithInAlloca(CGFunctionInfo &FI) const; |
