Remove or use variables which are unused but set.

[mbenfield]

Summary

This is in preparation for the -Wunused-but-set-variable warning.

[mbenfield]

Several variables I have just removed outright, including

llvm/lib/Target/X86/X86FloatingPoint.cpp: STDeadDefs
lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp: fp_bytes
lldb/source/Interpreter/CommandInterpreter.cpp: actual_cmd_name_len

Someone familiar with this code should probably look at these and determine whether these variables not being used could have lead to buggy behavior.

[dblaikie]

Sure, all sounds good - if you can, please reach out to the authors of any of the semantics changing changes (the ones related to the Changed values in transformations) to see if they could add missing test coverage.

llvm/lib/Target/AArch64/GISel/AArch64PostSelectOptimize.cpp

183

Might want to CC/respond to whoever wrote this to see if someone missed test coverage for this code.

llvm/lib/Target/ARM/ARMLowOverheadLoops.cpp

1227–1230

Maybe in a separate patch would be good to switch this around to:

if (!LoLoop.Preheader)
  return Changed;
LoLoop.Start = SearchForStart(LoLoop.Preheader);

1230

Also might be worth reaching out to authors to check that this change is intended & possibly tested.

[teemperor]

ABISysV_ppc.cpp feels a bit like this should be used to calculate some offset, but I don't think that's for this review to figure out what is wrong there. The other LLDB changes LGTM.

lldb/source/Interpreter/CommandInterpreter.cpp

3104

Was already checked in unused and I don't see what we would need that for, LGTM.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

342

This code was apparently rendered obsolete by 89870cebcb0c9996f49336a21e72b80511f37341 so LGTM

[mbenfield]

In D102942#2774819, @dblaikie wrote:

Sure, all sounds good - if you can, please reach out to the authors of any of the semantics changing changes (the ones related to the Changed values in transformations) to see if they could add missing test coverage.

Sure, I emailed Sam Parker and Amara Emerson.

[lebedev.ri]

(removing from my queue - i don't expect to provide any review here)

[samparker]

llvm/lib/Target/ARM/ARMLowOverheadLoops.cpp

1230

Ah, yes this should be fine. The Changed value would only be used by the pipeline manager and this pass is the last transform in the Arm pipeline.

[mbenfield]

I also heard via email from Amara Emerson that the change is fine for similar reasons.

[dblaikie]

In D102942#2791204, @mbenfield wrote:

I also heard via email from Amara Emerson that the change is fine for similar reasons.

Great, thanks for checking!

lldb/source/Interpreter/CommandInterpreter.cpp

 CommandObject *
 CommandInterpreter::ResolveCommandImpl(std::string &command_line,
                                        CommandReturnObject &result) {
   std::string scratch_command(command_line); // working copy so we don't modify
                                              // command_line unless we succeed
   CommandObject *cmd_obj = nullptr;
   StreamString revised_command_line;
   bool wants_raw_input = false;
-  size_t actual_cmd_name_len = 0;
   std::string next_word;
   StringList matches;
   bool done = false;
   while (!done) {
     char quote_char = '\0';
     std::string suffix;
     ExtractCommand(scratch_command, next_word, suffix, quote_char);
     if (cmd_obj == nullptr) {
       std::string full_name;
       bool is_alias = GetAliasFullName(next_word, full_name);
       cmd_obj = GetCommandObject(next_word, &matches);
       bool is_real_command =
           (!is_alias) || (cmd_obj != nullptr && !cmd_obj->IsAlias());
       if (!is_real_command) {
         matches.Clear();
         std::string alias_result;
         cmd_obj =
             BuildAliasResult(full_name, scratch_command, alias_result, result);
         revised_command_line.Printf("%s", alias_result.c_str());
         if (cmd_obj) {
           wants_raw_input = cmd_obj->WantsRawCommandString();
-          actual_cmd_name_len = cmd_obj->GetCommandName().size();
         }
       } else {
         if (cmd_obj) {
           llvm::StringRef cmd_name = cmd_obj->GetCommandName();
-          actual_cmd_name_len += cmd_name.size();
           revised_command_line.Printf("%s", cmd_name.str().c_str());
           wants_raw_input = cmd_obj->WantsRawCommandString();
         } else {
           revised_command_line.Printf("%s", next_word.c_str());
         }
       }
     } else {
       if (cmd_obj->IsMultiwordObject()) {
         CommandObject *sub_cmd_obj =
             cmd_obj->GetSubcommandObject(next_word.c_str());
         if (sub_cmd_obj) {
           // The subcommand's name includes the parent command's name, so
           // restart rather than append to the revised_command_line.
           llvm::StringRef sub_cmd_name = sub_cmd_obj->GetCommandName();
-          actual_cmd_name_len = sub_cmd_name.size() + 1;
           revised_command_line.Clear();
           revised_command_line.Printf("%s", sub_cmd_name.str().c_str());
           cmd_obj = sub_cmd_obj;
           wants_raw_input = cmd_obj->WantsRawCommandString();
         } else {
           if (quote_char)
             revised_command_line.Printf(" %c%s%s%c", quote_char,
                                         next_word.c_str(), suffix.c_str(),

lldb/source/Plugins/ABI/PowerPC/ABISysV_ppc.cpp

if (*bit_width <= 128) {
       reg_ctx_sp->ReadRegister(r3_info, r3_value);
       reg_ctx_sp->ReadRegister(rdx_info, rdx_value);
 
       DataExtractor r3_data, rdx_data;
 
       r3_value.GetData(r3_data);
       rdx_value.GetData(rdx_data);
 
-      uint32_t fp_bytes =
-          0; // Tracks how much of the xmm registers we've consumed so far
       uint32_t integer_bytes =
           0; // Tracks how much of the r3/rds registers we've consumed so far
 
       const uint32_t num_children = return_compiler_type.GetNumFields();
 
       // Since we are in the small struct regime, assume we are not in memory.
       is_memory = false;
 
if (*bit_width <= 128) {
           }
         } else if (field_compiler_type.IsFloatingPointType(count, is_complex)) {
           // Structs with long doubles are always passed in memory.
           if (*field_bit_width == 128) {
             is_memory = true;
             break;
           } else if (*field_bit_width == 64) {
             copy_from_offset = 0;
-            fp_bytes += field_byte_width;
           } else if (*field_bit_width == 32) {
             // This one is kind of complicated.  If we are in an "eightbyte"
             // with another float, we'll be stuffed into an xmm register with
             // it.  If we are in an "eightbyte" with one or more ints, then we
             // will be stuffed into the appropriate GPR with them.
             bool in_gpr;
             if (field_byte_offset % 8 == 0) {
               // We are at the beginning of one of the eightbytes, so check the
if (*bit_width <= 128) {
                 copy_from_extractor = &r3_data;
                 copy_from_offset = integer_bytes;
                 integer_bytes += field_byte_width;
               } else {
                 copy_from_extractor = &rdx_data;
                 copy_from_offset = integer_bytes - 8;
                 integer_bytes += field_byte_width;
               }
-            } else {
-              fp_bytes += field_byte_width;
             }
           }
         }
 
         // These two tests are just sanity checks.  If I somehow get the type
         // calculation wrong above it is better to just return nothing than to
         // assert or crash.
         if (!copy_from_extractor)

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV1.cpp

if (process) {
 
     ProcessSP process_sp = process->shared_from_this();
 
     ModuleSP objc_module_sp(GetObjCModule());
 
     if (!objc_module_sp)
       return;
 
-    uint32_t isa_count = 0;
-
     lldb::addr_t hash_table_ptr = GetISAHashTablePointer();
     if (hash_table_ptr != LLDB_INVALID_ADDRESS) {
       // Read the NXHashTable struct:
       //
       // typedef struct {
       //     const NXHashTablePrototype *prototype;
       //     unsigned   count;
       //     unsigned   nbBuckets;
if (hash_table_ptr != LLDB_INVALID_ADDRESS) {
             for (uint32_t bucket_idx = 0; bucket_idx < num_buckets;
                  ++bucket_idx) {
               const uint32_t bucket_isa_count = data.GetU32(&offset);
               const lldb::addr_t bucket_data = data.GetU32(&offset);
 
               if (bucket_isa_count == 0)
                 continue;
 
-              isa_count += bucket_isa_count;
-
               ObjCISA isa;
               if (bucket_isa_count == 1) {
                 // When we only have one entry in the bucket, the bucket data
                 // is the "isa"
                 isa = bucket_data;
                 if (isa) {
                   if (!ISAIsCached(isa)) {
                     ClassDescriptorSP descriptor_sp(

llvm/lib/Target/AArch64/GISel/AArch64PostSelectOptimize.cpp

if (MF.getProperties().hasProperty(
     return false;
   assert(MF.getProperties().hasProperty(
              MachineFunctionProperties::Property::Selected) &&
          "Expected a selected MF");
 
   bool Changed = false;
   for (auto &BB : MF)
     Changed |= optimizeNZCVDefs(BB);
-  return true;
+  return Changed;
 }
 
 char AArch64PostSelectOptimize::ID = 0;
 INITIALIZE_PASS_BEGIN(AArch64PostSelectOptimize, DEBUG_TYPE,
                       "Optimize AArch64 selected instructions",
                       false, false)
 INITIALIZE_PASS_END(AArch64PostSelectOptimize, DEBUG_TYPE,
                     "Optimize AArch64 selected instructions", false,
                     false)
 
 namespace llvm {
 FunctionPass *createAArch64PostSelectOptimize() {
   return new AArch64PostSelectOptimize();
 }
 } // end namespace llvm

llvm/lib/Target/ARM/ARMISelLowering.cpp

case 32:
     // caller would also need to check and handle the change in size.
     return SDValue();
 
   case 64: {
     if (type != VMOVModImm)
       return SDValue();
     // NEON has a 64-bit VMOV splat where each byte is either 0 or 0xff.
     uint64_t BitMask = 0xff;
-    uint64_t Val = 0;
     unsigned ImmMask = 1;
     Imm = 0;
     for (int ByteNum = 0; ByteNum < 8; ++ByteNum) {
       if (((SplatBits | SplatUndef) & BitMask) == BitMask) {
-        Val |= BitMask;
         Imm |= ImmMask;
       } else if ((SplatBits & BitMask) != 0) {
         return SDValue();
       }
       BitMask <<= 8;
       ImmMask <<= 1;
     }
 

llvm/lib/Target/ARM/ARMLowOverheadLoops.cpp

if (MBB->pred_size() == 1)
       return SearchForStart(*MBB->pred_begin());
     return nullptr;
   };
 
   LowOverheadLoop LoLoop(*ML, *MLI, *RDA, *TRI, *TII);
   // Search the preheader for the start intrinsic.
   // FIXME: I don't see why we shouldn't be supporting multiple predecessors
   // with potentially multiple set.loop.iterations, so we need to enable this.
   if (LoLoop.Preheader)
     LoLoop.Start = SearchForStart(LoLoop.Preheader);
   else
-    return false;
+    return Changed;
 
   // Find the low-overhead loop components and decide whether or not to fall
   // back to a normal loop. Also look for a vctp instructions and decide
   // whether we can convert that predicate using tail predication.
   for (auto *MBB : reverse(ML->getBlocks())) {
     for (auto &MI : *MBB) {
       if (MI.isDebugValue())
         continue;
for (auto &MI : *MBB) {
         LoLoop.AnalyseMVEInst(&MI);
       }
     }
   }
 
   LLVM_DEBUG(LoLoop.dump());
   if (!LoLoop.FoundAllComponents()) {
     LLVM_DEBUG(dbgs() << "ARM Loops: Didn't find loop start, update, end\n");
-    return false;
+    return Changed;
   }
 
   assert(LoLoop.Start->getOpcode() != ARM::t2WhileLoopStart &&
          "Expected t2WhileLoopStart to be removed before regalloc!");
 
   // Check that the only instruction using LoopDec is LoopEnd. This can only
   // happen when the Dec and End are separate, not a single t2LoopEndDec.
   // TODO: Check for copy chains that really have no effect.

llvm/lib/Target/PowerPC/PPCBranchSelector.cpp

if (MadeChange) {
       // padding-based contributions to the block sizes.
       modifyAdjustment(Fn);
     }
 
     EverMadeChange |= MadeChange;
   }
 
   BlockSizes.clear();
-  return true;
+  return EverMadeChange;
 }

llvm/lib/Target/X86/X86FloatingPoint.cpp

case TargetOpcode::INLINEASM_BR: {
     //
     // Outputs must be in ST registers, FP outputs are not allowed. Clobbered
     // registers do not count as output operands. The inline asm changes the
     // stack as if it popped all the popped inputs and then pushed all the
     // output operands.
 
     // Scan the assembly for ST registers used, defined and clobbered. We can
     // only tell clobbers from defs by looking at the asm descriptor.
-    unsigned STUses = 0, STDefs = 0, STClobbers = 0, STDeadDefs = 0;
+    unsigned STUses = 0, STDefs = 0, STClobbers = 0;
     unsigned NumOps = 0;
     SmallSet<unsigned, 1> FRegIdx;
     unsigned RCID;
 
     for (unsigned i = InlineAsm::MIOp_FirstOperand, e = MI.getNumOperands();
          i != e && MI.getOperand(i).isImm(); i += 1 + NumOps) {
       unsigned Flags = MI.getOperand(i).getImm();
 
for (unsigned i = InlineAsm::MIOp_FirstOperand, e = MI.getNumOperands();
 
       switch (InlineAsm::getKind(Flags)) {
       case InlineAsm::Kind_RegUse:
         STUses |= (1u << STReg);
         break;
       case InlineAsm::Kind_RegDef:
       case InlineAsm::Kind_RegDefEarlyClobber:
         STDefs |= (1u << STReg);
-        if (MO.isDead())
-          STDeadDefs |= (1u << STReg);
         break;
       case InlineAsm::Kind_Clobber:
         STClobbers |= (1u << STReg);
         break;
       default:
         break;
       }
     }

llvm/utils/benchmark/src/complexity.cc

 //   - fitting_curve : lambda expression (e.g. [](int64_t n) {return n; };).
 
 // For a deeper explanation on the algorithm logic, look the README file at
 // http://github.com/ismaelJimenez/Minimal-Cpp-Least-Squared-Fit
 
 LeastSq MinimalLeastSq(const std::vector<int64_t>& n,
                        const std::vector<double>& time,
                        BigOFunc* fitting_curve) {
-  double sigma_gn = 0.0;
   double sigma_gn_squared = 0.0;
   double sigma_time = 0.0;
   double sigma_time_gn = 0.0;
 
   // Calculate least square fitting parameter
   for (size_t i = 0; i < n.size(); ++i) {
     double gn_i = fitting_curve(n[i]);
-    sigma_gn += gn_i;
     sigma_gn_squared += gn_i * gn_i;
     sigma_time += time[i];
     sigma_time_gn += time[i] * gn_i;
   }
 
   LeastSq result;
   result.complexity = oLambda;