llvm.org GIT mirror llvm / 7d7a23e
Replace a few more "fall through" comments with LLVM_FALLTHROUGH Follow up to r278902. I had missed "fall through", with a space. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@278970 91177308-0d34-0410-b5e6-96231b3b80d8 Justin Bogner 3 years ago
52 changed file(s) with 218 addition(s) and 170 deletion(s). Raw diff Collapse all Expand all
338338 switch(c) {
339339 case '-':
340340 direction = -1;
341 // Fall through
341 LLVM_FALLTHROUGH;
342342
343343 case '+':
344344 if (cursym == SYM_CHANGE) {
359359
360360 case '<':
361361 direction = -1;
362 // Fall through
362 LLVM_FALLTHROUGH;
363363
364364 case '>':
365365 if (cursym == SYM_MOVE) {
226226 Offset = 0;
227227 return V;
228228 }
229 // FALL THROUGH.
229 LLVM_FALLTHROUGH;
230230 case Instruction::Add:
231231 V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, ZExtBits,
232232 SExtBits, DL, Depth + 1, AC, DT, NSW, NUW);
10091009 MemoryDependenceResults::NonLocalDepInfo::iterator Entry =
10101010 std::upper_bound(Cache.begin(), Cache.end() - 1, Val);
10111011 Cache.insert(Entry, Val);
1012 // FALL THROUGH.
1012 LLVM_FALLTHROUGH;
10131013 }
10141014 case 1:
10151015 // One new entry, Just insert the new value at the appropriate position.
42874287 case ICmpInst::ICMP_SLT:
42884288 case ICmpInst::ICMP_SLE:
42894289 std::swap(LHS, RHS);
4290 // fall through
4290 LLVM_FALLTHROUGH;
42914291 case ICmpInst::ICMP_SGT:
42924292 case ICmpInst::ICMP_SGE:
42934293 // a >s b ? a+x : b+x -> smax(a, b)+x
43104310 case ICmpInst::ICMP_ULT:
43114311 case ICmpInst::ICMP_ULE:
43124312 std::swap(LHS, RHS);
4313 // fall through
4313 LLVM_FALLTHROUGH;
43144314 case ICmpInst::ICMP_UGT:
43154315 case ICmpInst::ICMP_UGE:
43164316 // a >u b ? a+x : b+x -> umax(a, b)+x
85018501
85028502 case ICmpInst::ICMP_SGE:
85038503 std::swap(LHS, RHS);
8504 // fall through
8504 LLVM_FALLTHROUGH;
85058505 case ICmpInst::ICMP_SLE:
85068506 return
85078507 // min(A, ...) <= A
85118511
85128512 case ICmpInst::ICMP_UGE:
85138513 std::swap(LHS, RHS);
8514 // fall through
8514 LLVM_FALLTHROUGH;
85158515 case ICmpInst::ICMP_ULE:
85168516 return
85178517 // min(A, ...) <= A
98579857 const SCEVAddRecExpr *AR = cast(S);
98589858 if (!DT.dominates(AR->getLoop()->getHeader(), BB))
98599859 return DoesNotDominateBlock;
9860 }
9861 // FALL THROUGH into SCEVNAryExpr handling.
9860
9861 // Fall through into SCEVNAryExpr handling.
9862 LLVM_FALLTHROUGH;
9863 }
98629864 case scAddExpr:
98639865 case scMulExpr:
98649866 case scUMaxExpr:
323323 // on Linux.
324324 //
325325 // Fall through to disable all of them.
326 LLVM_FALLTHROUGH;
326327 default:
327328 TLI.setUnavailable(LibFunc::exp10);
328329 TLI.setUnavailable(LibFunc::exp10f);
10111011 case Instruction::PtrToInt:
10121012 case Instruction::IntToPtr:
10131013 case Instruction::AddrSpaceCast: // Pointers could be different sizes.
1014 // FALL THROUGH and handle them the same as zext/trunc.
1014 // Fall through and handle them the same as zext/trunc.
1015 LLVM_FALLTHROUGH;
10151016 case Instruction::ZExt:
10161017 case Instruction::Trunc: {
10171018 Type *SrcTy = I->getOperand(0)->getType();
25582559 // x*x is always non-negative or a NaN.
25592560 if (I->getOperand(0) == I->getOperand(1))
25602561 return true;
2561 // Fall through
2562 LLVM_FALLTHROUGH;
25622563 case Instruction::FAdd:
25632564 case Instruction::FDiv:
25642565 case Instruction::FRem:
17831783 // expression properly. This is important for differences between
17841784 // blockaddress labels. Since the two labels are in the same function, it
17851785 // is reasonable to treat their delta as a 32-bit value.
1786 // FALL THROUGH.
1786 LLVM_FALLTHROUGH;
17871787 case Instruction::BitCast:
17881788 return lowerConstant(CE->getOperand(0));
17891789
246246 // FIXME: Is there a better way to do this?
247247 Asm->OutStreamer->AddBlankLine();
248248 return;
249 case dwarf::DW_FORM_flag: // Fall thru
250 case dwarf::DW_FORM_ref1: // Fall thru
249 case dwarf::DW_FORM_flag: LLVM_FALLTHROUGH;
250 case dwarf::DW_FORM_ref1: LLVM_FALLTHROUGH;
251251 case dwarf::DW_FORM_data1: Size = 1; break;
252 case dwarf::DW_FORM_ref2: // Fall thru
252 case dwarf::DW_FORM_ref2: LLVM_FALLTHROUGH;
253253 case dwarf::DW_FORM_data2: Size = 2; break;
254 case dwarf::DW_FORM_sec_offset: // Fall thru
255 case dwarf::DW_FORM_strp: // Fall thru
256 case dwarf::DW_FORM_ref4: // Fall thru
254 case dwarf::DW_FORM_sec_offset: LLVM_FALLTHROUGH;
255 case dwarf::DW_FORM_strp: LLVM_FALLTHROUGH;
256 case dwarf::DW_FORM_ref4: LLVM_FALLTHROUGH;
257257 case dwarf::DW_FORM_data4: Size = 4; break;
258 case dwarf::DW_FORM_ref8: // Fall thru
259 case dwarf::DW_FORM_ref_sig8: // Fall thru
258 case dwarf::DW_FORM_ref8: LLVM_FALLTHROUGH;
259 case dwarf::DW_FORM_ref_sig8: LLVM_FALLTHROUGH;
260260 case dwarf::DW_FORM_data8: Size = 8; break;
261261 case dwarf::DW_FORM_GNU_str_index: Asm->EmitULEB128(Integer); return;
262262 case dwarf::DW_FORM_GNU_addr_index: Asm->EmitULEB128(Integer); return;
278278 unsigned DIEInteger::SizeOf(const AsmPrinter *AP, dwarf::Form Form) const {
279279 switch (Form) {
280280 case dwarf::DW_FORM_flag_present: return 0;
281 case dwarf::DW_FORM_flag: // Fall thru
282 case dwarf::DW_FORM_ref1: // Fall thru
281 case dwarf::DW_FORM_flag: LLVM_FALLTHROUGH;
282 case dwarf::DW_FORM_ref1: LLVM_FALLTHROUGH;
283283 case dwarf::DW_FORM_data1: return sizeof(int8_t);
284 case dwarf::DW_FORM_ref2: // Fall thru
284 case dwarf::DW_FORM_ref2: LLVM_FALLTHROUGH;
285285 case dwarf::DW_FORM_data2: return sizeof(int16_t);
286 case dwarf::DW_FORM_sec_offset: // Fall thru
287 case dwarf::DW_FORM_strp: // Fall thru
288 case dwarf::DW_FORM_ref4: // Fall thru
286 case dwarf::DW_FORM_sec_offset: LLVM_FALLTHROUGH;
287 case dwarf::DW_FORM_strp: LLVM_FALLTHROUGH;
288 case dwarf::DW_FORM_ref4: LLVM_FALLTHROUGH;
289289 case dwarf::DW_FORM_data4: return sizeof(int32_t);
290 case dwarf::DW_FORM_ref8: // Fall thru
291 case dwarf::DW_FORM_ref_sig8: // Fall thru
290 case dwarf::DW_FORM_ref8: LLVM_FALLTHROUGH;
291 case dwarf::DW_FORM_ref_sig8: LLVM_FALLTHROUGH;
292292 case dwarf::DW_FORM_data8: return sizeof(int64_t);
293293 case dwarf::DW_FORM_GNU_str_index: return getULEB128Size(Integer);
294294 case dwarf::DW_FORM_GNU_addr_index: return getULEB128Size(Integer);
359359 break;
360360 case regReserved:
361361 PhysRegState[PhysReg] = regFree;
362 // Fall through
362 LLVM_FALLTHROUGH;
363363 case regFree:
364364 MO.setIsKill();
365365 return;
388388 assert((TRI->isSuperRegister(PhysReg, Alias) ||
389389 TRI->isSuperRegister(Alias, PhysReg)) &&
390390 "Instruction is not using a subregister of a reserved register");
391 // Fall through.
391 LLVM_FALLTHROUGH;
392392 case regFree:
393393 if (TRI->isSuperRegister(PhysReg, Alias)) {
394394 // Leave the superregister in the working set.
420420 break;
421421 default:
422422 spillVirtReg(MI, VirtReg);
423 // Fall through.
423 LLVM_FALLTHROUGH;
424424 case regFree:
425425 case regReserved:
426426 PhysRegState[PhysReg] = NewState;
436436 break;
437437 default:
438438 spillVirtReg(MI, VirtReg);
439 // Fall through.
439 LLVM_FALLTHROUGH;
440440 case regFree:
441441 case regReserved:
442442 PhysRegState[Alias] = regDisabled;
22302230 if ((OtherV.WriteLanes & ~V.ValidLanes) != 0 && TrackSubRegLiveness)
22312231 OtherV.ErasableImplicitDef = false;
22322232 OtherV.Pruned = true;
2233 }
2234 // Fall through.
2233 LLVM_FALLTHROUGH;
2234 }
22352235 default:
22362236 // This value number needs to go in the final joined live range.
22372237 Assignments[ValNo] = NewVNInfo.size();
25162516 // make it appear like an unused value number.
25172517 VNI->markUnused();
25182518 DEBUG(dbgs() << "\t\tremoved " << i << '@' << Def << ": " << LR << '\n');
2519 // FALL THROUGH.
2519 LLVM_FALLTHROUGH;
25202520 }
25212521
25222522 case CR_Erase: {
15781578 Changed = true;
15791579 break;
15801580 }
1581 // Fall thru
1581 LLVM_FALLTHROUGH;
15821582
15831583 default:
15841584 // Only add if it isn't already in the list.
11221122 ReplaceNode(Node, ResultVals.data());
11231123 return;
11241124 }
1125 }
1126 // FALL THROUGH
1125 LLVM_FALLTHROUGH;
1126 }
11271127 case TargetLowering::Expand:
11281128 if (ExpandNode(Node))
11291129 return;
1130 // FALL THROUGH
1130 LLVM_FALLTHROUGH;
11311131 case TargetLowering::LibCall:
11321132 ConvertNodeToLibcall(Node);
11331133 return;
361361 Result = Tmp1;
362362 break;
363363 }
364 // FALL THROUGH
364 LLVM_FALLTHROUGH;
365365 }
366366 case TargetLowering::Expand:
367367 Result = Expand(Op);
19421942 default: break;
19431943 case ISD::SETEQ: if (R==APFloat::cmpUnordered)
19441944 return getUNDEF(VT);
1945 // fall through
1945 LLVM_FALLTHROUGH;
19461946 case ISD::SETOEQ: return getConstant(R==APFloat::cmpEqual, dl, VT);
19471947 case ISD::SETNE: if (R==APFloat::cmpUnordered)
19481948 return getUNDEF(VT);
1949 // fall through
1949 LLVM_FALLTHROUGH;
19501950 case ISD::SETONE: return getConstant(R==APFloat::cmpGreaterThan ||
19511951 R==APFloat::cmpLessThan, dl, VT);
19521952 case ISD::SETLT: if (R==APFloat::cmpUnordered)
19531953 return getUNDEF(VT);
1954 // fall through
1954 LLVM_FALLTHROUGH;
19551955 case ISD::SETOLT: return getConstant(R==APFloat::cmpLessThan, dl, VT);
19561956 case ISD::SETGT: if (R==APFloat::cmpUnordered)
19571957 return getUNDEF(VT);
1958 // fall through
1958 LLVM_FALLTHROUGH;
19591959 case ISD::SETOGT: return getConstant(R==APFloat::cmpGreaterThan, dl, VT);
19601960 case ISD::SETLE: if (R==APFloat::cmpUnordered)
19611961 return getUNDEF(VT);
1962 // fall through
1962 LLVM_FALLTHROUGH;
19631963 case ISD::SETOLE: return getConstant(R==APFloat::cmpLessThan ||
19641964 R==APFloat::cmpEqual, dl, VT);
19651965 case ISD::SETGE: if (R==APFloat::cmpUnordered)
19661966 return getUNDEF(VT);
1967 // fall through
1967 LLVM_FALLTHROUGH;
19681968 case ISD::SETOGE: return getConstant(R==APFloat::cmpGreaterThan ||
19691969 R==APFloat::cmpEqual, dl, VT);
19701970 case ISD::SETO: return getConstant(R!=APFloat::cmpUnordered, dl, VT);
23492349 }
23502350 }
23512351 }
2352 }
2353 // fall through
2352 LLVM_FALLTHROUGH;
2353 }
23542354 case ISD::ADD:
23552355 case ISD::ADDE: {
23562356 // Output known-0 bits are known if clear or set in both the low clear bits
24812481 if (const FPMathOperator *FPOp = dyn_cast(Inst))
24822482 if (FPOp->getFastMathFlags().unsafeAlgebra())
24832483 break;
2484 // Fall through.
2484 LLVM_FALLTHROUGH;
24852485 default:
24862486 return false;
24872487 }
92429242 lowerWorkItem(W, SI.getCondition(), SwitchMBB, DefaultMBB);
92439243 }
92449244 }
9245
11461146 // See if the operation should be performed at a smaller bit width.
11471147 if (TLO.ShrinkDemandedOp(Op, BitWidth, NewMask, dl))
11481148 return true;
1149 }
1150 // FALL THROUGH
1149 LLVM_FALLTHROUGH;
1150 }
11511151 default:
11521152 // Just use computeKnownBits to compute output bits.
11531153 TLO.DAG.computeKnownBits(Op, KnownZero, KnownOne, Depth);
23002300 Ops.push_back(Op);
23012301 return;
23022302 }
2303 // fall through
2303 LLVM_FALLTHROUGH;
23042304 case 'i': // Simple Integer or Relocatable Constant
23052305 case 'n': // Simple Integer
23062306 case 's': { // Relocatable Constant
285285 NewSize = InsertPartOf(O.data(), O.size(), U.data(), U.size(), MaxSize);
286286 if (NewSize)
287287 break;
288 // Fallthrough
288 LLVM_FALLTHROUGH;
289289 case 2:
290290 NewSize = CopyPartOf(O.data(), O.size(), U.data(), U.size());
291291 break;
747747 case IIT_EMPTYSTRUCT:
748748 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct, 0));
749749 return;
750 case IIT_STRUCT5: ++StructElts; // FALL THROUGH.
751 case IIT_STRUCT4: ++StructElts; // FALL THROUGH.
752 case IIT_STRUCT3: ++StructElts; // FALL THROUGH.
750 case IIT_STRUCT5: ++StructElts; LLVM_FALLTHROUGH;
751 case IIT_STRUCT4: ++StructElts; LLVM_FALLTHROUGH;
752 case IIT_STRUCT3: ++StructElts; LLVM_FALLTHROUGH;
753753 case IIT_STRUCT2: {
754754 OutputTable.push_back(IITDescriptor::get(IITDescriptor::Struct,StructElts));
755755
310310 if (Ctx->getAsmInfo()->getExceptionHandlingType() == ExceptionHandling::ARM)
311311 break;
312312 // Fallthrough if not using EHABI
313 LLVM_FALLTHROUGH;
313314 case Triple::ppc:
314315 case Triple::x86:
315316 PersonalityEncoding = PositionIndependent
12271227 switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
12281228 case cl::Optional:
12291229 Done = true; // Optional arguments want _at most_ one value
1230 // FALL THROUGH
1230 LLVM_FALLTHROUGH;
12311231 case cl::ZeroOrMore: // Zero or more will take all they can get...
12321232 case cl::OneOrMore: // One or more will take all they can get...
12331233 ProvidePositionalOption(PositionalOpts[i],
12811281 Opt.second->error("must be specified at least once!");
12821282 ErrorParsing = true;
12831283 }
1284 // Fall through
1284 LLVM_FALLTHROUGH;
12851285 default:
12861286 break;
12871287 }
13361336 case Required:
13371337 if (NumOccurrences > 1)
13381338 return error("must occur exactly one time!", ArgName);
1339 // Fall through
1339 LLVM_FALLTHROUGH;
13401340 case OneOrMore:
13411341 case ZeroOrMore:
13421342 case ConsumeAfter:
126126 // Pos will have overshot size by 4 - #bytes left over.
127127 // No need to take endianness into account here - this is always executed.
128128 switch (Pos - Size) {
129 case 1: V = (V << 8) | (unsigned char)String[Size - 3]; // Fall thru.
130 case 2: V = (V << 8) | (unsigned char)String[Size - 2]; // Fall thru.
129 case 1: V = (V << 8) | (unsigned char)String[Size - 3]; LLVM_FALLTHROUGH;
130 case 2: V = (V << 8) | (unsigned char)String[Size - 2]; LLVM_FALLTHROUGH;
131131 case 3: V = (V << 8) | (unsigned char)String[Size - 1]; break;
132132 default: return; // Nothing left.
133133 }
343343 // Handle short strings specially, memcpy isn't very good at very short
344344 // strings.
345345 switch (Size) {
346 case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH
347 case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH
348 case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH
349 case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH
346 case 4: OutBufCur[3] = Ptr[3]; LLVM_FALLTHROUGH;
347 case 3: OutBufCur[2] = Ptr[2]; LLVM_FALLTHROUGH;
348 case 2: OutBufCur[1] = Ptr[1]; LLVM_FALLTHROUGH;
349 case 1: OutBufCur[0] = Ptr[0]; LLVM_FALLTHROUGH;
350350 case 0: break;
351351 default:
352352 memcpy(OutBufCur, Ptr, Size);
221221 case '\0':
222222 if (CurPtr == CurBuf.end())
223223 return ReturnError(StrStart, "End of file in string literal");
224 // FALL THROUGH
224 LLVM_FALLTHROUGH;
225225 default:
226226 return ReturnError(CurPtr, "invalid escape in string literal");
227227 }
328328 ++NumImmRangeRejs;
329329 return nullptr;
330330 }
331 // Fall through.
331 LLVM_FALLTHROUGH;
332332 case AArch64::SUBSWrr:
333333 case AArch64::SUBSXrr:
334334 case AArch64::ADDSWrr:
70567056 // trunc(sext ty1 to ty2) to ty1.
70577057 if (Instr->getType() == Ext->getOperand(0)->getType())
70587058 continue;
7059 // FALL THROUGH.
7059 LLVM_FALLTHROUGH;
70607060 default:
70617061 return false;
70627062 }
285285 if (STM.getGeneration() >= R600Subtarget::EVERGREEN) {
286286 // Evergreen / Northern Islands
287287 switch (MF.getFunction()->getCallingConv()) {
288 default: // Fall through
288 default: LLVM_FALLTHROUGH;
289289 case CallingConv::AMDGPU_CS: RsrcReg = R_0288D4_SQ_PGM_RESOURCES_LS; break;
290290 case CallingConv::AMDGPU_GS: RsrcReg = R_028878_SQ_PGM_RESOURCES_GS; break;
291291 case CallingConv::AMDGPU_PS: RsrcReg = R_028844_SQ_PGM_RESOURCES_PS; break;
294294 } else {
295295 // R600 / R700
296296 switch (MF.getFunction()->getCallingConv()) {
297 default: // Fall through
298 case CallingConv::AMDGPU_GS: // Fall through
299 case CallingConv::AMDGPU_CS: // Fall through
297 default: LLVM_FALLTHROUGH;
298 case CallingConv::AMDGPU_GS: LLVM_FALLTHROUGH;
299 case CallingConv::AMDGPU_CS: LLVM_FALLTHROUGH;
300300 case CallingConv::AMDGPU_VS: RsrcReg = R_028868_SQ_PGM_RESOURCES_VS; break;
301301 case CallingConv::AMDGPU_PS: RsrcReg = R_028850_SQ_PGM_RESOURCES_PS; break;
302302 }
573573
574574 static unsigned getRsrcReg(CallingConv::ID CallConv) {
575575 switch (CallConv) {
576 default: // Fall through
576 default: LLVM_FALLTHROUGH;
577577 case CallingConv::AMDGPU_CS: return R_00B848_COMPUTE_PGM_RSRC1;
578578 case CallingConv::AMDGPU_GS: return R_00B228_SPI_SHADER_PGM_RSRC1_GS;
579579 case CallingConv::AMDGPU_PS: return R_00B028_SPI_SHADER_PGM_RSRC1_PS;
18671867 return (Return ? RetCC_ARM_AAPCS_VFP: CC_ARM_AAPCS_VFP);
18681868 // Fall through to soft float variant, variadic functions don't
18691869 // use hard floating point ABI.
1870 LLVM_FALLTHROUGH;
18701871 case CallingConv::ARM_AAPCS:
18711872 return (Return ? RetCC_ARM_AAPCS: CC_ARM_AAPCS);
18721873 case CallingConv::ARM_APCS:
86588658 // (zext cc) can never be the all ones value.
86598659 if (AllOnes)
86608660 return false;
8661 // Fall through.
8661 LLVM_FALLTHROUGH;
86628662 case ISD::SIGN_EXTEND: {
86638663 SDLoc dl(N);
86648664 EVT VT = N->getValueType(0);
1140811408 case 1:
1140911409 if (Subtarget->isThumb1Only())
1141011410 return false;
11411 // FALL THROUGH.
11411 LLVM_FALLTHROUGH;
1141211412 default:
1141311413 // ARM doesn't support any R+R*scale+imm addr modes.
1141411414 if (AM.BaseOffs)
14311431 case ARM::STC_POST:
14321432 case ARM::STCL_POST:
14331433 imm |= U << 8;
1434 // fall through.
1434 LLVM_FALLTHROUGH;
14351435 default:
14361436 // The 'option' variant doesn't encode 'U' in the immediate since
14371437 // the immediate is unsigned [0,255].
25542554 break;
25552555 }
25562556 // Fall through to handle the register offset variant.
2557 LLVM_FALLTHROUGH;
25572558 case ARM::VLD1d8wb_fixed:
25582559 case ARM::VLD1d16wb_fixed:
25592560 case ARM::VLD1d32wb_fixed:
41564157 case 0x93: // faultmask_ns
41574158 if (!(FeatureBits[ARM::HasV8MMainlineOps]))
41584159 return MCDisassembler::Fail;
4159 // fall through
4160 LLVM_FALLTHROUGH;
41604161 case 10: // msplim
41614162 case 11: // psplim
41624163 case 0x88: // msp_ns
53095310
53105311 return S;
53115312 }
5312
629629 case ARM::fixup_arm_pcrel_10:
630630 Value = Value - 4; // ARM fixups offset by an additional word and don't
631631 // need to adjust for the half-word ordering.
632 // Fall through.
632 LLVM_FALLTHROUGH;
633633 case ARM::fixup_t2_pcrel_10: {
634634 // Offset by 4, adjusted by two due to the half-word ordering of thumb.
635635 Value = Value - 4;
656656 case ARM::fixup_arm_pcrel_9:
657657 Value = Value - 4; // ARM fixups offset by an additional word and don't
658658 // need to adjust for the half-word ordering.
659 // Fall through.
659 LLVM_FALLTHROUGH;
660660 case ARM::fixup_t2_pcrel_9: {
661661 // Offset by 4, adjusted by two due to the half-word ordering of thumb.
662662 Value = Value - 4;
115115 const MachineOperand &A = MI->getOperand(2);
116116 if (!A.isImm() || A.getImm() != 0)
117117 return false;
118 }
119 // Fall through.
118 LLVM_FALLTHROUGH;
119 }
120120 case Hexagon::A2_tfr: {
121121 const MachineOperand &DstOp = MI->getOperand(0);
122122 const MachineOperand &SrcOp = MI->getOperand(1);
336336 if (V == 0 || V == -1)
337337 return 10;
338338 // Fall through into A2_combinew.
339 LLVM_FALLTHROUGH;
339340 }
340341 case Hexagon::A2_combinew:
341342 return 2;
16051605 case Mips::BBIT1:
16061606 case Mips::BBIT132:
16071607 assert(hasCnMips() && "instruction only valid for octeon cpus");
1608 // Fall through
1608 LLVM_FALLTHROUGH;
16091609
16101610 case Mips::BEQ:
16111611 case Mips::BNE:
21232123 // expression properly. This is important for differences between
21242124 // blockaddress labels. Since the two labels are in the same function, it
21252125 // is reasonable to treat their delta as a 32-bit value.
2126 // FALL THROUGH.
2126 LLVM_FALLTHROUGH;
21272127 case Instruction::BitCast:
21282128 return lowerConstantForGV(CE->getOperand(0), ProcessingGeneric);
21292129
117117
118118 case SPCC::CPCC_A: return SPCC::CPCC_N;
119119 case SPCC::CPCC_N: return SPCC::CPCC_A;
120 case SPCC::CPCC_3: // Fall through
121 case SPCC::CPCC_2: // Fall through
122 case SPCC::CPCC_23: // Fall through
123 case SPCC::CPCC_1: // Fall through
124 case SPCC::CPCC_13: // Fall through
125 case SPCC::CPCC_12: // Fall through
126 case SPCC::CPCC_123: // Fall through
127 case SPCC::CPCC_0: // Fall through
128 case SPCC::CPCC_03: // Fall through
129 case SPCC::CPCC_02: // Fall through
130 case SPCC::CPCC_023: // Fall through
131 case SPCC::CPCC_01: // Fall through
132 case SPCC::CPCC_013: // Fall through
120 case SPCC::CPCC_3: LLVM_FALLTHROUGH;
121 case SPCC::CPCC_2: LLVM_FALLTHROUGH;
122 case SPCC::CPCC_23: LLVM_FALLTHROUGH;
123 case SPCC::CPCC_1: LLVM_FALLTHROUGH;
124 case SPCC::CPCC_13: LLVM_FALLTHROUGH;
125 case SPCC::CPCC_12: LLVM_FALLTHROUGH;
126 case SPCC::CPCC_123: LLVM_FALLTHROUGH;
127 case SPCC::CPCC_0: LLVM_FALLTHROUGH;
128 case SPCC::CPCC_03: LLVM_FALLTHROUGH;
129 case SPCC::CPCC_02: LLVM_FALLTHROUGH;
130 case SPCC::CPCC_023: LLVM_FALLTHROUGH;
131 case SPCC::CPCC_01: LLVM_FALLTHROUGH;
132 case SPCC::CPCC_013: LLVM_FALLTHROUGH;
133133 case SPCC::CPCC_012:
134134 // "Opposite" code is not meaningful, as we don't know
135135 // what the CoProc condition means here. The cond-code will
831831 RxSBG.Input = N.getOperand(0);
832832 return true;
833833 }
834 // Fall through.
834 LLVM_FALLTHROUGH;
835835
836836 case ISD::SIGN_EXTEND: {
837837 // Check that the extension bits are don't-care (i.e. are masked out
12641264 if (Node->getOperand(1).getOpcode() != ISD::Constant)
12651265 if (tryRxSBG(Node, SystemZ::RNSBG))
12661266 return;
1267 // Fall through.
1267 LLVM_FALLTHROUGH;
12681268 case ISD::ROTL:
12691269 case ISD::SHL:
12701270 case ISD::SRL:
381381 case X86::VBLENDPDrri:
382382 case X86::VBLENDPDYrri:
383383 Src2Name = getRegName(MI->getOperand(2).getReg());
384 // FALL THROUGH.
384 LLVM_FALLTHROUGH;
385385 case X86::BLENDPDrmi:
386386 case X86::VBLENDPDrmi:
387387 case X86::VBLENDPDYrmi:
397397 case X86::VBLENDPSrri:
398398 case X86::VBLENDPSYrri:
399399 Src2Name = getRegName(MI->getOperand(2).getReg());
400 // FALL THROUGH.
400 LLVM_FALLTHROUGH;
401401 case X86::BLENDPSrmi:
402402 case X86::VBLENDPSrmi:
403403 case X86::VBLENDPSYrmi:
413413 case X86::VPBLENDWrri:
414414 case X86::VPBLENDWYrri:
415415 Src2Name = getRegName(MI->getOperand(2).getReg());
416 // FALL THROUGH.
416 LLVM_FALLTHROUGH;
417417 case X86::PBLENDWrmi:
418418 case X86::VPBLENDWrmi:
419419 case X86::VPBLENDWYrmi:
428428 case X86::VPBLENDDrri:
429429 case X86::VPBLENDDYrri:
430430 Src2Name = getRegName(MI->getOperand(2).getReg());
431 // FALL THROUGH.
431 LLVM_FALLTHROUGH;
432432 case X86::VPBLENDDrmi:
433433 case X86::VPBLENDDYrmi:
434434 if (MI->getOperand(NumOperands - 1).isImm())
443443 case X86::VINSERTPSrr:
444444 case X86::VINSERTPSZrr:
445445 Src2Name = getRegName(MI->getOperand(2).getReg());
446 // FALL THROUGH.
446 LLVM_FALLTHROUGH;
447447 case X86::INSERTPSrm:
448448 case X86::VINSERTPSrm:
449449 case X86::VINSERTPSZrm:
506506
507507 CASE_MOVDUP(MOVSLDUP, r)
508508 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
509 // FALL THROUGH.
509 LLVM_FALLTHROUGH;
510
510511 CASE_MOVDUP(MOVSLDUP, m)
511512 DestName = getRegName(MI->getOperand(0).getReg());
512513 DecodeMOVSLDUPMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
514515
515516 CASE_MOVDUP(MOVSHDUP, r)
516517 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
517 // FALL THROUGH.
518 LLVM_FALLTHROUGH;
519
518520 CASE_MOVDUP(MOVSHDUP, m)
519521 DestName = getRegName(MI->getOperand(0).getReg());
520522 DecodeMOVSHDUPMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
522524
523525 CASE_MOVDUP(MOVDDUP, r)
524526 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
525 // FALL THROUGH.
527 LLVM_FALLTHROUGH;
528
526529 CASE_MOVDUP(MOVDDUP, m)
527530 DestName = getRegName(MI->getOperand(0).getReg());
528531 DecodeMOVDDUPMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
565568 CASE_SHUF(PALIGNR, rri)
566569 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
567570 RegForm = true;
568 // FALL THROUGH.
571 LLVM_FALLTHROUGH;
572
569573 CASE_SHUF(PALIGNR, rmi)
570574 Src2Name = getRegName(MI->getOperand(NumOperands-(RegForm?3:7)).getReg());
571575 DestName = getRegName(MI->getOperand(0).getReg());
577581
578582 CASE_SHUF(PSHUFD, ri)
579583 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
580 // FALL THROUGH.
584 LLVM_FALLTHROUGH;
585
581586 CASE_SHUF(PSHUFD, mi)
582587 DestName = getRegName(MI->getOperand(0).getReg());
583588 if (MI->getOperand(NumOperands - 1).isImm())
588593
589594 CASE_SHUF(PSHUFHW, ri)
590595 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
591 // FALL THROUGH.
596 LLVM_FALLTHROUGH;
597
592598 CASE_SHUF(PSHUFHW, mi)
593599 DestName = getRegName(MI->getOperand(0).getReg());
594600 if (MI->getOperand(NumOperands - 1).isImm())
599605
600606 CASE_SHUF(PSHUFLW, ri)
601607 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
602 // FALL THROUGH.
608 LLVM_FALLTHROUGH;
609
603610 CASE_SHUF(PSHUFLW, mi)
604611 DestName = getRegName(MI->getOperand(0).getReg());
605612 if (MI->getOperand(NumOperands - 1).isImm())
610617
611618 case X86::MMX_PSHUFWri:
612619 Src1Name = getRegName(MI->getOperand(1).getReg());
613 // FALL THROUGH.
620 LLVM_FALLTHROUGH;
621
614622 case X86::MMX_PSHUFWmi:
615623 DestName = getRegName(MI->getOperand(0).getReg());
616624 if (MI->getOperand(NumOperands - 1).isImm())
621629
622630 case X86::PSWAPDrr:
623631 Src1Name = getRegName(MI->getOperand(1).getReg());
624 // FALL THROUGH.
632 LLVM_FALLTHROUGH;
633
625634 case X86::PSWAPDrm:
626635 DestName = getRegName(MI->getOperand(0).getReg());
627636 DecodePSWAPMask(MVT::v2i32, ShuffleMask);
631640 case X86::MMX_PUNPCKHBWirr:
632641 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
633642 RegForm = true;
634 // FALL THROUGH.
643 LLVM_FALLTHROUGH;
644
635645 CASE_UNPCK(PUNPCKHBW, m)
636646 case X86::MMX_PUNPCKHBWirm:
637647 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
643653 case X86::MMX_PUNPCKHWDirr:
644654 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
645655 RegForm = true;
646 // FALL THROUGH.
656 LLVM_FALLTHROUGH;
657
647658 CASE_UNPCK(PUNPCKHWD, m)
648659 case X86::MMX_PUNPCKHWDirm:
649660 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
655666 case X86::MMX_PUNPCKHDQirr:
656667 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
657668 RegForm = true;
658 // FALL THROUGH.
669 LLVM_FALLTHROUGH;
670
659671 CASE_UNPCK(PUNPCKHDQ, m)
660672 case X86::MMX_PUNPCKHDQirm:
661673 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
666678 CASE_UNPCK(PUNPCKHQDQ, r)
667679 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
668680 RegForm = true;
669 // FALL THROUGH.
681 LLVM_FALLTHROUGH;
682
670683 CASE_UNPCK(PUNPCKHQDQ, m)
671684 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
672685 DestName = getRegName(MI->getOperand(0).getReg());
677690 case X86::MMX_PUNPCKLBWirr:
678691 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
679692 RegForm = true;
680 // FALL THROUGH.
693 LLVM_FALLTHROUGH;
694
681695 CASE_UNPCK(PUNPCKLBW, m)
682696 case X86::MMX_PUNPCKLBWirm:
683697 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
689703 case X86::MMX_PUNPCKLWDirr:
690704 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
691705 RegForm = true;
692 // FALL THROUGH.
706 LLVM_FALLTHROUGH;
707
693708 CASE_UNPCK(PUNPCKLWD, m)
694709 case X86::MMX_PUNPCKLWDirm:
695710 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
701716 case X86::MMX_PUNPCKLDQirr:
702717 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
703718 RegForm = true;
704 // FALL THROUGH.
719 LLVM_FALLTHROUGH;
720
705721 CASE_UNPCK(PUNPCKLDQ, m)
706722 case X86::MMX_PUNPCKLDQirm:
707723 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
712728 CASE_UNPCK(PUNPCKLQDQ, r)
713729 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
714730 RegForm = true;
715 // FALL THROUGH.
731 LLVM_FALLTHROUGH;
732
716733 CASE_UNPCK(PUNPCKLQDQ, m)
717734 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
718735 DestName = getRegName(MI->getOperand(0).getReg());
722739 CASE_SHUF(SHUFPD, rri)
723740 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
724741 RegForm = true;
725 // FALL THROUGH.
742 LLVM_FALLTHROUGH;
743
726744 CASE_SHUF(SHUFPD, rmi)
727745 if (MI->getOperand(NumOperands - 1).isImm())
728746 DecodeSHUFPMask(getRegOperandVectorVT(MI, MVT::f64, 0),
735753 CASE_SHUF(SHUFPS, rri)
736754 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
737755 RegForm = true;
738 // FALL THROUGH.
756 LLVM_FALLTHROUGH;
757
739758 CASE_SHUF(SHUFPS, rmi)
740759 if (MI->getOperand(NumOperands - 1).isImm())
741760 DecodeSHUFPMask(getRegOperandVectorVT(MI, MVT::f32, 0),
748767 CASE_VSHUF(64X2, r)
749768 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
750769 RegForm = true;
751 // FALL THROUGH.
770 LLVM_FALLTHROUGH;
771
752772 CASE_VSHUF(64X2, m)
753773 decodeVSHUF64x2FamilyMask(getRegOperandVectorVT(MI, MVT::i64, 0),
754774 MI->getOperand(NumOperands - 1).getImm(),
760780 CASE_VSHUF(32X4, r)
761781 Src2Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
762782 RegForm = true;
763 // FALL THROUGH.
783 LLVM_FALLTHROUGH;
784
764785 CASE_VSHUF(32X4, m)
765786 decodeVSHUF64x2FamilyMask(getRegOperandVectorVT(MI, MVT::i32, 0),
766787 MI->getOperand(NumOperands - 1).getImm(),
772793 CASE_UNPCK(UNPCKLPD, r)
773794 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
774795 RegForm = true;
775 // FALL THROUGH.
796 LLVM_FALLTHROUGH;
797
776798 CASE_UNPCK(UNPCKLPD, m)
777799 DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
778800 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
782804 CASE_UNPCK(UNPCKLPS, r)
783805 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
784806 RegForm = true;
785 // FALL THROUGH.
807 LLVM_FALLTHROUGH;
808
786809 CASE_UNPCK(UNPCKLPS, m)
787810 DecodeUNPCKLMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
788811 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
792815 CASE_UNPCK(UNPCKHPD, r)
793816 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
794817 RegForm = true;
795 // FALL THROUGH.
818 LLVM_FALLTHROUGH;
819
796820 CASE_UNPCK(UNPCKHPD, m)
797821 DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::f64, 0), ShuffleMask);
798822 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
802826 CASE_UNPCK(UNPCKHPS, r)
803827 Src2Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
804828 RegForm = true;
805 // FALL THROUGH.
829 LLVM_FALLTHROUGH;
830
806831 CASE_UNPCK(UNPCKHPS, m)
807832 DecodeUNPCKHMask(getRegOperandVectorVT(MI, MVT::f32, 0), ShuffleMask);
808833 Src1Name = getRegName(MI->getOperand(NumOperands-(RegForm?2:6)).getReg());
811836
812837 CASE_VPERMILPI(PERMILPS, r)
813838 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
814 // FALL THROUGH.
839 LLVM_FALLTHROUGH;
840
815841 CASE_VPERMILPI(PERMILPS, m)
816842 if (MI->getOperand(NumOperands - 1).isImm())
817843 DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::f32, 0),
822848
823849 CASE_VPERMILPI(PERMILPD, r)
824850 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
825 // FALL THROUGH.
851 LLVM_FALLTHROUGH;
852
826853 CASE_VPERMILPI(PERMILPD, m)
827854 if (MI->getOperand(NumOperands - 1).isImm())
828855 DecodePSHUFMask(getRegOperandVectorVT(MI, MVT::f64, 0),
834861 case X86::VPERM2F128rr:
835862 case X86::VPERM2I128rr:
836863 Src2Name = getRegName(MI->getOperand(2).getReg());
837 // FALL THROUGH.
864 LLVM_FALLTHROUGH;
865
838866 case X86::VPERM2F128rm:
839867 case X86::VPERM2I128rm:
840868 // For instruction comments purpose, assume the 256-bit vector is v4i64.
848876
849877 CASE_VPERM(PERMPD, r)
850878 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
851 // FALL THROUGH.
879 LLVM_FALLTHROUGH;
880
852881 CASE_VPERM(PERMPD, m)
853882 if (MI->getOperand(NumOperands - 1).isImm())
854883 DecodeVPERMMask(getRegOperandVectorVT(MI, MVT::f64, 0),
859888
860889 CASE_VPERM(PERMQ, r)
861890 Src1Name = getRegName(MI->getOperand(NumOperands - 2).getReg());
862 // FALL THROUGH.
891 LLVM_FALLTHROUGH;
892
863893 CASE_VPERM(PERMQ, m)
864894 if (MI->getOperand(NumOperands - 1).isImm())
865895 DecodeVPERMMask(getRegOperandVectorVT(MI, MVT::i64, 0),
873903 case X86::VMOVSDZrr:
874904 Src2Name = getRegName(MI->getOperand(2).getReg());
875905 Src1Name = getRegName(MI->getOperand(1).getReg());
876 // FALL THROUGH.
906 LLVM_FALLTHROUGH;
907
877908 case X86::MOVSDrm:
878909 case X86::VMOVSDrm:
879910 case X86::VMOVSDZrm:
886917 case X86::VMOVSSZrr:
887918 Src2Name = getRegName(MI->getOperand(2).getReg());
888919 Src1Name = getRegName(MI->getOperand(1).getReg());
889 // FALL THROUGH.
920 LLVM_FALLTHROUGH;
921
890922 case X86::MOVSSrm:
891923 case X86::VMOVSSrm:
892924 case X86::VMOVSSZrm:
900932 case X86::VMOVZPQILo2PQIrr:
901933 case X86::VMOVZPQILo2PQIZrr:
902934 Src1Name = getRegName(MI->getOperand(1).getReg());
903 // FALL THROUGH.
935 LLVM_FALLTHROUGH;
936
904937 case X86::MOVQI2PQIrm:
905938 case X86::MOVZQI2PQIrm:
906939 case X86::MOVZPQILo2PQIrm:
953986 CASE_PMOVZX(PMOVZXBD, r)
954987 CASE_PMOVZX(PMOVZXBQ, r)
955988 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
956 // FALL THROUGH.
989 LLVM_FALLTHROUGH;
990
957991 CASE_PMOVZX(PMOVZXBW, m)
958992 CASE_PMOVZX(PMOVZXBD, m)
959993 CASE_PMOVZX(PMOVZXBQ, m)
964998 CASE_PMOVZX(PMOVZXWD, r)
965999 CASE_PMOVZX(PMOVZXWQ, r)
9661000 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
967 // FALL THROUGH.
1001 LLVM_FALLTHROUGH;
1002
9681003 CASE_PMOVZX(PMOVZXWD, m)
9691004 CASE_PMOVZX(PMOVZXWQ, m)
9701005 DecodeZeroExtendMask(MVT::i16, getZeroExtensionResultType(MI), ShuffleMask);
9731008
9741009 CASE_PMOVZX(PMOVZXDQ, r)
9751010 Src1Name = getRegName(MI->getOperand(NumOperands - 1).getReg());
976 // FALL THROUGH.
1011 LLVM_FALLTHROUGH;
1012
9771013 CASE_PMOVZX(PMOVZXDQ, m)
9781014 DecodeZeroExtendMask(MVT::i32, getZeroExtensionResultType(MI), ShuffleMask);
9791015 DestName = getRegName(MI->getOperand(0).getReg());
29682968 default: llvm_unreachable("Unexpected value type.");
29692969 case MVT::i32: SrcReg = GPR32ArgRegs[GPRIdx++]; break;
29702970 case MVT::i64: SrcReg = GPR64ArgRegs[GPRIdx++]; break;
2971 case MVT::f32: // fall-through
2971 case MVT::f32: LLVM_FALLTHROUGH;
29722972 case MVT::f64: SrcReg = XMMArgRegs[FPRIdx++]; break;
29732973 }
29742974 unsigned DstReg = FuncInfo.MF->addLiveIn(SrcReg, RC);
35073507 unsigned Opc = 0;
35083508 switch (VT.SimpleTy) {
35093509 default: llvm_unreachable("Unexpected value type");
3510 case MVT::i1: VT = MVT::i8; // fall-through
3510 case MVT::i1: VT = MVT::i8; LLVM_FALLTHROUGH;
35113511 case MVT::i8: Opc = X86::MOV8ri; break;
35123512 case MVT::i16: Opc = X86::MOV16ri; break;
35133513 case MVT::i32: Opc = X86::MOV32ri; break;
12331233 case ISD::UMUL_LOHI:
12341234 // A mul_lohi where we need the low part can be folded as a plain multiply.
12351235 if (N.getResNo() != 0) break;
1236 // FALL THROUGH
1236 LLVM_FALLTHROUGH;
12371237 case ISD::MUL:
12381238 case X86ISD::MUL_IMM:
12391239 // X*[3,5,9] -> X+X*[2,4,8]
1502715027 if (!Subtarget.hasBMI() || !isAndn || !isLegalAndnType)
1502815028 break;
1502915029 }
15030 // FALL THROUGH
15030 LLVM_FALLTHROUGH;
1503115031 case ISD::SUB:
1503215032 case ISD::OR:
1503315033 case ISD::XOR:
2763427634 break;
2763527635 assert(X86::CondCode(SetCC.getConstantOperandVal(0)) == X86::COND_B &&
2763627636 "Invalid use of SETCC_CARRY!");
27637 // FALL THROUGH
27637 LLVM_FALLTHROUGH;
2763827638 case X86ISD::SETCC:
2763927639 // Set the condition code or opposite one if necessary.
2764027640 CC = X86::CondCode(SetCC.getConstantOperandVal(0));
3222832228 return std::make_pair(0U, &X86::VR64RegClass);
3222932229 case 'Y': // SSE_REGS if SSE2 allowed
3223032230 if (!Subtarget.hasSSE2()) break;
32231 // FALL THROUGH.
32231 LLVM_FALLTHROUGH;
3223232232 case 'x': // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
3223332233 if (!Subtarget.hasSSE1()) break;
3223432234
224224 break;
225225
226226 // Fall through to make any remaining adjustment.
227 LLVM_FALLTHROUGH;
227228 case Sub:
228229 assert(Amount > 0);
229230 if (Amount == SlotSize) {
139139 if (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
140140 GV->hasCommonLinkage())
141141 OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Weak);
142 // FALL THROUGH
142 LLVM_FALLTHROUGH;
143143 case GlobalValue::InternalLinkage:
144144 case GlobalValue::PrivateLinkage:
145145 break;
774774 break;
775775 if (CS.getCalledFunction() && SCCNodes.count(CS.getCalledFunction()))
776776 break;
777 } // fall-through
777 LLVM_FALLTHROUGH;
778 }
778779 default:
779780 return false; // Did not come from an allocation.
780781 }
827827 default:
828828 llvm_unreachable("Unknown type!");
829829 // Fall through in Release mode.
830 LLVM_FALLTHROUGH;
830831 case Type::IntegerTyID:
831832 return cmpNumbers(cast(TyL)->getBitWidth(),
832833 cast(TyR)->getBitWidth());
14721472 II->setArgOperand(1, LHS);
14731473 return II;
14741474 }
1475 // fall through
1475 LLVM_FALLTHROUGH;
14761476
14771477 case Intrinsic::usub_with_overflow:
14781478 case Intrinsic::ssub_with_overflow: {
27142714
27152715 if (OR == OverflowResult::AlwaysOverflows)
27162716 return SetResult(Builder->CreateAdd(LHS, RHS), Builder->getTrue(), true);
2717 }
2718 // FALL THROUGH uadd into sadd
2717
2718 // Fall through uadd into sadd
2719 LLVM_FALLTHROUGH;
2720 }
27192721 case OCF_SIGNED_ADD: {
27202722 // X + 0 -> {X, false}
27212723 if (match(RHS, m_Zero()))
27552757 true);
27562758 if (OR == OverflowResult::AlwaysOverflows)
27572759 return SetResult(Builder->CreateMul(LHS, RHS), Builder->getTrue(), true);
2758 } // FALL THROUGH
2760 LLVM_FALLTHROUGH;
2761 }
27592762 case OCF_SIGNED_MUL:
27602763 // X * undef -> undef
27612764 if (isa(RHS))
33103313
33113314 case ICmpInst::ICMP_UGT:
33123315 std::swap(Op0, Op1); // Change icmp ugt -> icmp ult
3313 // FALL THROUGH
3316 LLVM_FALLTHROUGH;
33143317 case ICmpInst::ICMP_ULT:{ // icmp ult i1 A, B -> ~A & B
33153318 Value *Not = Builder->CreateNot(Op0, I.getName() + "tmp");
33163319 return BinaryOperator::CreateAnd(Not, Op1);
33173320 }
33183321 case ICmpInst::ICMP_SGT:
33193322 std::swap(Op0, Op1); // Change icmp sgt -> icmp slt
3320 // FALL THROUGH
3323 LLVM_FALLTHROUGH;
33213324 case ICmpInst::ICMP_SLT: { // icmp slt i1 A, B -> A & ~B
33223325 Value *Not = Builder->CreateNot(Op1, I.getName() + "tmp");
33233326 return BinaryOperator::CreateAnd(Not, Op0);
33243327 }
33253328 case ICmpInst::ICMP_UGE:
33263329 std::swap(Op0, Op1); // Change icmp uge -> icmp ule
3327 // FALL THROUGH
3330 LLVM_FALLTHROUGH;
33283331 case ICmpInst::ICMP_ULE: { // icmp ule i1 A, B -> ~A | B
33293332 Value *Not = Builder->CreateNot(Op0, I.getName() + "tmp");
33303333 return BinaryOperator::CreateOr(Not, Op1);
33313334 }
33323335 case ICmpInst::ICMP_SGE:
33333336 std::swap(Op0, Op1); // Change icmp sge -> icmp sle
3334 // FALL THROUGH
3337 LLVM_FALLTHROUGH;
33353338 case ICmpInst::ICMP_SLE: { // icmp sle i1 A, B -> A | ~B
33363339 Value *Not = Builder->CreateNot(Op1, I.getName() + "tmp");
33373340 return BinaryOperator::CreateOr(Not, Op0);
456456 V1->getName()+".mask");
457457 return BinaryOperator::Create(Op0BO->getOpcode(), YS, XM);
458458 }
459 }
460
461 // FALL THROUGH.
459 LLVM_FALLTHROUGH;
460 }
461
462462 case Instruction::Sub: {
463463 // Turn ((X >> C) + Y) << C -> (X + (Y << C)) & (~0 << C)
464464 if (isLeftShift && Op0BO->getOperand(0)->hasOneUse() &&
19821982 MemIntrinsic *MI = cast(II);
19831983 if (MI->isVolatile() || MI->getRawDest() != PI)
19841984 return false;
1985 LLVM_FALLTHROUGH;
19851986 }
1986 // fall through
19871987 case Intrinsic::dbg_declare:
19881988 case Intrinsic::dbg_value:
19891989 case Intrinsic::invariant_start:
200200 // imprecise release, clear our reverse insertion points.
201201 if (OldSeq != S_Use || IsTrackingImpreciseReleases())
202202 ClearReverseInsertPts();
203 // FALL THROUGH
203 LLVM_FALLTHROUGH;
204204 case S_CanRelease:
205205 return true;
206206 case S_None:
331331 case S_CanRelease:
332332 if (OldSeq == S_Retain || ReleaseMetadata != nullptr)
333333 ClearReverseInsertPts();
334 // FALL THROUGH
334 LLVM_FALLTHROUGH;
335335 case S_Use:
336336 SetReleaseMetadata(ReleaseMetadata);
337337 SetTailCallRelease(cast(Release)->isTailCall());
598598 }
599599 errs()
600600 << "llvm-config: error: component libraries and shared library\n\n";
601 // fall through
601 LLVM_FALLTHROUGH;
602602 case LinkModeStatic:
603603 for (auto &Lib : MissingLibs)
604604 errs() << "llvm-config: error: missing: " << Lib << "\n";
6565 SM.PrintMessage(SMLoc::getFromPointer(Bytes.second[Index]),
6666 SourceMgr::DK_Warning,
6767 "potentially undefined instruction encoding");
68 // Fall through
68 LLVM_FALLTHROUGH;
6969
7070 case MCDisassembler::Success:
7171 Streamer.EmitInstruction(Inst, STI);
286286 unsigned Tmp = 0;
287287 switch (VT) {
288288 default: break;
289 case MVT::iPTRAny: ++Tmp; // FALL THROUGH.
290 case MVT::vAny: ++Tmp; // FALL THROUGH.
291 case MVT::fAny: ++Tmp; // FALL THROUGH.
292 case MVT::iAny: ++Tmp; // FALL THROUGH.
289 case MVT::iPTRAny: ++Tmp; LLVM_FALLTHROUGH;
290 case MVT::vAny: ++Tmp; LLVM_FALLTHROUGH;
291 case MVT::fAny: ++Tmp; LLVM_FALLTHROUGH;
292 case MVT::iAny: ++Tmp; LLVM_FALLTHROUGH;
293293 case MVT::Any: {
294294 // If this is an "any" valuetype, then the type is the type of the next
295295 // type in the list specified to getIntrinsic().