Identified with readability-redundant-control-flow.
tooling::fixit::getText(*Remainder, *Result.Context) + ")")
.str());
}
- return;
}
} // namespace abseil
diag(MatchedDecl->getLocation(),
"declaration must be declared within the '%0' namespace")
<< RequiredNamespace;
- return;
}
} // namespace llvm_libc
void getArgKinds(ASTNodeKind ThisKind, unsigned,
std::vector<ArgKind> &ArgKinds) const override {
ArgKinds.push_back(ArgKind::MakeNodeArg(ThisKind));
- return;
}
bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity = nullptr,
ASTNodeKind *LeastDerivedKind = nullptr) const override {
for (VarDecl *VD : llvm::reverse(DeclsWithEndedScope))
appendScopeEnd(Block, VD, S);
-
- return;
}
/// addAutomaticObjDtors - Add to current block automatic objects destructors
Features["pcrelative-memops"] = true;
Features["prefix-instrs"] = true;
Features["isa-v31-instructions"] = true;
- return;
}
// Add features specific to the "Future" CPU.
void PPCTargetInfo::addFutureSpecificFeatures(
- llvm::StringMap<bool> &Features) const {
- return;
-}
+ llvm::StringMap<bool> &Features) const {}
bool PPCTargetInfo::hasFeature(StringRef Feature) const {
return llvm::StringSwitch<bool>(Feature)
PrivateDecls.push_back(VD);
}
}
- void VisitOMPExecutableDirective(const OMPExecutableDirective *) { return; }
- void VisitCapturedStmt(const CapturedStmt *) { return; }
- void VisitLambdaExpr(const LambdaExpr *) { return; }
- void VisitBlockExpr(const BlockExpr *) { return; }
+ void VisitOMPExecutableDirective(const OMPExecutableDirective *) {}
+ void VisitCapturedStmt(const CapturedStmt *) {}
+ void VisitLambdaExpr(const LambdaExpr *) {}
+ void VisitBlockExpr(const BlockExpr *) {}
void VisitStmt(const Stmt *S) {
if (!S)
return;
// If Loc is invalid, we still need to report the issue, it just gets no
// location info.
Diags.Report(Loc, DiagID).AddString(Message);
- return;
}
bool
getDriver().Diag(clang::diag::err_drv_bad_target_id)
<< PTID.OptionalTargetID.getValue();
}
- return;
}
}
addUnwrappedLine();
- return;
}
// readTokenWithJavaScriptASI reads the next token and terminates the current
diag::warn_maybe_capture_bad_target_this_ptr, Callee,
*this);
}
- return;
}
void Sema::CUDASetLambdaAttrs(CXXMethodDecl *Method) {
return;
// Keep the expected type, only update the location.
ExpectedLoc = Tok;
- return;
}
void PreferredTypeBuilder::enterUnary(Sema &S, SourceLocation Tok,
StringRef BTFTypeTag = StrLiteral->getString();
Type = State.getAttributedType(
::new (Ctx) BTFTypeTagAttr(Ctx, Attr, BTFTypeTag), Type, Type);
- return;
}
/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
if (memcmp(OptArrays, UnoptArrays, kTotalSize))
ErrorAndExit("!!!BUG!!!");
-
- return;
}
void SetPreferredDisplayLanguageIfNeeded(lldb::LanguageType);
protected:
- virtual void DoUpdateChildrenAddressType(ValueObject &valobj) { return; };
+ virtual void DoUpdateChildrenAddressType(ValueObject &valobj){};
private:
virtual CompilerType MaybeCalculateCompleteType();
return false;
}
- virtual void SymbolsDidLoad(const ModuleList &module_list) { return; }
+ virtual void SymbolsDidLoad(const ModuleList &module_list) {}
virtual lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
bool stop_others) = 0;
m_entries.erase(next);
}
}
- return;
}
Collection m_entries;
// navigates to the next or the previous field. This is particularly useful to
// do in-field validation and error setting. Fields with internal navigation
// should call this method on their fields.
- virtual void FieldDelegateExitCallback() { return; }
+ virtual void FieldDelegateExitCallback() {}
// Fields may have internal navigation, for instance, a List Field have
// multiple internal elements, which needs to be navigated. To allow for this
virtual bool FieldDelegateOnLastOrOnlyElement() { return true; }
// Select the first element in the field if multiple elements exists.
- virtual void FieldDelegateSelectFirstElement() { return; }
+ virtual void FieldDelegateSelectFirstElement() {}
// Select the last element in the field if multiple elements exists.
- virtual void FieldDelegateSelectLastElement() { return; }
+ virtual void FieldDelegateSelectLastElement() {}
// Returns true if the field has an error, false otherwise.
virtual bool FieldDelegateHasError() { return false; }
void FieldDelegateSelectLastElement() override {
m_selection_type = SelectionType::NewButton;
- return;
}
int GetNumberOfFields() { return m_fields.size(); }
virtual std::string GetName() = 0;
- virtual void UpdateFieldsVisibility() { return; }
+ virtual void UpdateFieldsVisibility() {}
FieldDelegate *GetField(uint32_t field_index) {
if (field_index < m_fields.size())
void SelectNext() {
if (m_selected_match != m_delegate_sp->GetNumberOfMatches() - 1)
m_selected_match++;
- return;
}
void SelectPrevious() {
if (m_selected_match != 0)
m_selected_match--;
- return;
}
void ExecuteCallback(Window &window) {
virtual void TreeDelegateDrawTreeItem(TreeItem &item, Window &window) = 0;
virtual void TreeDelegateGenerateChildren(TreeItem &item) = 0;
virtual void TreeDelegateUpdateSelection(TreeItem &root, int &selection_index,
- TreeItem *&selected_item) {
- return;
- }
+ TreeItem *&selected_item) {}
// This is invoked when a tree item is selected. If true is returned, the
// views are updated.
virtual bool TreeDelegateItemSelected(TreeItem &item) = 0;
func_addr = m_function_load_addr;
func_end = m_function_end_load_addr;
-
- return;
}
IRExecutionUnit::~IRExecutionUnit() {
error.SetErrorToGenericError();
error.SetErrorString("Couldn't write scalar: its size was zero");
}
- return;
}
void IRMemoryMap::WritePointerToMemory(lldb::addr_t process_address,
error.SetErrorToGenericError();
error.SetErrorString("Couldn't read scalar: its size was zero");
}
- return;
}
void IRMemoryMap::ReadPointerFromMemory(lldb::addr_t *address,
return;
*address = pointer_scalar.ULongLong();
-
- return;
}
void IRMemoryMap::GetMemoryData(DataExtractor &extractor,
ExitWithError(error_fd, "DupDescriptor-dup2");
::close(target_fd);
- return;
}
[[noreturn]] static void ChildFunc(int error_fd,
}
result.SetStatus(eReturnStatusSuccessFinishNoResult);
- return;
}
int CommandInterpreter::GetOptionArgumentPosition(const char *in_string) {
result.SetStatus(eReturnStatusSuccessFinishResult);
m_debugger.SetAsyncExecution(old_async_execution);
-
- return;
}
// Make flags that we can pass into the IOHandler so our delegates can do the
ReadDYLDInfoFromMemoryAndSetNotificationCallback(0x8fe00000);
}
}
- return;
}
// Assume that dyld is in memory at ADDR and try to parse it's load commands
md->removeOriginsWithContext(src_ast);
}
-ClangASTImporter::MapCompleter::~MapCompleter() { return; }
+ClangASTImporter::MapCompleter::~MapCompleter() {}
llvm::Expected<Decl *>
ClangASTImporter::ASTImporterDelegate::ImportImpl(Decl *From) {
// is consulted again when a clang::DeclContext::lookup is called.
const_cast<DeclContext *>(decl_context)->setMustBuildLookupTable();
}
-
- return;
}
void ClangASTSource::FindExternalVisibleDecls(NameSearchContext &context) {
GetExternalCXXBaseSpecifiers(uint64_t Offset) override {
return nullptr;
}
- void MaterializeVisibleDecls(const clang::DeclContext *DC) { return; }
+ void MaterializeVisibleDecls(const clang::DeclContext *DC) {}
void InstallASTContext(TypeSystemClang &ast_context);
return;
context.AddNamedDecl(typedef_decl);
-
- return;
}
void ClangExpressionDeclMap::AddOneType(NameSearchContext &context,
LLDB_LOG(log, " AOEAS::CT Before:\n{1}", ClangUtil::DumpDecl(tag_decl));
LLDB_LOG(log, " AOEAS::CT After:{1}", ClangUtil::DumpDecl(tag_decl));
-
- return;
}
void CompleteType(clang::ObjCInterfaceDecl *interface_decl) override {
LLDB_LOGF(log, " [CT] After:");
LLDB_LOG(log, " [CT] {0}", ClangUtil::DumpDecl(interface_decl));
}
- return;
}
bool layoutRecordType(
return TranslateLanguage(item->m_compile_opts->getLanguage());
}
-void SymbolFileNativePDB::AddSymbols(Symtab &symtab) { return; }
+void SymbolFileNativePDB::AddSymbols(Symtab &symtab) {}
size_t SymbolFileNativePDB::ParseFunctions(CompileUnit &comp_unit) {
std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
}
}
index = UINT32_MAX;
- return;
}
std::unique_ptr<llvm::pdb::PDBSymbolCompiland>
void SymbolFile::GetMangledNamesForFunction(
const std::string &scope_qualified_name,
- std::vector<ConstString> &mangled_names) {
- return;
-}
+ std::vector<ConstString> &mangled_names) {}
void SymbolFile::FindTypes(
ConstString name, const CompilerDeclContext &parent_decl_ctx,
for (int i = stack_size - 1; i > 0; i--) {
DiscardPlan();
}
- return;
}
void ThreadPlanStack::DiscardConsultingControllingPlans() {
// Restore status after calling AddOneMoreFrame
m_unwind_complete = old_m_unwind_complete;
m_candidate_frame = old_m_candidate_frame;
- return;
}
bool UnwindLLDB::AddOneMoreFrame(ABI *abi) {
LLVMOrcIRTransformLayerRef IRLayer = LLVMOrcLLJITGetIRTransformLayer(J);
LLVMOrcIRTransformLayerEmit(IRLayer, MR, TSM);
}
- return;
}
int main(int argc, char *argv[]) {
appendVectorElts(AllElts, Leftover);
MIRBuilder.buildMerge(DstReg, AllElts);
- return;
}
/// Append the result registers of G_UNMERGE_VALUES \p MI to \p Regs.
U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(), MRI,
Ctx.getDWARFObj(), U, DumpOpts,
Indent);
- return;
}
static void dumpLocationExpr(raw_ostream &OS, const DWARFFormValue &FormValue,
Ctx.isLittleEndian(), 0);
DWARFExpression(Data, U->getAddressByteSize(), U->getFormParams().Format)
.print(OS, DumpOpts, MRI, U);
- return;
}
static DWARFDie resolveReferencedType(DWARFDie D,
}
Src1Elts.setBit(i);
Src1Identity &= (M == (i + NumSrcElts));
- continue;
}
assert((Src0Elts | Src1Elts | UndefElts).isAllOnes() &&
"unknown shuffle elements");
}
MI.eraseFromParent();
- return;
}
OffsetLo->setVariableValue(MCBinaryExpr::createAnd(Offset, Mask, MCCtx));
auto *ShAmt = MCConstantExpr::create(32, MCCtx);
OffsetHi->setVariableValue(MCBinaryExpr::createAShr(Offset, ShAmt, MCCtx));
-
- return;
}
unsigned SIInstrInfo::getBranchOpcode(SIInstrInfo::BranchPredicate Cond) {
// See lib/CodeGen/RegisterRelaxation.cpp for details.
// We end up here when a jump is too long for a RJMP instruction.
BuildMI(&MBB, DL, get(AVR::JMPk)).addMBB(&NewDestBB);
-
- return;
}
} // end of namespace llvm
isl_sioimath_bigarg_src(rhs, &rhsscratch),
isl_sioimath_reinit_big(dst), NULL);
isl_sioimath_try_demote(dst);
- return;
}
/* Divide lhs by an unsigned long rhs, rounding to zero (Truncate).
}
// not a loop transformation; look for next property
- continue;
}
}
projects / platform / upstream / llvm.git / commitdiff