|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
gen/lib/Target/AArch64/AArch64GenAsmMatcher.inc 6472 static_cast<AArch64Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
6484 static_cast<AArch64Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
6487 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorReg128Operands(Inst, 1);
6490 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorReg64Operands(Inst, 1);
6493 static_cast<AArch64Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
6505 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmNegWithOptionalShiftOperands<12>(Inst, 2);
6508 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmWithOptionalShiftOperands<12>(Inst, 2);
6511 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmWithOptionalShiftOperands<8>(Inst, 2);
6514 static_cast<AArch64Operand&>(*Operands[OpIdx]).addShifterOperands(Inst, 1);
6517 static_cast<AArch64Operand&>(*Operands[OpIdx]).addExtendOperands(Inst, 1);
6520 static_cast<AArch64Operand&>(*Operands[OpIdx]).addExtend64Operands(Inst, 1);
6523 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmScaledOperands<16>(Inst, 1);
6526 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
6529 static_cast<AArch64Operand&>(*Operands[OpIdx]).addAdrLabelOperands(Inst, 1);
6532 static_cast<AArch64Operand&>(*Operands[OpIdx]).addAdrpLabelOperands(Inst, 1);
6535 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmOperands<int32_t>(Inst, 1);
6538 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmOperands<int64_t>(Inst, 1);
6541 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmOperands<int16_t>(Inst, 1);
6544 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmOperands<int8_t>(Inst, 1);
6553 static_cast<AArch64Operand&>(*Operands[OpIdx]).addBranchTarget26Operands(Inst, 1);
6556 static_cast<AArch64Operand&>(*Operands[OpIdx]).addCondCodeOperands(Inst, 1);
6559 static_cast<AArch64Operand&>(*Operands[OpIdx]).addPCRelLabel19Operands(Inst, 1);
6562 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmNotOperands<int32_t>(Inst, 1);
6565 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmNotOperands<int64_t>(Inst, 1);
6568 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmNotOperands<int16_t>(Inst, 1);
6571 static_cast<AArch64Operand&>(*Operands[OpIdx]).addLogicalImmNotOperands<int8_t>(Inst, 1);
6577 static_cast<AArch64Operand&>(*Operands[OpIdx]).addBTIHintOperands(Inst, 1);
6580 static_cast<AArch64Operand&>(*Operands[OpIdx]).addComplexRotationOddOperands(Inst, 1);
6583 static_cast<AArch64Operand&>(*Operands[OpIdx]).addComplexRotationEvenOperands(Inst, 1);
6586 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorIndexOperands(Inst, 1);
6604 static_cast<AArch64Operand&>(*Operands[OpIdx]).addBarrierOperands(Inst, 1);
6607 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_ZReg, 2>(Inst, 1);
6610 static_cast<AArch64Operand&>(*Operands[OpIdx]).addExactFPImmOperands<AArch64ExactFPImm::half, AArch64ExactFPImm::one>(Inst, 1);
6613 static_cast<AArch64Operand&>(*Operands[OpIdx]).addFPImmOperands(Inst, 1);
6616 static_cast<AArch64Operand&>(*Operands[OpIdx]).addExactFPImmOperands<AArch64ExactFPImm::zero, AArch64ExactFPImm::one>(Inst, 1);
6619 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorRegLoOperands(Inst, 1);
6622 static_cast<AArch64Operand&>(*Operands[OpIdx]).addExactFPImmOperands<AArch64ExactFPImm::half, AArch64ExactFPImm::two>(Inst, 1);
6625 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_QReg, 4>(Inst, 1);
6628 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_DReg, 4>(Inst, 1);
6631 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_QReg, 1>(Inst, 1);
6634 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_DReg, 1>(Inst, 1);
6637 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_QReg, 3>(Inst, 1);
6640 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_DReg, 3>(Inst, 1);
6643 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_QReg, 2>(Inst, 1);
6646 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_DReg, 2>(Inst, 1);
6649 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_ZReg, 1>(Inst, 1);
6652 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmScaledOperands<1>(Inst, 1);
6655 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmScaledOperands<8>(Inst, 1);
6658 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmScaledOperands<2>(Inst, 1);
6661 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmScaledOperands<4>(Inst, 1);
6664 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_ZReg, 3>(Inst, 1);
6667 static_cast<AArch64Operand&>(*Operands[OpIdx]).addImmScaledOperands<3>(Inst, 1);
6670 static_cast<AArch64Operand&>(*Operands[OpIdx]).addVectorListOperands<AArch64Operand::VecListIdx_ZReg, 4>(Inst, 1);
6673 static_cast<AArch64Operand&>(*Operands[OpIdx]).addUImm12OffsetOperands<4>(Inst, 1);
6676 static_cast<AArch64Operand&>(*Operands[OpIdx]).addUImm12OffsetOperands<8>(Inst, 1);
6679 static_cast<AArch64Operand&>(*Operands[OpIdx]).addUImm12OffsetOperands<1>(Inst, 1);
6682 static_cast<AArch64Operand&>(*Operands[OpIdx]).addUImm12OffsetOperands<2>(Inst, 1);
6685 static_cast<AArch64Operand&>(*Operands[OpIdx]).addUImm12OffsetOperands<16>(Inst, 1);
6688 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMemExtendOperands(Inst, 2);
6691 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMemExtend8Operands(Inst, 2);
6694 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVZMovAliasOperands<0>(Inst, 1);
6697 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVZMovAliasOperands<16>(Inst, 1);
6700 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVNMovAliasOperands<0>(Inst, 1);
6703 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVNMovAliasOperands<16>(Inst, 1);
6706 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVZMovAliasOperands<32>(Inst, 1);
6709 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVZMovAliasOperands<48>(Inst, 1);
6715 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVNMovAliasOperands<32>(Inst, 1);
6718 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMOVNMovAliasOperands<48>(Inst, 1);
6721 static_cast<AArch64Operand&>(*Operands[OpIdx]).addFPRasZPRRegOperands<128>(Inst, 1);
6724 static_cast<AArch64Operand&>(*Operands[OpIdx]).addFPRasZPRRegOperands<16>(Inst, 1);
6727 static_cast<AArch64Operand&>(*Operands[OpIdx]).addFPRasZPRRegOperands<32>(Inst, 1);
6730 static_cast<AArch64Operand&>(*Operands[OpIdx]).addFPRasZPRRegOperands<64>(Inst, 1);
6733 static_cast<AArch64Operand&>(*Operands[OpIdx]).addFPRasZPRRegOperands<8>(Inst, 1);
6736 static_cast<AArch64Operand&>(*Operands[OpIdx]).addSIMDImmType10Operands(Inst, 1);
6739 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMRSSystemRegisterOperands(Inst, 1);
6742 static_cast<AArch64Operand&>(*Operands[OpIdx]).addMSRSystemRegisterOperands(Inst, 1);
6745 static_cast<AArch64Operand&>(*Operands[OpIdx]).addSystemPStateFieldWithImm0_15Operands(Inst, 1);
6748 static_cast<AArch64Operand&>(*Operands[OpIdx]).addSystemPStateFieldWithImm0_1Operands(Inst, 1);
6751 static_cast<AArch64Operand&>(*Operands[OpIdx]).addPrefetchOperands(Inst, 1);
6754 static_cast<AArch64Operand&>(*Operands[OpIdx]).addPSBHintOperands(Inst, 1);
6763 static_cast<AArch64Operand&>(*Operands[OpIdx]).addUImm6Operands(Inst, 1);
6769 static_cast<AArch64Operand&>(*Operands[OpIdx]).addGPR64as32Operands(Inst, 1);
6775 static_cast<AArch64Operand&>(*Operands[OpIdx]).addSysCROperands(Inst, 1);
6778 static_cast<AArch64Operand&>(*Operands[OpIdx]).addBranchTarget14Operands(Inst, 1);
6781 static_cast<AArch64Operand&>(*Operands[OpIdx]).addGPR32as64Operands(Inst, 1);
6803 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6804 Operands[*(p + 1)]->setConstraint("r");
6811 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6812 Operands[*(p + 1)]->setConstraint("r");
6816 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6817 Operands[*(p + 1)]->setConstraint("m");
6821 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6822 Operands[*(p + 1)]->setConstraint("m");
6826 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6827 Operands[*(p + 1)]->setConstraint("m");
6831 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6832 Operands[*(p + 1)]->setConstraint("");
6836 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6837 Operands[*(p + 1)]->setConstraint("");
6841 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6842 Operands[*(p + 1)]->setConstraint("");
6846 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6847 Operands[*(p + 1)]->setConstraint("m");
6851 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6852 Operands[*(p + 1)]->setConstraint("m");
6856 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6857 Operands[*(p + 1)]->setConstraint("m");
6861 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6862 Operands[*(p + 1)]->setConstraint("m");
6866 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6867 Operands[*(p + 1)]->setConstraint("m");
6871 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6872 Operands[*(p + 1)]->setConstraint("m");
6876 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6877 Operands[*(p + 1)]->setConstraint("m");
6881 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6882 Operands[*(p + 1)]->setConstraint("m");
6886 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6887 Operands[*(p + 1)]->setConstraint("m");
6891 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6892 Operands[*(p + 1)]->setConstraint("m");
6896 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6897 Operands[*(p + 1)]->setConstraint("m");
6901 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6902 Operands[*(p + 1)]->setConstraint("m");
6906 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6907 Operands[*(p + 1)]->setConstraint("m");
6911 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6912 Operands[*(p + 1)]->setConstraint("m");
6916 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6917 Operands[*(p + 1)]->setConstraint("");
6921 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6922 Operands[*(p + 1)]->setConstraint("");
6926 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6927 Operands[*(p + 1)]->setConstraint("m");
6931 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6932 Operands[*(p + 1)]->setConstraint("m");
6936 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6937 Operands[*(p + 1)]->setConstraint("m");
6941 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6942 Operands[*(p + 1)]->setConstraint("m");
6946 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6947 Operands[*(p + 1)]->setConstraint("m");
6951 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6952 Operands[*(p + 1)]->setConstraint("m");
6956 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6957 Operands[*(p + 1)]->setConstraint("m");
6961 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6962 Operands[*(p + 1)]->setConstraint("");
6966 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6967 Operands[*(p + 1)]->setConstraint("m");
6971 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6972 Operands[*(p + 1)]->setConstraint("m");
6976 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6977 Operands[*(p + 1)]->setConstraint("m");
6981 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6982 Operands[*(p + 1)]->setConstraint("m");
6986 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6987 Operands[*(p + 1)]->setConstraint("");
6991 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6992 Operands[*(p + 1)]->setConstraint("m");
6996 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
6997 Operands[*(p + 1)]->setConstraint("m");
7001 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7002 Operands[*(p + 1)]->setConstraint("");
7006 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7007 Operands[*(p + 1)]->setConstraint("");
7011 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7012 Operands[*(p + 1)]->setConstraint("m");
7016 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7017 Operands[*(p + 1)]->setConstraint("m");
7021 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7022 Operands[*(p + 1)]->setConstraint("m");
7026 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7027 Operands[*(p + 1)]->setConstraint("m");
7031 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7032 Operands[*(p + 1)]->setConstraint("m");
7036 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7037 Operands[*(p + 1)]->setConstraint("m");
7041 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7042 Operands[*(p + 1)]->setConstraint("m");
7046 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7047 Operands[*(p + 1)]->setConstraint("m");
7051 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7052 Operands[*(p + 1)]->setConstraint("m");
7056 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7057 Operands[*(p + 1)]->setConstraint("m");
7061 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7062 Operands[*(p + 1)]->setConstraint("m");
7066 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7067 Operands[*(p + 1)]->setConstraint("m");
7071 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7072 Operands[*(p + 1)]->setConstraint("m");
7076 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7077 Operands[*(p + 1)]->setConstraint("m");
7081 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7082 Operands[*(p + 1)]->setConstraint("m");
7086 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7087 Operands[*(p + 1)]->setConstraint("m");
7091 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7092 Operands[*(p + 1)]->setConstraint("m");
7096 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7097 Operands[*(p + 1)]->setConstraint("m");
7101 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7102 Operands[*(p + 1)]->setConstraint("m");
7106 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7107 Operands[*(p + 1)]->setConstraint("m");
7111 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7112 Operands[*(p + 1)]->setConstraint("m");
7116 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7117 Operands[*(p + 1)]->setConstraint("m");
7121 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7122 Operands[*(p + 1)]->setConstraint("m");
7126 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7127 Operands[*(p + 1)]->setConstraint("m");
7131 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7132 Operands[*(p + 1)]->setConstraint("m");
7136 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7137 Operands[*(p + 1)]->setConstraint("m");
7141 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7142 Operands[*(p + 1)]->setConstraint("m");
7146 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7147 Operands[*(p + 1)]->setConstraint("m");
7151 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7152 Operands[*(p + 1)]->setConstraint("m");
7156 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7157 Operands[*(p + 1)]->setConstraint("m");
7161 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7162 Operands[*(p + 1)]->setConstraint("m");
7166 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7167 Operands[*(p + 1)]->setConstraint("m");
7171 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7172 Operands[*(p + 1)]->setConstraint("m");
7176 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7177 Operands[*(p + 1)]->setConstraint("m");
7181 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7182 Operands[*(p + 1)]->setConstraint("m");
7186 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7187 Operands[*(p + 1)]->setConstraint("m");
7191 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7192 Operands[*(p + 1)]->setConstraint("");
7196 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7197 Operands[*(p + 1)]->setConstraint("m");
7201 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7202 Operands[*(p + 1)]->setConstraint("m");
7206 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7207 Operands[*(p + 1)]->setConstraint("m");
7211 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7212 Operands[*(p + 1)]->setConstraint("m");
7216 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7217 Operands[*(p + 1)]->setConstraint("m");
7221 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7222 Operands[*(p + 1)]->setConstraint("m");
7226 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7227 Operands[*(p + 1)]->setConstraint("m");
7231 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7232 Operands[*(p + 1)]->setConstraint("m");
7236 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7237 Operands[*(p + 1)]->setConstraint("m");
7241 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7242 Operands[*(p + 1)]->setConstraint("m");
7246 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7247 Operands[*(p + 1)]->setConstraint("m");
7251 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7252 Operands[*(p + 1)]->setConstraint("m");
7256 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7257 Operands[*(p + 1)]->setConstraint("m");
7261 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7262 Operands[*(p + 1)]->setConstraint("m");
7266 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7267 Operands[*(p + 1)]->setConstraint("");
7271 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7272 Operands[*(p + 1)]->setConstraint("m");
7276 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7277 Operands[*(p + 1)]->setConstraint("m");
7281 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7282 Operands[*(p + 1)]->setConstraint("");
7286 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7287 Operands[*(p + 1)]->setConstraint("m");
7291 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7292 Operands[*(p + 1)]->setConstraint("");
7296 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7297 Operands[*(p + 1)]->setConstraint("m");
7301 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7302 Operands[*(p + 1)]->setConstraint("m");
7306 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7307 Operands[*(p + 1)]->setConstraint("m");
7311 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7312 Operands[*(p + 1)]->setConstraint("");
7316 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
7317 Operands[*(p + 1)]->setConstraint("");
12406 auto &SrcOp1 = Operands[OpndNum1];
12407 auto &SrcOp2 = Operands[OpndNum2];
27418 StringRef Mnemonic = ((AArch64Operand&)*Operands[0]).getToken();
27463 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
27472 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/AMDGPU/AMDGPUGenAsmMatcher.inc 3795 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
3831 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
3837 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3844 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3851 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3858 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3871 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addRegOrImmOperands(Inst, 1);
3874 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3880 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3884 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addSoppBrTargetOperands(Inst, 1);
3890 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3897 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3904 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3920 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3927 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3934 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3941 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3963 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
3972 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addKImmFP16Operands(Inst, 1);
3975 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addKImmFP32Operands(Inst, 1);
3984 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3991 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
3998 static_cast<AMDGPUOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
4015 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4016 Operands[*(p + 1)]->setConstraint("r");
4023 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4024 Operands[*(p + 1)]->setConstraint("r");
4028 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4029 Operands[*(p + 1)]->setConstraint("m");
4033 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4034 Operands[*(p + 1)]->setConstraint("m");
4038 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4039 Operands[*(p + 1)]->setConstraint("m");
4043 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4044 Operands[*(p + 1)]->setConstraint("m");
4048 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4049 Operands[*(p + 1)]->setConstraint("");
4053 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4054 Operands[*(p + 1)]->setConstraint("m");
4058 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4059 Operands[*(p + 1)]->setConstraint("m");
4063 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4064 Operands[*(p + 1)]->setConstraint("m");
4068 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4069 Operands[*(p + 1)]->setConstraint("m");
4073 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4074 Operands[*(p + 1)]->setConstraint("m");
4078 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4079 Operands[*(p + 1)]->setConstraint("m");
4083 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4084 Operands[*(p + 1)]->setConstraint("m");
4088 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4089 Operands[*(p + 1)]->setConstraint("m");
4093 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4094 Operands[*(p + 1)]->setConstraint("m");
4098 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4099 Operands[*(p + 1)]->setConstraint("m");
4103 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4104 Operands[*(p + 1)]->setConstraint("m");
4108 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4109 Operands[*(p + 1)]->setConstraint("m");
4113 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4114 Operands[*(p + 1)]->setConstraint("m");
4118 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4119 Operands[*(p + 1)]->setConstraint("m");
4123 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4124 Operands[*(p + 1)]->setConstraint("m");
4128 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4129 Operands[*(p + 1)]->setConstraint("m");
4133 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4134 Operands[*(p + 1)]->setConstraint("m");
10326 auto &SrcOp1 = Operands[OpndNum1];
10327 auto &SrcOp2 = Operands[OpndNum2];
23936 StringRef Mnemonic = ((AMDGPUOperand&)*Operands[0]).getToken();
23989 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
23999 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/AMDGPU/AMDGPUGenDAGISel.inc79638 if (!Operands[i]->isDivergent() &&
79639 !isInlineImmediate(Operands[i].getNode())) {
gen/lib/Target/ARM/ARMGenAsmMatcher.inc 4356 static_cast<ARMOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
4368 static_cast<ARMOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
4371 static_cast<ARMOperand&>(*Operands[OpIdx]).addCCOutOperands(Inst, 1);
4374 static_cast<ARMOperand&>(*Operands[OpIdx]).addCondCodeOperands(Inst, 2);
4377 static_cast<ARMOperand&>(*Operands[OpIdx]).addRegShiftedRegOperands(Inst, 3);
4380 static_cast<ARMOperand&>(*Operands[OpIdx]).addModImmOperands(Inst, 1);
4383 static_cast<ARMOperand&>(*Operands[OpIdx]).addModImmNotOperands(Inst, 1);
4386 static_cast<ARMOperand&>(*Operands[OpIdx]).addRegShiftedImmOperands(Inst, 2);
4389 static_cast<ARMOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
4392 static_cast<ARMOperand&>(*Operands[OpIdx]).addT2SOImmNotOperands(Inst, 1);
4395 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm0_508s4Operands(Inst, 1);
4401 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm0_508s4NegOperands(Inst, 1);
4404 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm0_4095NegOperands(Inst, 1);
4407 static_cast<ARMOperand&>(*Operands[OpIdx]).addThumbModImmNeg8_255Operands(Inst, 1);
4410 static_cast<ARMOperand&>(*Operands[OpIdx]).addT2SOImmNegOperands(Inst, 1);
4413 static_cast<ARMOperand&>(*Operands[OpIdx]).addModImmNegOperands(Inst, 1);
4416 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm0_1020s4Operands(Inst, 1);
4419 static_cast<ARMOperand&>(*Operands[OpIdx]).addThumbModImmNeg1_7Operands(Inst, 1);
4422 static_cast<ARMOperand&>(*Operands[OpIdx]).addUnsignedOffset_b8s2Operands(Inst, 1);
4425 static_cast<ARMOperand&>(*Operands[OpIdx]).addAdrLabelOperands(Inst, 1);
4428 static_cast<ARMOperand&>(*Operands[OpIdx]).addARMBranchTargetOperands(Inst, 1);
4434 static_cast<ARMOperand&>(*Operands[OpIdx]).addBitfieldOperands(Inst, 1);
4437 static_cast<ARMOperand&>(*Operands[OpIdx]).addITCondCodeOperands(Inst, 1);
4443 static_cast<ARMOperand&>(*Operands[OpIdx]).addThumbBranchTargetOperands(Inst, 1);
4446 static_cast<ARMOperand&>(*Operands[OpIdx]).addCoprocNumOperands(Inst, 1);
4449 static_cast<ARMOperand&>(*Operands[OpIdx]).addCoprocRegOperands(Inst, 1);
4452 static_cast<ARMOperand&>(*Operands[OpIdx]).addITCondCodeInvOperands(Inst, 1);
4455 static_cast<ARMOperand&>(*Operands[OpIdx]).addRegListWithAPSROperands(Inst, 1);
4458 static_cast<ARMOperand&>(*Operands[OpIdx]).addProcIFlagsOperands(Inst, 1);
4473 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemBarrierOptOperands(Inst, 1);
4479 static_cast<ARMOperand&>(*Operands[OpIdx]).addFPImmOperands(Inst, 1);
4482 static_cast<ARMOperand&>(*Operands[OpIdx]).addDPRRegListOperands(Inst, 1);
4488 static_cast<ARMOperand&>(*Operands[OpIdx]).addInstSyncBarrierOptOperands(Inst, 1);
4491 static_cast<ARMOperand&>(*Operands[OpIdx]).addITMaskOperands(Inst, 1);
4494 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemNoOffsetOperands(Inst, 1);
4497 static_cast<ARMOperand&>(*Operands[OpIdx]).addAddrMode5Operands(Inst, 2);
4500 static_cast<ARMOperand&>(*Operands[OpIdx]).addCoprocOptionOperands(Inst, 1);
4503 static_cast<ARMOperand&>(*Operands[OpIdx]).addPostIdxImm8s4Operands(Inst, 1);
4506 static_cast<ARMOperand&>(*Operands[OpIdx]).addRegListOperands(Inst, 1);
4509 static_cast<ARMOperand&>(*Operands[OpIdx]).addThumbMemPCOperands(Inst, 1);
4512 static_cast<ARMOperand&>(*Operands[OpIdx]).addConstPoolAsmImmOperands(Inst, 1);
4515 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemThumbRIs4Operands(Inst, 2);
4518 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemThumbRROperands(Inst, 2);
4521 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemThumbSPIOperands(Inst, 2);
4524 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemImm12OffsetOperands(Inst, 2);
4527 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemImmOffsetOperands(Inst, 2);
4530 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemRegOffsetOperands(Inst, 3);
4533 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemUImm12OffsetOperands(Inst, 2);
4536 static_cast<ARMOperand&>(*Operands[OpIdx]).addT2MemRegOffsetOperands(Inst, 3);
4539 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemPCRelImm12Operands(Inst, 1);
4542 static_cast<ARMOperand&>(*Operands[OpIdx]).addAM2OffsetImmOperands(Inst, 2);
4545 static_cast<ARMOperand&>(*Operands[OpIdx]).addPostIdxRegShiftedOperands(Inst, 2);
4548 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemThumbRIs1Operands(Inst, 2);
4551 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemImm8s4OffsetOperands(Inst, 2);
4554 static_cast<ARMOperand&>(*Operands[OpIdx]).addAddrMode3Operands(Inst, 3);
4557 static_cast<ARMOperand&>(*Operands[OpIdx]).addAM3OffsetOperands(Inst, 2);
4560 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemImm0_1020s4OffsetOperands(Inst, 2);
4563 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemThumbRIs2Operands(Inst, 2);
4566 static_cast<ARMOperand&>(*Operands[OpIdx]).addPostIdxRegOperands(Inst, 2);
4569 static_cast<ARMOperand&>(*Operands[OpIdx]).addPostIdxImm8Operands(Inst, 1);
4581 static_cast<ARMOperand&>(*Operands[OpIdx]).addBankedRegOperands(Inst, 1);
4584 static_cast<ARMOperand&>(*Operands[OpIdx]).addMSRMaskOperands(Inst, 1);
4596 static_cast<ARMOperand&>(*Operands[OpIdx]).addPKHASRImmOperands(Inst, 1);
4602 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm1_32Operands(Inst, 1);
4608 static_cast<ARMOperand&>(*Operands[OpIdx]).addMveSaturateOperands(Inst, 1);
4611 static_cast<ARMOperand&>(*Operands[OpIdx]).addShifterImmOperands(Inst, 1);
4614 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm1_16Operands(Inst, 1);
4617 static_cast<ARMOperand&>(*Operands[OpIdx]).addRotImmOperands(Inst, 1);
4620 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemTBBOperands(Inst, 2);
4623 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemTBHOperands(Inst, 2);
4626 static_cast<ARMOperand&>(*Operands[OpIdx]).addTraceSyncBarrierOptOperands(Inst, 1);
4629 static_cast<ARMOperand&>(*Operands[OpIdx]).addVPTPredNOperands(Inst, 2);
4632 static_cast<ARMOperand&>(*Operands[OpIdx]).addVPTPredROperands(Inst, 3);
4635 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi16splatNotOperands(Inst, 1);
4638 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi32splatNotOperands(Inst, 1);
4641 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi16splatOperands(Inst, 1);
4644 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi32splatOperands(Inst, 1);
4647 static_cast<ARMOperand&>(*Operands[OpIdx]).addComplexRotationOddOperands(Inst, 1);
4650 static_cast<ARMOperand&>(*Operands[OpIdx]).addComplexRotationEvenOperands(Inst, 1);
4653 static_cast<ARMOperand&>(*Operands[OpIdx]).addVectorIndex64Operands(Inst, 1);
4656 static_cast<ARMOperand&>(*Operands[OpIdx]).addVectorIndex32Operands(Inst, 1);
4659 static_cast<ARMOperand&>(*Operands[OpIdx]).addFBits16Operands(Inst, 1);
4662 static_cast<ARMOperand&>(*Operands[OpIdx]).addFBits32Operands(Inst, 1);
4665 static_cast<ARMOperand&>(*Operands[OpIdx]).addPowerTwoOperands(Inst, 1);
4668 static_cast<ARMOperand&>(*Operands[OpIdx]).addVectorIndex16Operands(Inst, 1);
4671 static_cast<ARMOperand&>(*Operands[OpIdx]).addVectorIndex8Operands(Inst, 1);
4674 static_cast<ARMOperand&>(*Operands[OpIdx]).addVecListOperands(Inst, 1);
4677 static_cast<ARMOperand&>(*Operands[OpIdx]).addDupAlignedMemory16Operands(Inst, 2);
4680 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemory64or128Operands(Inst, 2);
4683 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemory64or128or256Operands(Inst, 2);
4686 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemory64Operands(Inst, 2);
4689 static_cast<ARMOperand&>(*Operands[OpIdx]).addVecListIndexedOperands(Inst, 2);
4692 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemory16Operands(Inst, 2);
4695 static_cast<ARMOperand&>(*Operands[OpIdx]).addDupAlignedMemory32Operands(Inst, 2);
4698 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemory32Operands(Inst, 2);
4701 static_cast<ARMOperand&>(*Operands[OpIdx]).addDupAlignedMemoryNoneOperands(Inst, 2);
4704 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemoryNoneOperands(Inst, 2);
4707 static_cast<ARMOperand&>(*Operands[OpIdx]).addAlignedMemoryOperands(Inst, 2);
4710 static_cast<ARMOperand&>(*Operands[OpIdx]).addDupAlignedMemory64Operands(Inst, 2);
4713 static_cast<ARMOperand&>(*Operands[OpIdx]).addMVEVecListOperands(Inst, 1);
4716 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemNoOffsetT2Operands(Inst, 1);
4719 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemNoOffsetT2NoSpOperands(Inst, 1);
4722 static_cast<ARMOperand&>(*Operands[OpIdx]).addDupAlignedMemory64or128Operands(Inst, 2);
4725 static_cast<ARMOperand&>(*Operands[OpIdx]).addSPRRegListOperands(Inst, 1);
4728 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemImm7s4OffsetOperands(Inst, 2);
4731 static_cast<ARMOperand&>(*Operands[OpIdx]).addAddrMode5FP16Operands(Inst, 2);
4734 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm7s4Operands(Inst, 1);
4737 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemRegRQOffsetOperands(Inst, 2);
4740 static_cast<ARMOperand&>(*Operands[OpIdx]).addMemNoOffsetTOperands(Inst, 1);
4743 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm7Shift0Operands(Inst, 1);
4746 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm7Shift1Operands(Inst, 1);
4749 static_cast<ARMOperand&>(*Operands[OpIdx]).addImm7Shift2Operands(Inst, 1);
4752 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi32vmovOperands(Inst, 1);
4755 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONvmovi8ReplicateOperands(Inst, 1);
4758 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONvmovi16ReplicateOperands(Inst, 1);
4761 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi32vmovNegOperands(Inst, 1);
4764 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONvmovi32ReplicateOperands(Inst, 1);
4767 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi64splatOperands(Inst, 1);
4770 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONi8splatOperands(Inst, 1);
4773 static_cast<ARMOperand&>(*Operands[OpIdx]).addMVEVectorIndexOperands(Inst, 1);
4776 static_cast<ARMOperand&>(*Operands[OpIdx]).addMVEPairVectorIndexOperands(Inst, 1);
4782 static_cast<ARMOperand&>(*Operands[OpIdx]).addNEONinvi8ReplicateOperands(Inst, 1);
4785 static_cast<ARMOperand&>(*Operands[OpIdx]).addFPDRegListWithVPROperands(Inst, 1);
4788 static_cast<ARMOperand&>(*Operands[OpIdx]).addFPSRegListWithVPROperands(Inst, 1);
4810 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4811 Operands[*(p + 1)]->setConstraint("r");
4818 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4819 Operands[*(p + 1)]->setConstraint("r");
4823 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4824 Operands[*(p + 1)]->setConstraint("m");
4828 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4829 Operands[*(p + 1)]->setConstraint("m");
4833 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4834 Operands[*(p + 1)]->setConstraint("m");
4838 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4839 Operands[*(p + 1)]->setConstraint("m");
4843 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4844 Operands[*(p + 1)]->setConstraint("m");
4848 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4849 Operands[*(p + 1)]->setConstraint("m");
4853 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4854 Operands[*(p + 1)]->setConstraint("m");
4858 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4859 Operands[*(p + 1)]->setConstraint("m");
4863 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4864 Operands[*(p + 1)]->setConstraint("m");
4868 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4869 Operands[*(p + 1)]->setConstraint("m");
4873 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4874 Operands[*(p + 1)]->setConstraint("m");
4878 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4879 Operands[*(p + 1)]->setConstraint("m");
4883 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4884 Operands[*(p + 1)]->setConstraint("m");
4888 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4889 Operands[*(p + 1)]->setConstraint("m");
4893 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4894 Operands[*(p + 1)]->setConstraint("m");
4898 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4899 Operands[*(p + 1)]->setConstraint("m");
4903 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4904 Operands[*(p + 1)]->setConstraint("m");
4908 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4909 Operands[*(p + 1)]->setConstraint("m");
4913 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4914 Operands[*(p + 1)]->setConstraint("m");
4918 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4919 Operands[*(p + 1)]->setConstraint("m");
4923 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4924 Operands[*(p + 1)]->setConstraint("m");
4928 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4929 Operands[*(p + 1)]->setConstraint("m");
4933 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4934 Operands[*(p + 1)]->setConstraint("");
4938 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4939 Operands[*(p + 1)]->setConstraint("m");
4943 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4944 Operands[*(p + 1)]->setConstraint("m");
4948 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4949 Operands[*(p + 1)]->setConstraint("m");
4953 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4954 Operands[*(p + 1)]->setConstraint("m");
4958 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4959 Operands[*(p + 1)]->setConstraint("m");
4963 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4964 Operands[*(p + 1)]->setConstraint("m");
4968 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4969 Operands[*(p + 1)]->setConstraint("");
4973 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4974 Operands[*(p + 1)]->setConstraint("m");
4978 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4979 Operands[*(p + 1)]->setConstraint("");
4983 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4984 Operands[*(p + 1)]->setConstraint("");
4988 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4989 Operands[*(p + 1)]->setConstraint("m");
4993 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4994 Operands[*(p + 1)]->setConstraint("");
4998 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
4999 Operands[*(p + 1)]->setConstraint("m");
5003 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5004 Operands[*(p + 1)]->setConstraint("m");
5008 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5009 Operands[*(p + 1)]->setConstraint("");
5013 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5014 Operands[*(p + 1)]->setConstraint("m");
5018 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5019 Operands[*(p + 1)]->setConstraint("m");
5023 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5024 Operands[*(p + 1)]->setConstraint("m");
5028 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5029 Operands[*(p + 1)]->setConstraint("m");
5033 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5034 Operands[*(p + 1)]->setConstraint("m");
5038 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5039 Operands[*(p + 1)]->setConstraint("m");
5043 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5044 Operands[*(p + 1)]->setConstraint("m");
5048 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5049 Operands[*(p + 1)]->setConstraint("m");
5053 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5054 Operands[*(p + 1)]->setConstraint("m");
5058 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5059 Operands[*(p + 1)]->setConstraint("m");
5063 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5064 Operands[*(p + 1)]->setConstraint("m");
5068 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5069 Operands[*(p + 1)]->setConstraint("m");
5073 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5074 Operands[*(p + 1)]->setConstraint("m");
5078 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5079 Operands[*(p + 1)]->setConstraint("m");
5083 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5084 Operands[*(p + 1)]->setConstraint("m");
5088 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5089 Operands[*(p + 1)]->setConstraint("m");
5093 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5094 Operands[*(p + 1)]->setConstraint("m");
5098 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5099 Operands[*(p + 1)]->setConstraint("m");
5103 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5104 Operands[*(p + 1)]->setConstraint("m");
5108 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5109 Operands[*(p + 1)]->setConstraint("m");
5113 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5114 Operands[*(p + 1)]->setConstraint("m");
5118 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5119 Operands[*(p + 1)]->setConstraint("m");
5123 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5124 Operands[*(p + 1)]->setConstraint("m");
5128 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5129 Operands[*(p + 1)]->setConstraint("m");
5133 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5134 Operands[*(p + 1)]->setConstraint("m");
5138 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5139 Operands[*(p + 1)]->setConstraint("m");
5143 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5144 Operands[*(p + 1)]->setConstraint("m");
5148 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5149 Operands[*(p + 1)]->setConstraint("m");
5153 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5154 Operands[*(p + 1)]->setConstraint("m");
5158 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5159 Operands[*(p + 1)]->setConstraint("m");
5163 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5164 Operands[*(p + 1)]->setConstraint("");
5168 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5169 Operands[*(p + 1)]->setConstraint("m");
5173 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5174 Operands[*(p + 1)]->setConstraint("m");
5178 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5179 Operands[*(p + 1)]->setConstraint("m");
5183 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5184 Operands[*(p + 1)]->setConstraint("m");
5188 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5189 Operands[*(p + 1)]->setConstraint("m");
5193 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5194 Operands[*(p + 1)]->setConstraint("");
5198 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5199 Operands[*(p + 1)]->setConstraint("m");
5203 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5204 Operands[*(p + 1)]->setConstraint("");
5208 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5209 Operands[*(p + 1)]->setConstraint("m");
5213 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5214 Operands[*(p + 1)]->setConstraint("m");
5218 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5219 Operands[*(p + 1)]->setConstraint("m");
5223 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5224 Operands[*(p + 1)]->setConstraint("m");
5228 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5229 Operands[*(p + 1)]->setConstraint("m");
5233 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5234 Operands[*(p + 1)]->setConstraint("m");
5238 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5239 Operands[*(p + 1)]->setConstraint("m");
5243 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5244 Operands[*(p + 1)]->setConstraint("m");
5248 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5249 Operands[*(p + 1)]->setConstraint("m");
5253 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5254 Operands[*(p + 1)]->setConstraint("m");
5258 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5259 Operands[*(p + 1)]->setConstraint("m");
5263 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5264 Operands[*(p + 1)]->setConstraint("m");
5268 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5269 Operands[*(p + 1)]->setConstraint("m");
5273 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5274 Operands[*(p + 1)]->setConstraint("m");
5278 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5279 Operands[*(p + 1)]->setConstraint("m");
5283 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5284 Operands[*(p + 1)]->setConstraint("m");
5288 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5289 Operands[*(p + 1)]->setConstraint("m");
5293 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5294 Operands[*(p + 1)]->setConstraint("m");
5298 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5299 Operands[*(p + 1)]->setConstraint("m");
5303 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5304 Operands[*(p + 1)]->setConstraint("m");
5308 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5309 Operands[*(p + 1)]->setConstraint("m");
5313 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5314 Operands[*(p + 1)]->setConstraint("m");
5318 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5319 Operands[*(p + 1)]->setConstraint("m");
5323 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5324 Operands[*(p + 1)]->setConstraint("m");
5328 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5329 Operands[*(p + 1)]->setConstraint("m");
5333 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5334 Operands[*(p + 1)]->setConstraint("m");
5338 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5339 Operands[*(p + 1)]->setConstraint("m");
5343 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5344 Operands[*(p + 1)]->setConstraint("m");
5348 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5349 Operands[*(p + 1)]->setConstraint("m");
5353 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5354 Operands[*(p + 1)]->setConstraint("m");
5358 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5359 Operands[*(p + 1)]->setConstraint("m");
5363 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5364 Operands[*(p + 1)]->setConstraint("m");
5368 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5369 Operands[*(p + 1)]->setConstraint("m");
5373 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5374 Operands[*(p + 1)]->setConstraint("m");
5378 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5379 Operands[*(p + 1)]->setConstraint("m");
5383 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5384 Operands[*(p + 1)]->setConstraint("m");
5388 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5389 Operands[*(p + 1)]->setConstraint("m");
5393 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5394 Operands[*(p + 1)]->setConstraint("m");
5398 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5399 Operands[*(p + 1)]->setConstraint("m");
5403 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5404 Operands[*(p + 1)]->setConstraint("m");
5408 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5409 Operands[*(p + 1)]->setConstraint("m");
5413 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5414 Operands[*(p + 1)]->setConstraint("m");
5418 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5419 Operands[*(p + 1)]->setConstraint("m");
5423 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5424 Operands[*(p + 1)]->setConstraint("m");
5428 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5429 Operands[*(p + 1)]->setConstraint("m");
5433 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5434 Operands[*(p + 1)]->setConstraint("m");
5438 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5439 Operands[*(p + 1)]->setConstraint("m");
5443 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5444 Operands[*(p + 1)]->setConstraint("m");
5448 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5449 Operands[*(p + 1)]->setConstraint("m");
5453 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5454 Operands[*(p + 1)]->setConstraint("m");
5458 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5459 Operands[*(p + 1)]->setConstraint("m");
5463 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5464 Operands[*(p + 1)]->setConstraint("m");
5468 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5469 Operands[*(p + 1)]->setConstraint("m");
5473 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5474 Operands[*(p + 1)]->setConstraint("m");
5478 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5479 Operands[*(p + 1)]->setConstraint("m");
5483 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5484 Operands[*(p + 1)]->setConstraint("m");
5488 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5489 Operands[*(p + 1)]->setConstraint("m");
5493 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5494 Operands[*(p + 1)]->setConstraint("m");
5498 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5499 Operands[*(p + 1)]->setConstraint("m");
5503 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5504 Operands[*(p + 1)]->setConstraint("m");
5508 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5509 Operands[*(p + 1)]->setConstraint("");
5513 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5514 Operands[*(p + 1)]->setConstraint("");
15082 StringRef Mnemonic = ((ARMOperand&)*Operands[0]).getToken();
15126 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
15152 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
15304 SMLoc Loc = ((ARMOperand&)*Operands[0]).getStartLoc();
gen/lib/Target/AVR/AVRGenAsmMatcher.inc 505 static_cast<AVROperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
517 static_cast<AVROperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
520 static_cast<AVROperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
538 static_cast<AVROperand&>(*Operands[OpIdx]).addImmCom8Operands(Inst, 1);
550 static_cast<AVROperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
553 static_cast<AVROperand&>(*Operands[OpIdx]).addMemriOperands(Inst, 2);
572 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
573 Operands[*(p + 1)]->setConstraint("r");
580 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
581 Operands[*(p + 1)]->setConstraint("r");
585 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
586 Operands[*(p + 1)]->setConstraint("m");
590 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
591 Operands[*(p + 1)]->setConstraint("");
595 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
596 Operands[*(p + 1)]->setConstraint("");
600 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
601 Operands[*(p + 1)]->setConstraint("");
605 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
606 Operands[*(p + 1)]->setConstraint("");
610 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
611 Operands[*(p + 1)]->setConstraint("");
615 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
616 Operands[*(p + 1)]->setConstraint("m");
620 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
621 Operands[*(p + 1)]->setConstraint("");
625 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
626 Operands[*(p + 1)]->setConstraint("");
630 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
631 Operands[*(p + 1)]->setConstraint("");
635 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
636 Operands[*(p + 1)]->setConstraint("m");
640 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
641 Operands[*(p + 1)]->setConstraint("m");
645 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
646 Operands[*(p + 1)]->setConstraint("");
1021 auto &SrcOp1 = Operands[OpndNum1];
1022 auto &SrcOp2 = Operands[OpndNum2];
1272 StringRef Mnemonic = ((AVROperand&)*Operands[0]).getToken();
1316 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
1325 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/BPF/BPFGenAsmMatcher.inc 277 static_cast<BPFOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
289 static_cast<BPFOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
292 static_cast<BPFOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
311 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
312 Operands[*(p + 1)]->setConstraint("r");
319 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
320 Operands[*(p + 1)]->setConstraint("r");
324 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
325 Operands[*(p + 1)]->setConstraint("m");
329 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
330 Operands[*(p + 1)]->setConstraint("");
709 auto &SrcOp1 = Operands[OpndNum1];
710 auto &SrcOp2 = Operands[OpndNum2];
913 if (Operands[0]->isToken())
914 Mnemonic = ((BPFOperand&)*Operands[0]).getToken();
959 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
968 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/Hexagon/HexagonGenAsmMatcher.inc 2554 static_cast<HexagonOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
2566 static_cast<HexagonOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
2569 static_cast<HexagonOperand&>(*Operands[OpIdx]).addSignedImmOperands(Inst, 1);
2572 static_cast<HexagonOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
2596 static_cast<HexagonOperand&>(*Operands[OpIdx]).addn1ConstOperands(Inst, 1);
2615 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2616 Operands[*(p + 1)]->setConstraint("r");
2623 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2624 Operands[*(p + 1)]->setConstraint("r");
2628 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2629 Operands[*(p + 1)]->setConstraint("m");
2633 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2634 Operands[*(p + 1)]->setConstraint("m");
2638 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2639 Operands[*(p + 1)]->setConstraint("m");
2643 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2644 Operands[*(p + 1)]->setConstraint("");
2648 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2649 Operands[*(p + 1)]->setConstraint("");
2653 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2654 Operands[*(p + 1)]->setConstraint("");
2658 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2659 Operands[*(p + 1)]->setConstraint("m");
2663 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2664 Operands[*(p + 1)]->setConstraint("m");
2668 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2669 Operands[*(p + 1)]->setConstraint("m");
2673 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2674 Operands[*(p + 1)]->setConstraint("m");
2678 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2679 Operands[*(p + 1)]->setConstraint("m");
7492 auto &SrcOp1 = Operands[OpndNum1];
7493 auto &SrcOp2 = Operands[OpndNum2];
10259 if (Operands[0]->isToken())
10260 Mnemonic = ((HexagonOperand&)*Operands[0]).getToken();
10305 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
10314 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/Lanai/LanaiGenAsmMatcher.inc 353 static_cast<LanaiOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
365 static_cast<LanaiOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
368 static_cast<LanaiOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
371 static_cast<LanaiOperand&>(*Operands[OpIdx]).addHiImm16Operands(Inst, 1);
374 static_cast<LanaiOperand&>(*Operands[OpIdx]).addLoImm16Operands(Inst, 1);
377 static_cast<LanaiOperand&>(*Operands[OpIdx]).addCondCodeOperands(Inst, 1);
380 static_cast<LanaiOperand&>(*Operands[OpIdx]).addHiImm16AndOperands(Inst, 1);
383 static_cast<LanaiOperand&>(*Operands[OpIdx]).addLoImm16AndOperands(Inst, 1);
386 static_cast<LanaiOperand&>(*Operands[OpIdx]).addBrTargetOperands(Inst, 1);
389 static_cast<LanaiOperand&>(*Operands[OpIdx]).addMemImmOperands(Inst, 1);
392 static_cast<LanaiOperand&>(*Operands[OpIdx]).addMemRegImmOperands(Inst, 3);
395 static_cast<LanaiOperand&>(*Operands[OpIdx]).addMemRegRegOperands(Inst, 3);
398 static_cast<LanaiOperand&>(*Operands[OpIdx]).addMemSplsOperands(Inst, 3);
410 static_cast<LanaiOperand&>(*Operands[OpIdx]).addLoImm21Operands(Inst, 1);
413 static_cast<LanaiOperand&>(*Operands[OpIdx]).addImmShiftOperands(Inst, 1);
429 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
430 Operands[*(p + 1)]->setConstraint("r");
437 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
438 Operands[*(p + 1)]->setConstraint("m");
442 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
443 Operands[*(p + 1)]->setConstraint("r");
447 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
448 Operands[*(p + 1)]->setConstraint("m");
452 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
453 Operands[*(p + 1)]->setConstraint("m");
457 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
458 Operands[*(p + 1)]->setConstraint("m");
462 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
463 Operands[*(p + 1)]->setConstraint("m");
467 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
468 Operands[*(p + 1)]->setConstraint("m");
472 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
473 Operands[*(p + 1)]->setConstraint("m");
477 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
478 Operands[*(p + 1)]->setConstraint("m");
482 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
483 Operands[*(p + 1)]->setConstraint("m");
487 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
488 Operands[*(p + 1)]->setConstraint("m");
492 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
493 Operands[*(p + 1)]->setConstraint("m");
497 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
498 Operands[*(p + 1)]->setConstraint("m");
502 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
503 Operands[*(p + 1)]->setConstraint("");
507 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
508 Operands[*(p + 1)]->setConstraint("m");
512 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
513 Operands[*(p + 1)]->setConstraint("m");
517 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
518 Operands[*(p + 1)]->setConstraint("m");
875 auto &SrcOp1 = Operands[OpndNum1];
876 auto &SrcOp2 = Operands[OpndNum2];
1056 StringRef Mnemonic = ((LanaiOperand&)*Operands[0]).getToken();
1100 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
1109 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/MSP430/MSP430GenAsmMatcher.inc 338 static_cast<MSP430Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
350 static_cast<MSP430Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
356 static_cast<MSP430Operand&>(*Operands[OpIdx]).addMemOperands(Inst, 2);
359 static_cast<MSP430Operand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
362 static_cast<MSP430Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
399 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
400 Operands[*(p + 1)]->setConstraint("r");
407 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
408 Operands[*(p + 1)]->setConstraint("r");
412 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
413 Operands[*(p + 1)]->setConstraint("");
417 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
418 Operands[*(p + 1)]->setConstraint("m");
422 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
423 Operands[*(p + 1)]->setConstraint("m");
427 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
428 Operands[*(p + 1)]->setConstraint("m");
432 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
433 Operands[*(p + 1)]->setConstraint("m");
437 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
438 Operands[*(p + 1)]->setConstraint("");
442 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
443 Operands[*(p + 1)]->setConstraint("");
447 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
448 Operands[*(p + 1)]->setConstraint("");
452 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
453 Operands[*(p + 1)]->setConstraint("");
457 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
458 Operands[*(p + 1)]->setConstraint("");
462 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
463 Operands[*(p + 1)]->setConstraint("m");
643 auto &SrcOp1 = Operands[OpndNum1];
644 auto &SrcOp2 = Operands[OpndNum2];
1114 StringRef Mnemonic = ((MSP430Operand&)*Operands[0]).getToken();
1158 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
1167 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/Mips/MipsGenAsmMatcher.inc 1334 static_cast<MipsOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
1346 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPR32AsmRegOperands(Inst, 1);
1349 static_cast<MipsOperand&>(*Operands[OpIdx]).addAFGR64AsmRegOperands(Inst, 1);
1352 static_cast<MipsOperand&>(*Operands[OpIdx]).addFGR64AsmRegOperands(Inst, 1);
1355 static_cast<MipsOperand&>(*Operands[OpIdx]).addFGR32AsmRegOperands(Inst, 1);
1358 static_cast<MipsOperand&>(*Operands[OpIdx]).addSImmOperands<32>(Inst, 1);
1361 static_cast<MipsOperand&>(*Operands[OpIdx]).addMSA128AsmRegOperands(Inst, 1);
1364 static_cast<MipsOperand&>(*Operands[OpIdx]).addSImmOperands<16>(Inst, 1);
1367 static_cast<MipsOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
1370 static_cast<MipsOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
1373 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPRMM16AsmRegOperands(Inst, 1);
1376 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantSImmOperands<4, 0>(Inst, 1);
1379 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<5, 0>(Inst, 1);
1382 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<2, 0>(Inst, 1);
1385 static_cast<MipsOperand&>(*Operands[OpIdx]).addUImmOperands<16>(Inst, 1);
1388 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPR64AsmRegOperands(Inst, 1);
1391 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<8, 0>(Inst, 1);
1397 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<5, 32, -32>(Inst, 1);
1403 static_cast<MipsOperand&>(*Operands[OpIdx]).addFCCAsmRegOperands(Inst, 1);
1406 static_cast<MipsOperand&>(*Operands[OpIdx]).addCOP2AsmRegOperands(Inst, 1);
1409 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<3, 0>(Inst, 1);
1412 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<6, 0>(Inst, 1);
1415 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<4, 0>(Inst, 1);
1421 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<10, 0>(Inst, 1);
1424 static_cast<MipsOperand&>(*Operands[OpIdx]).addMemOperands(Inst, 2);
1427 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantSImmOperands<5, 0>(Inst, 1);
1430 static_cast<MipsOperand&>(*Operands[OpIdx]).addCCRAsmRegOperands(Inst, 1);
1433 static_cast<MipsOperand&>(*Operands[OpIdx]).addMSACtrlAsmRegOperands(Inst, 1);
1436 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<1, 0>(Inst, 1);
1439 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<5, 33>(Inst, 1);
1442 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<5, 32>(Inst, 1);
1445 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<5, 1>(Inst, 1);
1448 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPR32NonZeroAsmRegOperands(Inst, 1);
1451 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPR32ZeroAsmRegOperands(Inst, 1);
1454 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<2, 1>(Inst, 1);
1457 static_cast<MipsOperand&>(*Operands[OpIdx]).addCOP0AsmRegOperands(Inst, 1);
1463 static_cast<MipsOperand&>(*Operands[OpIdx]).addACC64DSPAsmRegOperands(Inst, 1);
1466 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<1>(Inst, 1);
1475 static_cast<MipsOperand&>(*Operands[OpIdx]).addMicroMipsMemOperands(Inst, 2);
1478 static_cast<MipsOperand&>(*Operands[OpIdx]).addCOP3AsmRegOperands(Inst, 1);
1481 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantSImmOperands<10, 0>(Inst, 1);
1484 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<32>(Inst, 1);
1487 static_cast<MipsOperand&>(*Operands[OpIdx]).addStrictlyAFGR64AsmRegOperands(Inst, 1);
1490 static_cast<MipsOperand&>(*Operands[OpIdx]).addStrictlyFGR64AsmRegOperands(Inst, 1);
1493 static_cast<MipsOperand&>(*Operands[OpIdx]).addStrictlyFGR32AsmRegOperands(Inst, 1);
1496 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<7, -1>(Inst, 1);
1499 static_cast<MipsOperand&>(*Operands[OpIdx]).addRegListOperands(Inst, 1);
1508 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPRMM16AsmRegMovePPairFirstOperands(Inst, 1);
1511 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPRMM16AsmRegMovePPairSecondOperands(Inst, 1);
1514 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPRMM16AsmRegMovePOperands(Inst, 1);
1517 static_cast<MipsOperand&>(*Operands[OpIdx]).addHI32DSPAsmRegOperands(Inst, 1);
1520 static_cast<MipsOperand&>(*Operands[OpIdx]).addLO32DSPAsmRegOperands(Inst, 1);
1526 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<7, 0>(Inst, 1);
1529 static_cast<MipsOperand&>(*Operands[OpIdx]).addHWRegsAsmRegOperands(Inst, 1);
1532 static_cast<MipsOperand&>(*Operands[OpIdx]).addGPRMM16AsmRegZeroOperands(Inst, 1);
1535 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantUImmOperands<20, 0>(Inst, 1);
1538 static_cast<MipsOperand&>(*Operands[OpIdx]).addConstantSImmOperands<6, 0>(Inst, 1);
1569 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1570 Operands[*(p + 1)]->setConstraint("r");
1577 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1578 Operands[*(p + 1)]->setConstraint("m");
1582 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1583 Operands[*(p + 1)]->setConstraint("m");
1587 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1588 Operands[*(p + 1)]->setConstraint("m");
1592 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1593 Operands[*(p + 1)]->setConstraint("m");
1597 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1598 Operands[*(p + 1)]->setConstraint("m");
1602 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1603 Operands[*(p + 1)]->setConstraint("m");
1607 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1608 Operands[*(p + 1)]->setConstraint("m");
1612 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1613 Operands[*(p + 1)]->setConstraint("r");
1617 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1618 Operands[*(p + 1)]->setConstraint("m");
1622 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1623 Operands[*(p + 1)]->setConstraint("m");
1627 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1628 Operands[*(p + 1)]->setConstraint("m");
1632 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1633 Operands[*(p + 1)]->setConstraint("m");
1637 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1638 Operands[*(p + 1)]->setConstraint("m");
1642 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1643 Operands[*(p + 1)]->setConstraint("m");
1647 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1648 Operands[*(p + 1)]->setConstraint("m");
1652 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1653 Operands[*(p + 1)]->setConstraint("m");
1657 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1658 Operands[*(p + 1)]->setConstraint("m");
1662 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1663 Operands[*(p + 1)]->setConstraint("m");
1667 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1668 Operands[*(p + 1)]->setConstraint("m");
1672 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1673 Operands[*(p + 1)]->setConstraint("m");
1677 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1678 Operands[*(p + 1)]->setConstraint("m");
1682 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1683 Operands[*(p + 1)]->setConstraint("m");
1687 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1688 Operands[*(p + 1)]->setConstraint("m");
1692 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1693 Operands[*(p + 1)]->setConstraint("m");
1697 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1698 Operands[*(p + 1)]->setConstraint("");
1702 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1703 Operands[*(p + 1)]->setConstraint("m");
1707 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1708 Operands[*(p + 1)]->setConstraint("m");
1712 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1713 Operands[*(p + 1)]->setConstraint("m");
1717 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1718 Operands[*(p + 1)]->setConstraint("m");
1722 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1723 Operands[*(p + 1)]->setConstraint("m");
1727 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1728 Operands[*(p + 1)]->setConstraint("m");
1732 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1733 Operands[*(p + 1)]->setConstraint("m");
1737 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1738 Operands[*(p + 1)]->setConstraint("m");
1742 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1743 Operands[*(p + 1)]->setConstraint("m");
1747 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1748 Operands[*(p + 1)]->setConstraint("m");
1752 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1753 Operands[*(p + 1)]->setConstraint("m");
1757 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1758 Operands[*(p + 1)]->setConstraint("m");
1762 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1763 Operands[*(p + 1)]->setConstraint("m");
1767 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1768 Operands[*(p + 1)]->setConstraint("m");
1772 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1773 Operands[*(p + 1)]->setConstraint("m");
1777 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1778 Operands[*(p + 1)]->setConstraint("m");
1782 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1783 Operands[*(p + 1)]->setConstraint("m");
1787 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1788 Operands[*(p + 1)]->setConstraint("m");
1792 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1793 Operands[*(p + 1)]->setConstraint("m");
1797 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1798 Operands[*(p + 1)]->setConstraint("m");
1802 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1803 Operands[*(p + 1)]->setConstraint("m");
1807 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1808 Operands[*(p + 1)]->setConstraint("m");
1812 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1813 Operands[*(p + 1)]->setConstraint("m");
1817 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1818 Operands[*(p + 1)]->setConstraint("m");
1822 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1823 Operands[*(p + 1)]->setConstraint("m");
1827 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1828 Operands[*(p + 1)]->setConstraint("m");
1832 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1833 Operands[*(p + 1)]->setConstraint("m");
1837 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1838 Operands[*(p + 1)]->setConstraint("m");
1842 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1843 Operands[*(p + 1)]->setConstraint("m");
1847 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1848 Operands[*(p + 1)]->setConstraint("m");
1852 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1853 Operands[*(p + 1)]->setConstraint("m");
1857 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1858 Operands[*(p + 1)]->setConstraint("m");
1862 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1863 Operands[*(p + 1)]->setConstraint("m");
1867 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1868 Operands[*(p + 1)]->setConstraint("m");
1872 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1873 Operands[*(p + 1)]->setConstraint("m");
1877 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1878 Operands[*(p + 1)]->setConstraint("m");
1882 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1883 Operands[*(p + 1)]->setConstraint("m");
1887 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1888 Operands[*(p + 1)]->setConstraint("m");
1892 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1893 Operands[*(p + 1)]->setConstraint("m");
1897 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1898 Operands[*(p + 1)]->setConstraint("");
1902 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1903 Operands[*(p + 1)]->setConstraint("");
1907 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1908 Operands[*(p + 1)]->setConstraint("");
1912 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1913 Operands[*(p + 1)]->setConstraint("");
1917 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1918 Operands[*(p + 1)]->setConstraint("");
4892 auto &SrcOp1 = Operands[OpndNum1];
4893 auto &SrcOp2 = Operands[OpndNum2];
8090 StringRef Mnemonic = ((MipsOperand&)*Operands[0]).getToken();
8134 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
8143 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/PowerPC/PPCGenAsmMatcher.inc 2090 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
2102 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegG8RCOperands(Inst, 1);
2105 static_cast<PPCOperand&>(*Operands[OpIdx]).addTLSRegOperands(Inst, 1);
2108 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegGPRCOperands(Inst, 1);
2111 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegGPRCNoR0Operands(Inst, 1);
2114 static_cast<PPCOperand&>(*Operands[OpIdx]).addS16ImmOperands(Inst, 1);
2117 static_cast<PPCOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
2120 static_cast<PPCOperand&>(*Operands[OpIdx]).addU16ImmOperands(Inst, 1);
2123 static_cast<PPCOperand&>(*Operands[OpIdx]).addBranchTargetOperands(Inst, 1);
2126 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegCRBITRCOperands(Inst, 1);
2138 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegVRRCOperands(Inst, 1);
2153 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegCRRCOperands(Inst, 1);
2228 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegGxRCNoR0Operands(Inst, 1);
2231 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegGxRCOperands(Inst, 1);
2237 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegSPERCOperands(Inst, 1);
2240 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegSPE4RCOperands(Inst, 1);
2243 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegF4RCOperands(Inst, 1);
2246 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegF8RCOperands(Inst, 1);
2252 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegVFRCOperands(Inst, 1);
2255 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegVSFRCOperands(Inst, 1);
2258 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegVSSRCOperands(Inst, 1);
2261 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegVSRCOperands(Inst, 1);
2369 static_cast<PPCOperand&>(*Operands[OpIdx]).addCRBitMaskOperands(Inst, 1);
2447 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegG8RCNoX0Operands(Inst, 1);
2450 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegQFRCOperands(Inst, 1);
2453 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegQSRCOperands(Inst, 1);
2456 static_cast<PPCOperand&>(*Operands[OpIdx]).addRegQBRCOperands(Inst, 1);
2487 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2488 Operands[*(p + 1)]->setConstraint("r");
2495 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2496 Operands[*(p + 1)]->setConstraint("m");
2500 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2501 Operands[*(p + 1)]->setConstraint("m");
2505 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2506 Operands[*(p + 1)]->setConstraint("m");
2510 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2511 Operands[*(p + 1)]->setConstraint("m");
2515 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2516 Operands[*(p + 1)]->setConstraint("m");
2520 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2521 Operands[*(p + 1)]->setConstraint("m");
2525 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2526 Operands[*(p + 1)]->setConstraint("m");
2530 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2531 Operands[*(p + 1)]->setConstraint("m");
2535 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2536 Operands[*(p + 1)]->setConstraint("m");
2540 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2541 Operands[*(p + 1)]->setConstraint("");
2545 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2546 Operands[*(p + 1)]->setConstraint("");
2550 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2551 Operands[*(p + 1)]->setConstraint("");
2555 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2556 Operands[*(p + 1)]->setConstraint("m");
2560 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2561 Operands[*(p + 1)]->setConstraint("");
2565 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2566 Operands[*(p + 1)]->setConstraint("");
2570 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2571 Operands[*(p + 1)]->setConstraint("");
2575 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2576 Operands[*(p + 1)]->setConstraint("m");
2580 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2581 Operands[*(p + 1)]->setConstraint("m");
2585 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2586 Operands[*(p + 1)]->setConstraint("");
2590 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2591 Operands[*(p + 1)]->setConstraint("");
2595 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2596 Operands[*(p + 1)]->setConstraint("");
2600 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2601 Operands[*(p + 1)]->setConstraint("");
2605 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2606 Operands[*(p + 1)]->setConstraint("");
2610 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2611 Operands[*(p + 1)]->setConstraint("");
2615 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2616 Operands[*(p + 1)]->setConstraint("");
2620 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2621 Operands[*(p + 1)]->setConstraint("");
2625 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2626 Operands[*(p + 1)]->setConstraint("");
2630 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2631 Operands[*(p + 1)]->setConstraint("");
2635 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2636 Operands[*(p + 1)]->setConstraint("");
2640 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2641 Operands[*(p + 1)]->setConstraint("");
2645 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2646 Operands[*(p + 1)]->setConstraint("");
2650 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2651 Operands[*(p + 1)]->setConstraint("");
2655 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2656 Operands[*(p + 1)]->setConstraint("");
2660 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2661 Operands[*(p + 1)]->setConstraint("");
2665 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2666 Operands[*(p + 1)]->setConstraint("");
2670 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2671 Operands[*(p + 1)]->setConstraint("");
2675 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2676 Operands[*(p + 1)]->setConstraint("");
2680 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2681 Operands[*(p + 1)]->setConstraint("");
2685 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2686 Operands[*(p + 1)]->setConstraint("");
2690 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2691 Operands[*(p + 1)]->setConstraint("");
2695 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2696 Operands[*(p + 1)]->setConstraint("");
2700 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2701 Operands[*(p + 1)]->setConstraint("");
2705 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2706 Operands[*(p + 1)]->setConstraint("m");
2710 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2711 Operands[*(p + 1)]->setConstraint("m");
2715 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2716 Operands[*(p + 1)]->setConstraint("m");
2720 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2721 Operands[*(p + 1)]->setConstraint("m");
2725 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2726 Operands[*(p + 1)]->setConstraint("m");
2730 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2731 Operands[*(p + 1)]->setConstraint("m");
2735 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2736 Operands[*(p + 1)]->setConstraint("m");
2740 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2741 Operands[*(p + 1)]->setConstraint("");
2745 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2746 Operands[*(p + 1)]->setConstraint("m");
2750 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2751 Operands[*(p + 1)]->setConstraint("m");
2755 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2756 Operands[*(p + 1)]->setConstraint("m");
2760 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2761 Operands[*(p + 1)]->setConstraint("m");
2765 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2766 Operands[*(p + 1)]->setConstraint("");
2770 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2771 Operands[*(p + 1)]->setConstraint("");
2775 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2776 Operands[*(p + 1)]->setConstraint("");
2780 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2781 Operands[*(p + 1)]->setConstraint("");
2785 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2786 Operands[*(p + 1)]->setConstraint("");
2790 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2791 Operands[*(p + 1)]->setConstraint("");
2795 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2796 Operands[*(p + 1)]->setConstraint("");
2800 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2801 Operands[*(p + 1)]->setConstraint("");
2805 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2806 Operands[*(p + 1)]->setConstraint("");
2810 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2811 Operands[*(p + 1)]->setConstraint("");
2815 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2816 Operands[*(p + 1)]->setConstraint("");
2820 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2821 Operands[*(p + 1)]->setConstraint("");
2825 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2826 Operands[*(p + 1)]->setConstraint("");
2830 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2831 Operands[*(p + 1)]->setConstraint("");
2835 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2836 Operands[*(p + 1)]->setConstraint("");
2840 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2841 Operands[*(p + 1)]->setConstraint("");
2845 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2846 Operands[*(p + 1)]->setConstraint("");
2850 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2851 Operands[*(p + 1)]->setConstraint("");
2855 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2856 Operands[*(p + 1)]->setConstraint("");
2860 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2861 Operands[*(p + 1)]->setConstraint("");
2865 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2866 Operands[*(p + 1)]->setConstraint("");
2870 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2871 Operands[*(p + 1)]->setConstraint("");
2875 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2876 Operands[*(p + 1)]->setConstraint("");
2880 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2881 Operands[*(p + 1)]->setConstraint("");
2885 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2886 Operands[*(p + 1)]->setConstraint("");
2890 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2891 Operands[*(p + 1)]->setConstraint("");
2895 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2896 Operands[*(p + 1)]->setConstraint("");
2900 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2901 Operands[*(p + 1)]->setConstraint("");
2905 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2906 Operands[*(p + 1)]->setConstraint("");
2910 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2911 Operands[*(p + 1)]->setConstraint("");
2915 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2916 Operands[*(p + 1)]->setConstraint("");
2920 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2921 Operands[*(p + 1)]->setConstraint("");
2925 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2926 Operands[*(p + 1)]->setConstraint("");
2930 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2931 Operands[*(p + 1)]->setConstraint("");
2935 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2936 Operands[*(p + 1)]->setConstraint("");
2940 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2941 Operands[*(p + 1)]->setConstraint("m");
2945 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2946 Operands[*(p + 1)]->setConstraint("");
2950 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2951 Operands[*(p + 1)]->setConstraint("");
2955 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2956 Operands[*(p + 1)]->setConstraint("");
2960 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2961 Operands[*(p + 1)]->setConstraint("");
2965 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2966 Operands[*(p + 1)]->setConstraint("");
2970 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2971 Operands[*(p + 1)]->setConstraint("");
2975 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2976 Operands[*(p + 1)]->setConstraint("");
2980 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2981 Operands[*(p + 1)]->setConstraint("");
2985 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2986 Operands[*(p + 1)]->setConstraint("");
2990 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2991 Operands[*(p + 1)]->setConstraint("");
2995 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
2996 Operands[*(p + 1)]->setConstraint("");
3000 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3001 Operands[*(p + 1)]->setConstraint("");
3005 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3006 Operands[*(p + 1)]->setConstraint("");
3010 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3011 Operands[*(p + 1)]->setConstraint("");
3015 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3016 Operands[*(p + 1)]->setConstraint("");
3020 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3021 Operands[*(p + 1)]->setConstraint("");
3025 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3026 Operands[*(p + 1)]->setConstraint("");
3030 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3031 Operands[*(p + 1)]->setConstraint("");
3035 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3036 Operands[*(p + 1)]->setConstraint("");
3040 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3041 Operands[*(p + 1)]->setConstraint("");
3045 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3046 Operands[*(p + 1)]->setConstraint("");
3050 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3051 Operands[*(p + 1)]->setConstraint("");
3055 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3056 Operands[*(p + 1)]->setConstraint("");
3060 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3061 Operands[*(p + 1)]->setConstraint("");
3065 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3066 Operands[*(p + 1)]->setConstraint("");
3070 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3071 Operands[*(p + 1)]->setConstraint("m");
3075 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3076 Operands[*(p + 1)]->setConstraint("m");
3080 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3081 Operands[*(p + 1)]->setConstraint("m");
3085 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3086 Operands[*(p + 1)]->setConstraint("m");
3090 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3091 Operands[*(p + 1)]->setConstraint("");
3095 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3096 Operands[*(p + 1)]->setConstraint("");
3100 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3101 Operands[*(p + 1)]->setConstraint("");
3105 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3106 Operands[*(p + 1)]->setConstraint("");
3110 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
3111 Operands[*(p + 1)]->setConstraint("");
4131 auto &SrcOp1 = Operands[OpndNum1];
4132 auto &SrcOp2 = Operands[OpndNum2];
7016 StringRef Mnemonic = ((PPCOperand&)*Operands[0]).getToken();
7063 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
7072 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
7186 SMLoc Loc = ((PPCOperand&)*Operands[0]).getStartLoc();
gen/lib/Target/RISCV/RISCVGenAsmMatcher.inc 959 static_cast<RISCVOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
971 static_cast<RISCVOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
974 static_cast<RISCVOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
977 static_cast<RISCVOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
986 static_cast<RISCVOperand&>(*Operands[OpIdx]).addCSRSystemRegisterOperands(Inst, 1);
992 static_cast<RISCVOperand&>(*Operands[OpIdx]).addFRMArgOperands(Inst, 1);
998 static_cast<RISCVOperand&>(*Operands[OpIdx]).addFenceArgOperands(Inst, 1);
1047 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1048 Operands[*(p + 1)]->setConstraint("r");
1055 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1056 Operands[*(p + 1)]->setConstraint("r");
1060 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1061 Operands[*(p + 1)]->setConstraint("m");
1065 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1066 Operands[*(p + 1)]->setConstraint("m");
1070 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1071 Operands[*(p + 1)]->setConstraint("m");
1075 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1076 Operands[*(p + 1)]->setConstraint("");
1080 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1081 Operands[*(p + 1)]->setConstraint("m");
1085 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1086 Operands[*(p + 1)]->setConstraint("");
1090 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1091 Operands[*(p + 1)]->setConstraint("m");
1095 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1096 Operands[*(p + 1)]->setConstraint("");
1100 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1101 Operands[*(p + 1)]->setConstraint("m");
1105 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1106 Operands[*(p + 1)]->setConstraint("");
1110 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1111 Operands[*(p + 1)]->setConstraint("");
1115 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1116 Operands[*(p + 1)]->setConstraint("");
1120 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1121 Operands[*(p + 1)]->setConstraint("m");
1125 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1126 Operands[*(p + 1)]->setConstraint("");
1130 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1131 Operands[*(p + 1)]->setConstraint("");
1135 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1136 Operands[*(p + 1)]->setConstraint("");
1140 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1141 Operands[*(p + 1)]->setConstraint("");
1145 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1146 Operands[*(p + 1)]->setConstraint("");
1150 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1151 Operands[*(p + 1)]->setConstraint("");
1155 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1156 Operands[*(p + 1)]->setConstraint("");
1779 auto &SrcOp1 = Operands[OpndNum1];
1780 auto &SrcOp2 = Operands[OpndNum2];
2405 StringRef Mnemonic = ((RISCVOperand&)*Operands[0]).getToken();
2452 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
2461 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/Sparc/SparcGenAsmMatcher.inc 1578 static_cast<SparcOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
1590 static_cast<SparcOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
1593 static_cast<SparcOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
1650 static_cast<SparcOperand&>(*Operands[OpIdx]).addMEMriOperands(Inst, 2);
1653 static_cast<SparcOperand&>(*Operands[OpIdx]).addMEMrrOperands(Inst, 2);
1659 static_cast<SparcOperand&>(*Operands[OpIdx]).addMembarTagOperands(Inst, 1);
1675 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1676 Operands[*(p + 1)]->setConstraint("r");
1683 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1684 Operands[*(p + 1)]->setConstraint("r");
1688 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1689 Operands[*(p + 1)]->setConstraint("m");
1693 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1694 Operands[*(p + 1)]->setConstraint("");
1698 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1699 Operands[*(p + 1)]->setConstraint("");
1703 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1704 Operands[*(p + 1)]->setConstraint("");
1708 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1709 Operands[*(p + 1)]->setConstraint("");
1713 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1714 Operands[*(p + 1)]->setConstraint("");
1718 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1719 Operands[*(p + 1)]->setConstraint("");
1723 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1724 Operands[*(p + 1)]->setConstraint("");
1728 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1729 Operands[*(p + 1)]->setConstraint("");
1733 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1734 Operands[*(p + 1)]->setConstraint("");
1738 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1739 Operands[*(p + 1)]->setConstraint("");
1743 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1744 Operands[*(p + 1)]->setConstraint("");
1748 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1749 Operands[*(p + 1)]->setConstraint("");
1753 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1754 Operands[*(p + 1)]->setConstraint("");
1758 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1759 Operands[*(p + 1)]->setConstraint("");
1763 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1764 Operands[*(p + 1)]->setConstraint("m");
1768 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1769 Operands[*(p + 1)]->setConstraint("");
1773 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1774 Operands[*(p + 1)]->setConstraint("");
1778 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1779 Operands[*(p + 1)]->setConstraint("m");
1783 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1784 Operands[*(p + 1)]->setConstraint("m");
1788 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1789 Operands[*(p + 1)]->setConstraint("m");
1793 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1794 Operands[*(p + 1)]->setConstraint("m");
1798 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1799 Operands[*(p + 1)]->setConstraint("m");
2346 auto &SrcOp1 = Operands[OpndNum1];
2347 auto &SrcOp2 = Operands[OpndNum2];
4149 StringRef Mnemonic = ((SparcOperand&)*Operands[0]).getToken();
4196 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
4205 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/SystemZ/SystemZGenAsmMatcher.inc 1351 static_cast<SystemZOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
1363 static_cast<SystemZOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
1366 static_cast<SystemZOperand&>(*Operands[OpIdx]).addBDXAddrOperands(Inst, 3);
1369 static_cast<SystemZOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
1372 static_cast<SystemZOperand&>(*Operands[OpIdx]).addBDAddrOperands(Inst, 2);
1375 static_cast<SystemZOperand&>(*Operands[OpIdx]).addBDLAddrOperands(Inst, 3);
1378 static_cast<SystemZOperand&>(*Operands[OpIdx]).addImmTLSOperands(Inst, 2);
1381 static_cast<SystemZOperand&>(*Operands[OpIdx]).addBDRAddrOperands(Inst, 3);
1387 static_cast<SystemZOperand&>(*Operands[OpIdx]).addBDVAddrOperands(Inst, 3);
1403 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1404 Operands[*(p + 1)]->setConstraint("r");
1411 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1412 Operands[*(p + 1)]->setConstraint("m");
1416 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1417 Operands[*(p + 1)]->setConstraint("m");
1421 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1422 Operands[*(p + 1)]->setConstraint("m");
1426 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1427 Operands[*(p + 1)]->setConstraint("m");
1431 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1432 Operands[*(p + 1)]->setConstraint("m");
1436 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1437 Operands[*(p + 1)]->setConstraint("m");
1441 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1442 Operands[*(p + 1)]->setConstraint("m");
1446 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1447 Operands[*(p + 1)]->setConstraint("");
1451 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
1452 Operands[*(p + 1)]->setConstraint("m");
2340 auto &SrcOp1 = Operands[OpndNum1];
2341 auto &SrcOp2 = Operands[OpndNum2];
5347 StringRef Mnemonic = ((SystemZOperand&)*Operands[0]).getToken();
5391 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
5400 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/WebAssembly/WebAssemblyGenAsmMatcher.inc 168 static_cast<WebAssemblyOperand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
183 static_cast<WebAssemblyOperand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
186 static_cast<WebAssemblyOperand&>(*Operands[OpIdx]).addBrListOperands(Inst, 1);
189 static_cast<WebAssemblyOperand&>(*Operands[OpIdx]).addFPImmOperands(Inst, 1);
205 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
206 Operands[*(p + 1)]->setConstraint("r");
213 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
214 Operands[*(p + 1)]->setConstraint("");
218 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
219 Operands[*(p + 1)]->setConstraint("m");
223 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
224 Operands[*(p + 1)]->setConstraint("m");
228 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
229 Operands[*(p + 1)]->setConstraint("m");
397 auto &SrcOp1 = Operands[OpndNum1];
398 auto &SrcOp2 = Operands[OpndNum2];
1116 StringRef Mnemonic = ((WebAssemblyOperand&)*Operands[0]).getToken();
1160 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
1169 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
gen/lib/Target/X86/X86GenAsmMatcher.inc 4949 static_cast<X86Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
4964 static_cast<X86Operand&>(*Operands[OpIdx]).addImmOperands(Inst, 1);
4976 static_cast<X86Operand&>(*Operands[OpIdx]).addRegOperands(Inst, 1);
4979 static_cast<X86Operand&>(*Operands[OpIdx]).addMemOperands(Inst, 5);
4982 static_cast<X86Operand&>(*Operands[OpIdx]).addAbsMemOperands(Inst, 1);
5030 static_cast<X86Operand&>(*Operands[OpIdx]).addDstIdxOperands(Inst, 1);
5033 static_cast<X86Operand&>(*Operands[OpIdx]).addSrcIdxOperands(Inst, 2);
5036 static_cast<X86Operand&>(*Operands[OpIdx]).addGR32orGR64Operands(Inst, 1);
5045 static_cast<X86Operand&>(*Operands[OpIdx]).addMemOffsOperands(Inst, 2);
5054 static_cast<X86Operand&>(*Operands[OpIdx]).addAVX512RCOperands(Inst, 1);
5057 static_cast<X86Operand&>(*Operands[OpIdx]).addMaskPairOperands(Inst, 1);
5073 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5074 Operands[*(p + 1)]->setConstraint("r");
5081 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5082 Operands[*(p + 1)]->setConstraint("");
5086 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5087 Operands[*(p + 1)]->setConstraint("m");
5091 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5092 Operands[*(p + 1)]->setConstraint("m");
5096 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5097 Operands[*(p + 1)]->setConstraint("m");
5101 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5102 Operands[*(p + 1)]->setConstraint("m");
5106 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5107 Operands[*(p + 1)]->setConstraint("r");
5111 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5112 Operands[*(p + 1)]->setConstraint("m");
5116 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5117 Operands[*(p + 1)]->setConstraint("m");
5121 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5122 Operands[*(p + 1)]->setConstraint("");
5126 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5127 Operands[*(p + 1)]->setConstraint("");
5131 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5132 Operands[*(p + 1)]->setConstraint("");
5136 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5137 Operands[*(p + 1)]->setConstraint("");
5141 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5142 Operands[*(p + 1)]->setConstraint("");
5146 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5147 Operands[*(p + 1)]->setConstraint("");
5151 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5152 Operands[*(p + 1)]->setConstraint("");
5156 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5157 Operands[*(p + 1)]->setConstraint("");
5161 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5162 Operands[*(p + 1)]->setConstraint("");
5166 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5167 Operands[*(p + 1)]->setConstraint("");
5171 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5172 Operands[*(p + 1)]->setConstraint("");
5176 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5177 Operands[*(p + 1)]->setConstraint("");
5181 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5182 Operands[*(p + 1)]->setConstraint("");
5186 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5187 Operands[*(p + 1)]->setConstraint("");
5191 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5192 Operands[*(p + 1)]->setConstraint("");
5196 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5197 Operands[*(p + 1)]->setConstraint("m");
5201 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5202 Operands[*(p + 1)]->setConstraint("m");
5206 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5207 Operands[*(p + 1)]->setConstraint("m");
5211 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5212 Operands[*(p + 1)]->setConstraint("m");
5216 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5217 Operands[*(p + 1)]->setConstraint("m");
5221 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5222 Operands[*(p + 1)]->setConstraint("m");
5226 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5227 Operands[*(p + 1)]->setConstraint("");
5231 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5232 Operands[*(p + 1)]->setConstraint("");
5236 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5237 Operands[*(p + 1)]->setConstraint("m");
5241 Operands[*(p + 1)]->setMCOperandNum(NumMCOperands);
5242 Operands[*(p + 1)]->setConstraint("m");
7588 auto &SrcOp1 = Operands[OpndNum1];
7589 auto &SrcOp2 = Operands[OpndNum2];
36943 StringRef Mnemonic = ((X86Operand&)*Operands[0]).getToken();
36991 Operands[ActualIdx]->print(dbgs()); dbgs() << "): ");
37000 MCParsedAsmOperand &Actual = *Operands[ActualIdx];
include/llvm/ADT/IndexedMap.h 52 return storage_[toIndex_(n)];
include/llvm/ADT/IntEqClasses.h 77 return EC[a];
include/llvm/ADT/IntervalMap.h 795 return *reinterpret_cast<NodeT*>(path[Level].node);
797 unsigned size(unsigned Level) const { return path[Level].size; }
798 unsigned offset(unsigned Level) const { return path[Level].offset; }
822 return path[Level].subtree(path[Level].offset);
822 return path[Level].subtree(path[Level].offset);
899 if (path[i].offset != 0)
908 return path[Level].offset == path[Level].size - 1;
908 return path[Level].offset == path[Level].size - 1;
include/llvm/ADT/MapVector.h 114 return Pos == Map.end()? ValueT() : Vector[Pos->second].second;
include/llvm/ADT/SetVector.h 136 return vector_[n];
include/llvm/ADT/SparseMultiSet.h 146 return Dense[D.Prev].isTail();
154 return &Dense[N.Prev] == &N;
244 unsigned Next() const { return SMS->Dense[Idx].Next; }
include/llvm/Analysis/BlockFrequencyInfoImpl.h 244 return Node == Nodes[0];
247 BlockNode getHeader() const { return Nodes[0]; }
include/llvm/Analysis/DominanceFrontier.h 64 return Roots[0];
include/llvm/Analysis/LoopAccessAnalysis.h 248 OrderMap[InstMap[I]] = I;
472 return Pointers[PtrIdx];
780 return LAI.getDepChecker().getMemoryInstructions()[Source];
785 return LAI.getDepChecker().getMemoryInstructions()[Destination];
include/llvm/Analysis/LoopCacheAnalysis.h 57 return Subscripts[SubNum];
include/llvm/Analysis/PHITransAddr.h 67 if (InstInputs[i]->getParent() == BB)
include/llvm/Bitstream/BitCodes.h 180 return OperandList[N];
include/llvm/Bitstream/BitstreamWriter.h 419 EmitVBR64(Vals[i], 6);
include/llvm/CodeGen/CallingConvLower.h 286 return UsedRegs[Reg/32] & (1 << (Reg&31));
477 const ByValInfo& info = ByValRegs[InRegsParamRecordIndex];
include/llvm/CodeGen/EdgeBundles.h 48 ArrayRef<unsigned> getBlocks(unsigned Bundle) const { return Blocks[Bundle]; }
include/llvm/CodeGen/LiveInterval.h 312 return valnos[ValNo];
include/llvm/CodeGen/LiveIntervals.h 356 std::pair<unsigned, unsigned> P = RegMaskBlocks[MBBNum];
367 std::pair<unsigned, unsigned> P = RegMaskBlocks[MBBNum];
411 return RegUnitRanges[Unit];
include/llvm/CodeGen/MachineFrameInfo.h 408 return LocalFrameObjects[i];
include/llvm/CodeGen/MachineRegisterInfo.h 795 RegAllocHints[VReg.id()].second[0] : 0);
include/llvm/CodeGen/MachineScheduler.h 720 return ExecutedResCounts[ResIdx];
include/llvm/CodeGen/RegisterClassInfo.h 115 return CalleeSavedAliases[PhysReg];
include/llvm/CodeGen/ScheduleDFS.h 152 return DFSTreeData[SubtreeID].SubInstrCount;
include/llvm/CodeGen/SlotIndexes.h 459 return MBBRanges[Num];
include/llvm/CodeGen/TargetSchedule.h 141 return ResourceFactors[ResIdx];
include/llvm/DebugInfo/DIContext.h 89 return Frames[Index];
include/llvm/DebugInfo/DWARF/DWARFAbbreviationDeclaration.h 102 return AttributeSpecs[idx].Form;
111 return AttributeSpecs[idx].Attr;
include/llvm/IR/CallSite.h 807 return (int)CS.getArgumentNo(U) == CI.ParameterEncoding[0];
830 return CI.ParameterEncoding[ArgNo + 1];
844 return CI.ParameterEncoding[ArgNo + 1] >= 0
845 ? CS.getArgOperand(CI.ParameterEncoding[ArgNo + 1])
853 assert(CI.ParameterEncoding.size() && CI.ParameterEncoding[0] > 0);
854 return CI.ParameterEncoding[0];
include/llvm/MC/MCInst.h 179 const MCOperand &getOperand(unsigned i) const { return Operands[i]; }
include/llvm/MC/MCParser/MCAsmLexer.h 101 return CurTok[0];
include/llvm/Option/Arg.h 114 return Values[N];
122 if (Values[i] == Value)
include/llvm/Support/CommandLine.h 782 StringRef getOption(unsigned N) const override { return Values[N].Name; }
784 return Values[N].HelpStr;
789 return Values[N].V;
include/llvm/Support/GenericDomTree.h 440 return this->Roots[0];
include/llvm/Support/GenericDomTreeConstruction.h 553 runDFS(DT.Roots[0], 0, DC, 0);
1375 const NodePtr RootBB = IsPostDom ? nullptr : DT.getRoots()[0];
lib/Analysis/BasicAliasAnalysis.cpp 1948 const Value *V = Src[i].V;
1949 unsigned ZExtBits = Src[i].ZExtBits, SExtBits = Src[i].SExtBits;
1949 unsigned ZExtBits = Src[i].ZExtBits, SExtBits = Src[i].SExtBits;
1950 APInt Scale = Src[i].Scale;
1988 const VariableGEPIndex &Var0 = VarIndices[0], &Var1 = VarIndices[1];
1988 const VariableGEPIndex &Var0 = VarIndices[0], &Var1 = VarIndices[1];
lib/Analysis/LoopAccessAnalysis.cpp 239 const RuntimePointerChecking::CheckingPtrGroup &CGI = CheckingGroups[I];
240 const RuntimePointerChecking::CheckingPtrGroup &CGJ = CheckingGroups[J];
260 if (needsChecking(M.Members[I], N.Members[J]))
260 if (needsChecking(M.Members[I], N.Members[J]))
429 return (PtrToPartition[PtrIdx1] != -1 &&
430 PtrToPartition[PtrIdx1] == PtrToPartition[PtrIdx2]);
430 PtrToPartition[PtrIdx1] == PtrToPartition[PtrIdx2]);
434 const PointerInfo &PointerI = Pointers[I];
435 const PointerInfo &PointerJ = Pointers[J];
463 OS.indent(Depth + 2) << *Pointers[First[K]].PointerValue << "\n";
463 OS.indent(Depth + 2) << *Pointers[First[K]].PointerValue << "\n";
467 OS.indent(Depth + 2) << *Pointers[Second[K]].PointerValue << "\n";
467 OS.indent(Depth + 2) << *Pointers[Second[K]].PointerValue << "\n";
478 const auto &CG = CheckingGroups[I];
484 OS.indent(Depth + 6) << "Member: " << *Pointers[CG.Members[J]].Expr
484 OS.indent(Depth + 6) << "Member: " << *Pointers[CG.Members[J]].Expr
1719 [&](unsigned Idx) { return this->InstMap[Idx]; });
1731 OS.indent(Depth + 2) << *Instrs[Source] << " -> \n";
1732 OS.indent(Depth + 2) << *Instrs[Destination] << "\n";
2148 Value *Ptr = PtrRtChecking.Pointers[CG->Members[0]].PointerValue;
2148 Value *Ptr = PtrRtChecking.Pointers[CG->Members[0]].PointerValue;
lib/Analysis/PHITransAddr.cpp 52 dbgs() << " Input #" << i << " is " << *InstInputs[i] << "\n";
102 errs() << " InstInput #" << i << " is " << *InstInputs[i] << "\n";
lib/Analysis/StackSafetyAnalysis.cpp 456 return FS.Params[ParamNo].Use.Range;
lib/Bitcode/Reader/MetadataLoader.cpp 154 return MetadataPtrs[i];
159 return MetadataPtrs[I];
2024 Instruction *Inst = InstructionList[Record[0]];
lib/Bitcode/Writer/BitcodeWriter.cpp 4206 Hasher.update(ArrayRef<uint8_t>((const uint8_t *)&(Buffer)[BlockStartPos],
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 1276 auto &EndingEntry = Entries[Entry.getEndIndex()];
lib/CodeGen/AsmPrinter/DIE.cpp 63 Data[i].Profile(ID);
77 const DIEAbbrevData &AttrData = Data[i];
120 << dwarf::AttributeString(Data[i].getAttribute())
122 << dwarf::FormEncodingString(Data[i].getForm());
124 if (Data[i].getForm() == dwarf::DW_FORM_implicit_const)
125 O << " " << Data[i].getValue();
lib/CodeGen/AsmPrinter/DebugLocStream.h 61 const List &getList(size_t LI) const { return Lists[LI]; }
113 .slice(Lists[LI].EntryOffset, getNumEntries(LI));
119 .slice(Entries[EI].ByteOffset, getNumBytes(EI));
124 .slice(Entries[EI].CommentOffset, getNumComments(EI));
140 return Entries.size() - Lists[LI].EntryOffset;
141 return Lists[LI + 1].EntryOffset - Lists[LI].EntryOffset;
141 return Lists[LI + 1].EntryOffset - Lists[LI].EntryOffset;
145 return DWARFBytes.size() - Entries[EI].ByteOffset;
146 return Entries[EI + 1].ByteOffset - Entries[EI].ByteOffset;
146 return Entries[EI + 1].ByteOffset - Entries[EI].ByteOffset;
150 return Comments.size() - Entries[EI].CommentOffset;
151 return Entries[EI + 1].CommentOffset - Entries[EI].CommentOffset;
151 return Entries[EI + 1].CommentOffset - Entries[EI].CommentOffset;
lib/CodeGen/AsmPrinter/DwarfDebug.cpp 1546 HistSize == 2 && HistoryMapEntries[1].isClobber();
1549 SingleValueWithClobber ? HistoryMapEntries[1].getInstr() : nullptr;
lib/CodeGen/AsmPrinter/EHStreamer.cpp 207 const LandingPadInfo *LandingPad = LandingPads[i];
209 MCSymbol *BeginLabel = LandingPad->BeginLabels[j];
263 const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
264 assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
277 LastLabel = LandingPad->EndLabels[P.RangeIndex];
289 FirstActions[P.PadIndex]
lib/CodeGen/AsmPrinter/WasmException.cpp 83 const LandingPadInfo *Info = LandingPads[I];
91 CallSiteEntry Site = {nullptr, nullptr, Info, FirstActions[I]};
lib/CodeGen/AsmPrinter/WinException.cpp 628 const SEHUnwindMapEntry &UME = FuncInfo.SEHUnwindMap[State];
779 const WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I];
821 const WinEHTryBlockMapEntry &TBME = FuncInfo.TryBlockMap[I];
1062 State = FuncInfo.ClrEHUnwindMap[State].TryParentState;
1072 Right = FuncInfo.ClrEHUnwindMap[Right].TryParentState;
1077 Left = FuncInfo.ClrEHUnwindMap[Left].TryParentState;
1082 Left = FuncInfo.ClrEHUnwindMap[Left].TryParentState;
1083 Right = FuncInfo.ClrEHUnwindMap[Right].TryParentState;
1114 FuncInfo.ClrEHUnwindMap[State].Handler.get<MachineBasicBlock *>();
1119 assert(FuncInfo.ClrEHUnwindMap[State].HandlerParentState < State &&
1190 CurrentState = FuncInfo.ClrEHUnwindMap[CurrentState].TryParentState;
1204 FuncInfo.ClrEHUnwindMap[EnteredState].TryParentState) {
1274 const ClrEHUnwindMapEntry &Entry = FuncInfo.ClrEHUnwindMap[Clause.State];
lib/CodeGen/BranchRelaxation.cpp 184 unsigned Offset = BlockInfo[MBB->getNumber()].Offset;
283 int64_t DestOffset = BlockInfo[DestBB.getNumber()].Offset;
lib/CodeGen/CallingConvLower.cpp 91 MVT ArgVT = Ins[i].VT;
92 ISD::ArgFlagsTy ArgFlags = Ins[i].Flags;
104 MVT VT = Outs[i].VT;
105 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
118 MVT VT = Outs[i].VT;
119 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
131 MVT ArgVT = Outs[i].VT;
132 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
166 MVT VT = Ins[i].VT;
167 ISD::ArgFlagsTy Flags = Ins[i].Flags;
lib/CodeGen/CodeGenPrepare.cpp 3098 return AddrModes[0];
lib/CodeGen/DFAPacketizer.cpp 141 return RS[0];
144 return RS[InstIdx] ^ RS[InstIdx - 1];
144 return RS[InstIdx] ^ RS[InstIdx - 1];
lib/CodeGen/GlobalISel/LegalizerInfo.cpp 637 const SizeAndActionsVec &Vec = Actions[Aspect.Idx];
659 ScalarInVectorActions[OpcodeIdx][TypeIdx];
674 const SizeAndActionsVec &NumElementsVec = (*i).second[TypeIdx];
lib/CodeGen/GlobalISel/RegisterBankInfo.cpp 731 int StartIdx = OpToNewVRegIdx[OpIdx];
741 make_range(&NewVRegs[StartIdx], End);
765 if (OpToNewVRegIdx[Idx] != DontKnowIdx) {
768 OS << '(' << Idx << ", " << OpToNewVRegIdx[Idx] << ')';
785 if (OpToNewVRegIdx[Idx] == DontKnowIdx)
lib/CodeGen/GlobalMerge.cpp 462 Type *Ty = Globals[j]->getValueType();
465 Align Alignment(DL.getPreferredAlignment(Globals[j]));
478 Inits.push_back(Globals[j]->getInitializer());
483 if (Globals[j]->hasExternalLinkage() && !HasExternal) {
485 FirstExternalName = Globals[j]->getName();
520 MergedGV->setSection(Globals[i]->getSection());
524 GlobalValue::LinkageTypes Linkage = Globals[k]->getLinkage();
525 std::string Name = Globals[k]->getName();
527 Globals[k]->getDLLStorageClass();
531 MergedGV->copyMetadata(Globals[k],
540 Globals[k]->replaceAllUsesWith(GEP);
541 Globals[k]->eraseFromParent();
lib/CodeGen/LexicalScopes.cpp 335 if (Children[i] != this)
336 Children[i]->dump(Indent + 2);
lib/CodeGen/LiveDebugVariables.cpp 810 SlotIndex Idx = Kills[i];
lib/CodeGen/LiveInterval.cpp 1067 assert(I->valno == valnos[I->valno->id]);
1146 OS << ' ' << Spills[I];
lib/CodeGen/LiveIntervals.cpp 159 if (LiveRange *LR = RegUnitRanges[Unit])
lib/CodeGen/MachineLICM.cpp 1164 if (static_cast<int>(RP[Class]) + RPIdAndCost.second >= Limit)
lib/CodeGen/MachinePipeliner.cpp 2963 ProcResourceCount[I->ProcResourceIdx], NumUnits,
2966 if (ProcResourceCount[I->ProcResourceIdx] >= NumUnits)
lib/CodeGen/MachineTraceMetrics.cpp 145 assert(BlockInfo[MBBNum].hasResources() &&
243 const TraceBlockInfo *TBI = &BlockInfo[MBB->getNumber()];
252 const TraceBlockInfo *TBI = &BlockInfo[MBB->getNumber()];
590 const TraceBlockInfo &TBI = BlockInfo[Num];
594 assert(BlockInfo[TBI.Pred->getNumber()].hasValidDepth() &&
602 assert(BlockInfo[TBI.Succ->getNumber()].hasValidHeight() &&
1292 BlockInfo[i].print(OS);
lib/CodeGen/PeepholeOptimizer.cpp 319 return RegSrcs[Idx];
324 return RegSrcs[Idx].Reg;
329 return RegSrcs[Idx].SubReg;
760 const TargetRegisterClass *NewRC = MRI.getRegClass(SrcRegs[0].Reg);
763 assert(SrcRegs[0].SubReg == 0 && "should not have subreg operand");
lib/CodeGen/RegAllocBasic.cpp 215 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
lib/CodeGen/RegAllocGreedy.cpp 901 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
980 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
2545 LiveInterval *Intf = Q.interferingVRegs()[i - 1];
lib/CodeGen/RegisterClassInfo.cpp 118 if (CalleeSavedAliases[PhysReg] &&
lib/CodeGen/RenameIndependentSubregs.cpp 214 unsigned Reg = Intervals[0]->reg;
244 unsigned VReg = Intervals[ID]->reg;
284 SubRanges[ID-1] = Intervals[ID]->createSubRange(Allocator, SR.LaneMask);
305 LiveInterval &LI = *Intervals[I];
318 const VNInfo &VNI = *SR.valnos[I];
lib/CodeGen/ScheduleDAG.cpp 623 const SUnit *Succ = SU->Succs[I].getSUnit();
657 const SUnit *Pred = SU->Preds[I].getSUnit();
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 6430 int64_t CurrentByteOffset = ByteOffsets[i] - FirstOffset;
lib/CodeGen/SelectionDAG/ScheduleDAGRRList.cpp 1961 auto &Pred = TempSU->Preds[P];
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 814 EVT ValueVT = ValueVTs[Value];
815 unsigned NumRegs = RegCount[Value];
818 CallConv.getValue(), RegVTs[Value])
819 : RegVTs[Value];
825 P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT);
827 P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT, *Flag);
836 if (!Register::isVirtualRegister(Regs[Part + i]) ||
841 FuncInfo.GetLiveOutRegInfo(Regs[Part+i]);
897 unsigned NumParts = RegCount[Value];
901 CallConv.getValue(), RegVTs[Value])
902 : RegVTs[Value];
917 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
919 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
974 Ops.push_back(DAG.getRegister(Regs[I], RegVTs[I]));
974 Ops.push_back(DAG.getRegister(Regs[I], RegVTs[I]));
976 (Regs[I] != SP ||
984 unsigned NumRegs = TLI.getNumRegisters(*DAG.getContext(), ValueVTs[Value]);
985 MVT RegisterVT = RegVTs[Value];
988 unsigned TheReg = Regs[Reg++];
1003 OutVec.push_back(std::make_pair(Regs[I], RegisterSize));
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 2468 return N == RecordedNodes[RecNo].first;
lib/CodeGen/SelectionDAG/TargetLowering.cpp 79 const CCValAssign &ArgLoc = ArgLocs[I];
89 SDValue Value = OutVals[I];
lib/CodeGen/SlotIndexes.cpp 251 dbgs() << "%bb." << i << "\t[" << MBBRanges[i].first << ';'
252 << MBBRanges[i].second << ")\n";
lib/CodeGen/SpillPlacement.h 153 return BlockFrequencies[Number];
lib/CodeGen/StackColoring.cpp 561 Intervals[I]->dump();
lib/CodeGen/StackSlotColoring.cpp 258 const SmallVectorImpl<LiveInterval *> &OtherLIs = Assignments[Color];
260 LiveInterval *OtherLI = OtherLIs[i];
lib/CodeGen/SwitchLoweringUtils.cpp 37 assert(TotalCases[Last] >= TotalCases[First]);
37 assert(TotalCases[Last] >= TotalCases[First]);
39 TotalCases[Last] - (First == 0 ? 0 : TotalCases[First - 1]);
39 TotalCases[Last] - (First == 0 ? 0 : TotalCases[First - 1]);
lib/DebugInfo/DWARF/DWARFAbbreviationDeclaration.cpp 144 if (AttributeSpecs[i].Attr == Attr)
lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp 190 StringRef Str = dwarf::AtomValueString(HdrData.Atoms[i].first, *Val);
lib/DebugInfo/DWARF/DWARFDebugFrame.cpp 283 printOperand(OS, MRI, IsEH, Instr, i, Instr.Ops[i]);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp 1062 const RelocationEntry &RE = Relocs[i];
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp 977 return (void *)(Sections[SectionID].getObjAddress() + Offset);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldImpl.h 480 return Sections[SectionID].getLoadAddress();
484 return Sections[SectionID].getAddress();
488 return StringRef(reinterpret_cast<char *>(Sections[SectionID].getAddress()),
489 Sections[SectionID].getStubOffset() + getMaxStubSize());
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldMachO.cpp 48 uint8_t *Src = Sections[RE.SectionID].getAddress() + RE.Offset;
150 const SectionEntry &Section = Sections[RE.SectionID];
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOAArch64.h 35 const SectionEntry &Section = Sections[RE.SectionID];
lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldMachOARM.h 64 const SectionEntry &Section = Sections[RE.SectionID];
lib/ExecutionEngine/TargetSelect.cpp 82 Features.AddFeature(MAttrs[i]);
lib/IR/AsmWriter.cpp 4093 MDs[0].second->getContext().getMDKindNames(MDNames);
lib/IR/LegacyPassManager.cpp 862 ImmutablePasses[i]->dumpPassStructure(0);
1310 const PassInfo *PInf = TPM->findAnalysisPassInfo(Set[i]);
lib/MC/MCAssembler.cpp 686 if (DF.getContents()[i]) {
lib/MC/MCCodeView.cpp 42 return Files[Idx].Assigned;
lib/MC/MCContext.cpp 667 return !LineTable.getMCDwarfFiles()[FileNumber].Name.empty();
lib/MC/MCDwarf.cpp 342 assert(!MCDwarfFiles[i].Name.empty());
343 MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName and...
345 MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); // Directory number.
441 emitOneV5FileEntry(MCOS, RootFile.Name.empty() ? MCDwarfFiles[1] : RootFile,
444 emitOneV5FileEntry(MCOS, MCDwarfFiles[i], HasAllMD5, HasSource, LineStr);
1016 MCOS->EmitBytes(MCDwarfDirs[0]);
1026 : MCDwarfFiles[1];
lib/MC/MCFragment.cpp 358 OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
358 OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
382 OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
382 OS << hexdigit((Contents[i] >> 4) & 0xF) << hexdigit(Contents[i] & 0xF);
lib/MC/MachObjectWriter.cpp 127 const MCSection &NextSec = *Layout.getSectionOrder()[Next];
lib/MCA/HardwareUnits/RegisterFile.cpp 445 const RegisterMappingTracker &RMT = RegisterFiles[I];
492 const RegisterMappingTracker &RMT = RegisterFiles[I];
lib/MCA/HardwareUnits/ResourceManager.cpp 167 return ResIndex2ProcResID[getResourceStateIndex(Mask)];
lib/Object/MachOObjectFile.cpp 2441 getStructOrErr<MachO::dylib_command>(*this, Libraries[i]);
2447 const char *P = (const char *)(Libraries[i]) + D.dylib.name;
2808 if (Stack[i].Start != Other.Stack[i].Start)
2808 if (Stack[i].Start != Other.Stack[i].Start)
4157 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4165 reinterpret_cast<const section_base *>(Sections[Sec.d.a]);
4250 return getStruct<MachO::section>(*this, Sections[DRI.d.a]);
4255 return getStruct<MachO::section_64>(*this, Sections[DRI.d.a]);
4319 return getStruct<MachO::build_tool_version>(*this, BuildTools[index]);
lib/Option/Arg.cpp 58 O << "'" << Values[i] << "'";
lib/Support/IntEqClasses.cpp 54 while (a != EC[a])
55 a = EC[a];
lib/Support/IntervalMap.cpp 31 while (l && path[l].offset == 0)
35 if (path[l].offset == 0)
39 NodeRef NR = path[l].subtree(path[l].offset - 1);
39 NodeRef NR = path[l].subtree(path[l].offset - 1);
89 NodeRef NR = path[l].subtree(path[l].offset + 1);
89 NodeRef NR = path[l].subtree(path[l].offset + 1);
lib/Target/AArch64/AArch64CallLowering.cpp 235 SplitArgs.emplace_back(OrigArg.Regs[0], SplitVTs[0].getTypeForEVT(Ctx),
236 OrigArg.Flags[0], OrigArg.IsFixed);
247 SplitArgs.emplace_back(OrigArg.Regs[i], SplitTy, OrigArg.Flags[0],
247 SplitArgs.emplace_back(OrigArg.Regs[i], SplitTy, OrigArg.Flags[0],
lib/Target/AArch64/AArch64ConditionalCompares.cpp 726 if (HeadCond[0].getImm() == -1) {
727 switch (HeadCond[1].getImm()) {
lib/Target/AArch64/AArch64ISelLowering.cpp 3158 MVT ValVT = Ins[i].VT;
3159 if (Ins[i].isOrigArg()) {
3160 std::advance(CurOrigArg, Ins[i].getOrigArgIndex() - CurArgIdx);
3161 CurArgIdx = Ins[i].getOrigArgIndex();
3175 AssignFn(i, ValVT, ValVT, CCValAssign::Full, Ins[i].Flags, CCInfo);
3184 if (Ins[i].Flags.isByVal()) {
3188 int Size = Ins[i].Flags.getByValSize();
3263 !Ins[i].Flags.isInConsecutiveRegs())
3303 if (Subtarget->isTargetILP32() && Ins[i].Flags.isPointer())
3350 if (Ins[I].Flags.isInReg()) {
4184 SDValue Arg = OutVals[realRVLocIdx];
4190 if (Outs[i].ArgVT == MVT::i1) {
lib/Target/AArch64/AArch64StackTagging.cpp 633 IntrinsicInst *Start = Info.LifetimeStart[0];
634 IntrinsicInst *End = Info.LifetimeEnd[0];
lib/Target/AMDGPU/AMDGPUCallLowering.cpp 178 SplitArgs.emplace_back(OrigArg.Regs[SplitIdx], Ty,
lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp 1890 unsigned PtrReg = GEPInfo.SgprParts[0];
1907 unsigned PtrReg = GEPInfo.SgprParts[0];
1939 unsigned PtrReg = GEPInfo.SgprParts[0];
lib/Target/AMDGPU/AMDGPULibFunc.cpp 784 const AMDGPULibFunc::Param& T = Str[I];
lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp 3255 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
4647 ((AMDGPUOperand &)*Operands[Idx]).addImmOperands(Inst, 1);
4733 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
4757 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
4796 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
5805 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
5870 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[i]);
5915 ((AMDGPUOperand &)*Operands[I++]).addRegOperands(Inst, 1);
5921 ((AMDGPUOperand &)*Operands[I - 1]).addRegOperands(Inst, 1);
5927 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[I]);
6202 ((AMDGPUOperand &)*Operands[I++]).addRegOperands(Inst, 1);
6206 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[I]);
6240 ((AMDGPUOperand &)*Operands[I++]).addRegOperands(Inst, 1);
6246 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[I]);
6260 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[I]);
6684 ((AMDGPUOperand &)*Operands[I++]).addRegOperands(Inst, 1);
6696 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[I]);
6843 ((AMDGPUOperand &)*Operands[I++]).addRegOperands(Inst, 1);
6847 AMDGPUOperand &Op = ((AMDGPUOperand &)*Operands[I]);
lib/Target/AMDGPU/GCNSchedStrategy.cpp 436 RPTracker.advance(begin(), end(), &LiveIns[RegionIdx]);
lib/Target/AMDGPU/R600EmitClauseMarkers.cpp 143 if (Consts[i].first->getReg() != R600::ALU_CONST)
145 unsigned Sel = Consts[i].second;
174 if (Consts[i].first->getReg() != R600::ALU_CONST)
178 Consts[i].first->setReg(
182 Consts[i].first->setReg(
lib/Target/AMDGPU/R600ISelLowering.cpp 1596 const ISD::InputArg &In = Ins[i];
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp 149 MD.ArgVector[i].push_back(V[i]);
lib/Target/AMDGPU/SIISelLowering.cpp 2122 const ISD::InputArg &Arg = Ins[i];
2132 VT = Ins[i].VT;
2139 DAG, VT, MemVT, DL, Chain, Offset, Align, Ins[i].Flags.isSExt(), &Ins[i]);
2139 DAG, VT, MemVT, DL, Chain, Offset, Align, Ins[i].Flags.isSExt(), &Ins[i]);
2143 dyn_cast<PointerType>(FType->getParamType(Ins[i].getOrigArgIndex()));
2313 SDValue Arg = OutVals[RealRVLocIdx];
lib/Target/AMDGPU/SIMachineFunctionInfo.h 507 : I->second.Lanes[Lane];
lib/Target/ARC/ARCISelLowering.cpp 377 const CCValAssign &VA = RVLocs[i];
514 const ArgDataPair ADP = {ArgIn, Ins[i].Flags};
649 Chain, dl, OutVals[i], FIN,
664 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), OutVals[i], Flag);
lib/Target/ARM/ARMBasicBlockInfo.cpp 81 unsigned Offset = BBInfo[MBB->getNumber()].Offset;
98 unsigned DestOffset = BBInfo[DestBB->getNumber()].Offset;
lib/Target/ARM/ARMBasicBlockInfo.h 135 return BBInfo[MBB->getNumber()].Offset;
lib/Target/ARM/ARMCallLowering.cpp 160 MIRBuilder.buildUnmerge(NewRegs, Arg.Regs[0]);
205 auto Flags = OrigArg.Flags[0];
207 SplitArgs.emplace_back(OrigArg.Regs[0], SplitVTs[0].getTypeForEVT(Ctx),
216 auto Flags = OrigArg.Flags[0];
230 Register PartReg = OrigArg.Regs[i];
392 MIRBuilder.buildMerge(Arg.Regs[0], NewRegs);
lib/Target/ARM/ARMISelLowering.cpp 2641 SDValue Arg = OutVals[realArgIdx];
2642 ISD::ArgFlagsTy Flags = Outs[realArgIdx].Flags;
2751 SDValue Arg = OutVals[realRVLocIdx];
3988 ISD::ArgFlagsTy Flags = Ins[Index].Flags;
4014 if (Ins[VA.getValNo()].isOrigArg()) {
4016 Ins[VA.getValNo()].getOrigArgIndex() - CurArgIdx);
4017 CurArgIdx = Ins[VA.getValNo()].getOrigArgIndex();
4074 if (VA.getLocReg() == ARM::R0 && Ins[VA.getValNo()].Flags.isReturned()) {
4112 ISD::ArgFlagsTy Flags = Ins[index].Flags;
4119 assert(Ins[index].isOrigArg() &&
lib/Target/ARM/ARMLoadStoreOptimizer.cpp 892 MachineInstr *LatestMI = Cand.Instrs[Cand.LatestMIIdx];
914 iterator EarliestI(Cand.Instrs[Cand.EarliestMIIdx]);
996 const MachineInstr *FirstMI = MemOps[0].MI;
1005 const MachineInstr *MI = MemOps[SIndex].MI;
1006 int Offset = MemOps[SIndex].Offset;
1051 int NewOffset = MemOps[I].Offset;
1054 const MachineOperand &MO = getLoadStoreRegOp(*MemOps[I].MI);
1084 unsigned Position = MemOps[I].Position;
1085 if (Position < MemOps[Latest].Position)
1087 else if (Position > MemOps[Earliest].Position)
1097 Candidate->Instrs.push_back(MemOps[C].MI);
1100 Candidate->InsertPos = MemOps[Latest].Position;
lib/Target/ARM/AsmParser/ARMAsmParser.cpp 5553 ((ARMOperand &)*Operands[3]).addRegOperands(Inst, 1);
5554 ((ARMOperand &)*Operands[1]).addCCOutOperands(Inst, 1);
5559 ((ARMOperand &)*Operands[4]).getReg() ==
5560 ((ARMOperand &)*Operands[3]).getReg())
5562 ((ARMOperand &)*Operands[RegOp]).addRegOperands(Inst, 1);
5564 ((ARMOperand &)*Operands[2]).addCondCodeOperands(Inst, 2);
5591 unsigned Cond = static_cast<ARMOperand &>(*Operands[CondOp]).getCondCode();
5608 ARMOperand &op = static_cast<ARMOperand &>(*Operands[ImmOp]);
5615 ARMOperand &op = static_cast<ARMOperand &>(*Operands[ImmOp]);
5621 ((ARMOperand &)*Operands[ImmOp]).addImmOperands(Inst, 1);
5622 ((ARMOperand &)*Operands[CondOp]).addCondCodeOperands(Inst, 2);
5631 ((ARMOperand &)*Operands[2]).addRegOperands(Inst, 1); // Rt
5632 ((ARMOperand &)*Operands[3]).addRegOperands(Inst, 1); // Rt2
5633 ((ARMOperand &)*Operands[4]).addRegOperands(Inst, 1); // Qd
5634 ((ARMOperand &)*Operands[5]).addMVEPairVectorIndexOperands(Inst, 1); // idx
5636 ((ARMOperand &)*Operands[7]).addMVEPairVectorIndexOperands(Inst, 1); // idx2
5637 ((ARMOperand &)*Operands[1]).addCondCodeOperands(Inst, 2); // condition code
7188 const ARMOperand &Op = static_cast<const ARMOperand &>(*Operands[ListNo]);
7196 return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
7199 return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
7207 const ARMOperand &Op = static_cast<const ARMOperand &>(*Operands[ListNo]);
7214 return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
7217 return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
7220 return Error(Operands[ListNo + HasWritebackToken]->getStartLoc(),
7235 return Error(Operands[3]->getStartLoc(),
7240 return Error(Operands[3]->getStartLoc(),
7246 return Error(Operands[3]->getStartLoc(),
7249 return Error(Operands[3]->getStartLoc(),
7259 return Error(Operands[3]->getStartLoc(),
7268 return Error(Operands[3]->getStartLoc(),
7272 return Error(Operands[3]->getStartLoc(),
7299 SMLoc Loc = Operands[0]->getStartLoc();
7314 if (static_cast<ARMOperand &>(*Operands[I]).isCondCode())
7315 CondLoc = Operands[I]->getStartLoc();
7361 if (static_cast<ARMOperand &>(*Operands[I]).isVPTPred())
7362 PredLoc = Operands[I]->getStartLoc();
7416 return Error(Operands[2]->getStartLoc(),
7458 return Error(Operands[3]->getStartLoc(),
7491 return Error(Operands[3]->getStartLoc(),
7535 return Error(Operands[3]->getStartLoc(),
7551 return Error(Operands[5]->getStartLoc(),
7565 (static_cast<ARMOperand &>(*Operands[3]).isToken() &&
7566 static_cast<ARMOperand &>(*Operands[3]).getToken() == "!");
7569 return Error(Operands[3 + HasWritebackToken]->getStartLoc(),
7573 return Error(Operands[2]->getStartLoc(),
7578 return Error(Operands[3]->getStartLoc(),
7630 return Error(Operands[4]->getStartLoc(),
7638 return Error(Operands[2]->getStartLoc(),
7649 if (Operands.size() == 6 && (((ARMOperand &)*Operands[3]).getReg() !=
7650 ((ARMOperand &)*Operands[5]).getReg()) &&
7651 (((ARMOperand &)*Operands[3]).getReg() !=
7652 ((ARMOperand &)*Operands[4]).getReg())) {
7653 return Error(Operands[3]->getStartLoc(),
7665 return Error(Operands[2]->getStartLoc(),
7675 return Error(Operands[2]->getStartLoc(),
7686 return Error(Operands[4]->getStartLoc(),
7692 return Error(Operands[4]->getStartLoc(),
7705 return Error(Operands[4]->getStartLoc(),
7720 return Error(Operands[4]->getStartLoc(),
7726 if (!(static_cast<ARMOperand &>(*Operands[2])).isSignedOffset<11, 1>())
7727 return Error(Operands[2]->getStartLoc(), "branch target out of range");
7730 int op = (Operands[2]->isImm()) ? 2 : 3;
7731 if (!static_cast<ARMOperand &>(*Operands[op]).isSignedOffset<24, 1>())
7732 return Error(Operands[op]->getStartLoc(), "branch target out of range");
7737 if (!static_cast<ARMOperand &>(*Operands[2]).isSignedOffset<8, 1>())
7738 return Error(Operands[2]->getStartLoc(), "branch target out of range");
7741 int Op = (Operands[2]->isImm()) ? 2 : 3;
7742 if (!static_cast<ARMOperand &>(*Operands[Op]).isSignedOffset<20, 1>())
7743 return Error(Operands[Op]->getStartLoc(), "branch target out of range");
7748 if (!static_cast<ARMOperand &>(*Operands[2]).isUnsignedOffset<6, 1>())
7749 return Error(Operands[2]->getStartLoc(), "branch target out of range");
7763 int i = (Operands[3]->isImm()) ? 3 : 4;
7764 ARMOperand &Op = static_cast<ARMOperand &>(*Operands[i]);
7784 return Error(Operands[1]->getStartLoc(), "instruction 'esb' is not "
7788 return Error(Operands[1]->getStartLoc(), "instruction 'csdb' is not "
7797 if (!static_cast<ARMOperand &>(*Operands[2]).isUnsignedOffset<4, 1>() ||
7799 return Error(Operands[2]->getStartLoc(),
7803 if (!static_cast<ARMOperand &>(*Operands[3]).isSignedOffset<16, 1>())
7804 return Error(Operands[3]->getStartLoc(),
7807 if (!static_cast<ARMOperand &>(*Operands[3]).isSignedOffset<18, 1>())
7808 return Error(Operands[3]->getStartLoc(),
7814 if (!static_cast<ARMOperand &>(*Operands[1]).isUnsignedOffset<4, 1>() ||
7816 return Error(Operands[1]->getStartLoc(),
7819 if (!static_cast<ARMOperand &>(*Operands[2]).isSignedOffset<16, 1>())
7820 return Error(Operands[2]->getStartLoc(),
7831 Operands[3]->getStartLoc(),
7841 return Error(Operands[2]->getStartLoc(),
7859 return Error(Operands[1]->getStartLoc(),
7863 return Error(Operands[1]->getStartLoc(),
7873 return Error(Operands[5]->getStartLoc(),
7882 return Error(Operands[3]->getStartLoc(),
7888 ARMOperand &Op = static_cast<ARMOperand&>(*Operands[3]);
7891 return Error(Operands[3]->getStartLoc(),
7902 if (Operands[3]->getReg() == Operands[4]->getReg()) {
7902 if (Operands[3]->getReg() == Operands[4]->getReg()) {
7903 return Error (Operands[3]->getStartLoc(),
7906 if (Operands[3]->getReg() == Operands[5]->getReg()) {
7906 if (Operands[3]->getReg() == Operands[5]->getReg()) {
7907 return Error (Operands[3]->getStartLoc(),
7913 if (Operands[4]->getReg() != Operands[6]->getReg())
7913 if (Operands[4]->getReg() != Operands[6]->getReg())
7914 return Error (Operands[4]->getStartLoc(), "Q-registers must be the same");
7915 if (static_cast<ARMOperand &>(*Operands[5]).getVectorIndex() !=
7916 static_cast<ARMOperand &>(*Operands[7]).getVectorIndex() + 2)
7917 return Error (Operands[5]->getStartLoc(), "Q-register indexes must be 2 and 0 or 3 and 1");
7921 if (Operands[2]->getReg() != Operands[4]->getReg())
7921 if (Operands[2]->getReg() != Operands[4]->getReg())
7922 return Error (Operands[2]->getStartLoc(), "Q-registers must be the same");
7923 if (static_cast<ARMOperand &>(*Operands[3]).getVectorIndex() !=
7924 static_cast<ARMOperand &>(*Operands[5]).getVectorIndex() + 2)
7925 return Error (Operands[3]->getStartLoc(), "Q-register indexes must be 2 and 0 or 3 and 1");
8358 static_cast<ARMOperand &>(*Operands[4]) :
8359 static_cast<ARMOperand &>(*Operands[3]));
9721 if (static_cast<ARMOperand &>(*Operands[0]).getToken() == "pop" &&
9739 if (static_cast<ARMOperand &>(*Operands[0]).getToken() == "push" &&
9755 if (static_cast<ARMOperand &>(*Operands[0]).getToken() != "add" ||
9764 if (static_cast<ARMOperand &>(*Operands[0]).getToken() != "sub" ||
9886 (static_cast<ARMOperand &>(*Operands[3]).isToken() &&
9887 static_cast<ARMOperand &>(*Operands[3]).getToken() == "!");
lib/Target/ARM/MCTargetDesc/ARMELFStreamer.cpp 165 InstPrinter.printRegName(OS, RegList[0]);
169 InstPrinter.printRegName(OS, RegList[i]);
1039 AttributeItem item = Contents[i];
1452 unsigned Reg = MRI->getEncodingValue(RegList[i]);
lib/Target/AVR/AVRISelLowering.cpp 905 while ((i != e) && (In[i].PartOffset == Offset)) {
906 Offset += In[i].VT.getStoreSize();
975 MVT LocVT = (IsCall) ? (*Outs)[pos].VT : (*Ins)[pos].VT;
975 MVT LocVT = (IsCall) ? (*Outs)[pos].VT : (*Ins)[pos].VT;
1404 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), OutVals[i], Flag);
lib/Target/AVR/AsmParser/AVRAsmParser.cpp 287 AVROperand const &Op = (AVROperand const &)*Operands[ErrorInfo];
lib/Target/BPF/BPFISelLowering.cpp 437 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), OutVals[i], Flag);
467 InVals.push_back(DAG.getConstant(0, DL, Ins[i].VT));
468 return DAG.getCopyFromReg(Chain, DL, 1, Ins[0].VT, InFlag).getValue(1);
lib/Target/Hexagon/AsmParser/HexagonAsmParser.cpp 1505 if (*Operands[4]->getStartLoc().getPointer() == '#') {
1506 StringStart = Operands[5]->getStartLoc().getPointer();
1507 StringEnd = Operands[6]->getStartLoc().getPointer();
1509 StringStart = Operands[4]->getStartLoc().getPointer();
1510 StringEnd = Operands[5]->getStartLoc().getPointer();
lib/Target/Hexagon/BitTracker.cpp 241 RC.Bits[i-B] = Bits[i];
247 RC.Bits[i] = Bits[i+B];
249 RC.Bits[i+(W-B)] = Bits[i];
288 Bits[i+W] = RC.Bits[i];
296 while (C < W && Bits[C] == V)
305 while (C < W && Bits[W-(C+1)] == V)
315 if (Bits[i] != RC[i])
lib/Target/Hexagon/BitTracker.h 308 return Bits[BitN];
lib/Target/Hexagon/HexagonISelDAGToDAGHVX.cpp 1836 if (C[LogPos] == LogLen-1)
1852 if (C[0] != Len-1)
1860 if (C[I] != Len-1-I)
1862 if (C[I] != I-(1-D)) // I-1, I
1902 unsigned First = (C[0] == LogLen-1) ? 1 : 0;
1905 SwapElems.push_back(C[0]);
lib/Target/Hexagon/HexagonISelLowering.cpp 217 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), OutVals[i], Flag);
720 ISD::ArgFlagsTy Flags = Ins[i].Flags;
lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp 181 if (Chain[i] != OtherChain[i])
228 OS << *(CD[i]) << " -->\n";
230 OS << *CD[ChainSize-1] << "\n";
lib/Target/Hexagon/MCTargetDesc/HexagonShuffler.cpp 183 if (!hvxInsts[startIdx].Units)
186 if ((hvxInsts[startIdx].Units & b) == 0)
188 unsigned allBits = makeAllBits(b, hvxInsts[startIdx].Lanes);
lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp 1113 else if (Operands[0]->isToken() && Operands[1]->isReg() &&
1113 else if (Operands[0]->isToken() && Operands[1]->isReg() &&
1114 Operands[2]->isImm() && Operands[3]->isImm() && Operands[4]->isReg())
1114 Operands[2]->isImm() && Operands[3]->isImm() && Operands[4]->isReg())
1114 Operands[2]->isImm() && Operands[3]->isImm() && Operands[4]->isReg())
1116 else if (Operands[0]->isToken() && Operands[1]->isToken() &&
1116 else if (Operands[0]->isToken() && Operands[1]->isToken() &&
1117 Operands[2]->isReg() && Operands[3]->isImm() &&
1117 Operands[2]->isReg() && Operands[3]->isImm() &&
1118 Operands[4]->isImm() && Operands[5]->isReg())
1118 Operands[4]->isImm() && Operands[5]->isReg())
1127 static_cast<LanaiOperand *>(Operands[PossibleAluOpIdx].get()))
1132 return Modifies && Operands[PossibleBaseIdx]->isReg() &&
1133 Operands[PossibleDestIdx]->isReg() &&
1134 Operands[PossibleBaseIdx]->getReg() ==
1135 Operands[PossibleDestIdx]->getReg();
1143 if (Operands.size() < 4 || !IsRegister(*Operands[1]) ||
1144 !IsRegister(*Operands[2]))
1147 static_cast<const LanaiOperand &>(*Operands[0]).getToken())
lib/Target/Lanai/LanaiISelLowering.cpp 557 Chain = DAG.getCopyToReg(Chain, DL, VA.getLocReg(), OutVals[i], Flag);
630 ISD::ArgFlagsTy Flags = Outs[I].Flags;
634 SDValue Arg = OutVals[I];
659 SDValue Arg = OutVals[I];
660 ISD::ArgFlagsTy Flags = Outs[I].Flags;
lib/Target/MSP430/MSP430ISelLowering.cpp 412 CurrentArgIndex = Args[0].OrigArgIndex;
483 MVT ArgVT = Args[ValNo].VT;
484 ISD::ArgFlagsTy ArgFlags = Args[ValNo].Flags;
662 ISD::ArgFlagsTy Flags = Ins[i].Flags;
692 if (Ins[i].Flags.isSRet()) {
750 OutVals[i], Flag);
814 SDValue Arg = OutVals[i];
846 ISD::ArgFlagsTy Flags = Outs[i].Flags;
lib/Target/Mips/AsmParser/MipsAsmParser.cpp 5423 if (static_cast<MipsOperand &>(*Operands[1])
5424 .isValidForTie(static_cast<MipsOperand &>(*Operands[2])))
5573 SMLoc ErrorLoc = Operands[ErrorInfo]->getStartLoc();
5796 ((MipsOperand &)*Operands[1]).addGPR32ZeroAsmRegOperands(Inst, 1);
5797 int NextReg = nextReg(((MipsOperand &)*Operands[1]).getGPR32Reg());
5799 ((MipsOperand &)*Operands[2]).addMemOperands(Inst, 2);
lib/Target/Mips/MipsCCState.cpp 123 ISD::OutputArg Out = Outs[i];
136 TargetLowering::ArgListEntry FuncArg = FuncArgs[Outs[i].OrigArgIndex];
141 CallOperandIsFixed.push_back(Outs[i].IsFixed);
156 if (Ins[i].Flags.isSRet()) {
163 assert(Ins[i].getOrigArgIndex() < MF.getFunction().arg_size());
164 std::advance(FuncArg, Ins[i].getOrigArgIndex());
lib/Target/Mips/MipsCCState.h 156 return OriginalArgWasFloatVector[ValNo];
159 return OriginalRetWasFloatVector[ValNo];
lib/Target/Mips/MipsCallLowering.cpp 78 if (!handleSplit(VRegs, ArgLocs, ArgLocsIndex, Args[ArgsIndex].Regs[0],
82 if (!assign(Args[ArgsIndex].Regs[0], ArgLocs[ArgLocsIndex], VT))
402 Arguments[i].VT, Arguments[i].ArgVT, Arguments[i].Flags);
402 Arguments[i].VT, Arguments[i].ArgVT, Arguments[i].Flags);
402 Arguments[i].VT, Arguments[i].ArgVT, Arguments[i].Flags);
688 ISD::ArgFlagsTy Flags = Arg.Flags[0];
715 ArgInfo Info = ArgInfo{OrigArg.Regs[i], SplitEVTs[i].getTypeForEVT(Ctx)};
lib/Target/Mips/MipsISelLowering.cpp 3363 unsigned ValSizeInBits = Ins[i].ArgVT.getSizeInBits();
3498 if (Ins[i].isOrigArg()) {
3499 std::advance(FuncArg, Ins[i].getOrigArgIndex() - CurArgIdx);
3500 CurArgIdx = Ins[i].getOrigArgIndex();
3503 ISD::ArgFlagsTy Flags = Ins[i].Flags;
3507 assert(Ins[i].isOrigArg() && "Byval arguments cannot be implicit");
3532 ArgValue = UnpackFromArgumentSlot(ArgValue, VA, Ins[i].ArgVT, DL, DAG);
3578 ArgValue = UnpackFromArgumentSlot(ArgValue, VA, Ins[i].ArgVT, DL, DAG);
3588 if (Ins[i].Flags.isSRet()) {
3670 SDValue Val = OutVals[i];
3704 unsigned ValSizeInBits = Outs[i].ArgVT.getSizeInBits();
lib/Target/NVPTX/NVPTXISelLowering.cpp 242 if (Offsets[Idx] & (AccessSize - 1))
245 EVT EltVT = ValueVTs[Idx];
267 if (ValueVTs[j] != EltVT)
271 if (Offsets[j] - Offsets[j - 1] != EltSize)
271 if (Offsets[j] - Offsets[j - 1] != EltSize)
1315 if (!Outs[OIdx].Flags.isByVal()) {
1334 assert((getValueType(DL, Ty) == Outs[OIdx].VT ||
1335 (getValueType(DL, Ty) == MVT::i8 && Outs[OIdx].VT == MVT::i16)) &&
1360 unsigned align = Outs[OIdx].Flags.getByValAlign();
2525 InVals.push_back(DAG.getNode(ISD::UNDEF, dl, Ins[InsIdx].VT));
2536 InVals.push_back(DAG.getNode(ISD::UNDEF, dl, Ins[InsIdx].VT));
2543 InVals.push_back(DAG.getNode(ISD::UNDEF, dl, Ins[InsIdx].VT));
2609 if (Ins[InsIdx].VT.isInteger() &&
2610 Ins[InsIdx].VT.getSizeInBits() > LoadVT.getSizeInBits()) {
2611 unsigned Extend = Ins[InsIdx].Flags.isSExt() ? ISD::SIGN_EXTEND
2613 Elt = DAG.getNode(Extend, dl, Ins[InsIdx].VT, Elt);
2636 assert(ObjectVT == Ins[InsIdx].VT &&
2697 SDValue RetVal = OutVals[i];
2699 RetVal = DAG.getNode(Outs[i].Flags.isSExt() ? ISD::SIGN_EXTEND
lib/Target/NVPTX/NVPTXMachineFunctionInfo.h 45 return ImageHandleList[Idx].c_str();
lib/Target/PowerPC/PPCFrameLowering.cpp 980 MIB.addReg(MustSaveCRs[i], CrState);
1005 MIB.addReg(MustSaveCRs[i], CrState);
1610 BuildMI(MBB, MBBI, dl, TII.get(PPC::MTOCRF8), MustSaveCRs[i])
1688 BuildMI(MBB, MBBI, dl, TII.get(PPC::MTOCRF8), MustSaveCRs[i])
lib/Target/PowerPC/PPCISelDAGToDAG.cpp 1234 Bits[i] = LHSBits[i < RotAmt ? i + (NumBits - RotAmt) : i - RotAmt];
1246 Bits[i] = LHSBits[i - ShiftAmt];
1261 Bits[i] = LHSBits[i + ShiftAmt];
1282 Bits[i] = (*LHSBits)[i];
1286 if ((*LHSBits)[i].isZero())
1287 Bits[i] = (*LHSBits)[i];
1303 if (LHSBits[i].isZero() && RHSBits[i].isZero()) {
1303 if (LHSBits[i].isZero() && RHSBits[i].isZero()) {
1310 if (LHSBits[i].hasValue() && LHSBits[i].getValue() == LastVal &&
1310 if (LHSBits[i].hasValue() && LHSBits[i].getValue() == LastVal &&
1311 LHSBits[i].getValueBitIndex() == LastIdx + 1)
1312 Bits[i] = LHSBits[i];
1313 else if (RHSBits[i].hasValue() && RHSBits[i].getValue() == LastVal &&
1313 else if (RHSBits[i].hasValue() && RHSBits[i].getValue() == LastVal &&
1314 RHSBits[i].getValueBitIndex() == LastIdx + 1)
1315 Bits[i] = RHSBits[i];
1319 else if (LHSBits[i].isZero())
1320 Bits[i] = RHSBits[i];
1321 else if (RHSBits[i].isZero())
1322 Bits[i] = LHSBits[i];
1355 Bits[i] = (*LHSBits)[i];
1400 Bits[i] = (*LHSBits)[i];
1404 Bits[i] = ValueBit((*LHSBits)[i].getValue(),
1405 (*LHSBits)[i].getValueBitIndex(),
lib/Target/PowerPC/PPCISelLowering.cpp 3738 if (Ins[i].Flags.isNest())
3741 if (CalculateStackSlotUsed(Ins[i].VT, Ins[i].ArgVT, Ins[i].Flags,
3741 if (CalculateStackSlotUsed(Ins[i].VT, Ins[i].ArgVT, Ins[i].Flags,
3741 if (CalculateStackSlotUsed(Ins[i].VT, Ins[i].ArgVT, Ins[i].Flags,
3761 EVT ObjectVT = Ins[ArgNo].VT;
3762 EVT OrigVT = Ins[ArgNo].ArgVT;
3765 ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
3766 if (Ins[ArgNo].isOrigArg()) {
3767 std::advance(FuncArg, Ins[ArgNo].getOrigArgIndex() - CurArgIdx);
3768 CurArgIdx = Ins[ArgNo].getOrigArgIndex();
3792 assert(Ins[ArgNo].isOrigArg() && "Byval arguments cannot be implicit");
4155 EVT ObjectVT = Ins[ArgNo].VT;
4156 ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
4205 EVT ObjectVT = Ins[ArgNo].VT;
4208 ISD::ArgFlagsTy Flags = Ins[ArgNo].Flags;
4209 if (Ins[ArgNo].isOrigArg()) {
4210 std::advance(FuncArg, Ins[ArgNo].getOrigArgIndex() - CurArgIdx);
4211 CurArgIdx = Ins[ArgNo].getOrigArgIndex();
4226 MinReservedArea += CalculateStackSlotSize(Ins[ArgNo].VT,
4233 assert(Ins[ArgNo].isOrigArg() && "Byval arguments cannot be implicit");
4727 ISD::ArgFlagsTy Flags = Ins[i].Flags;
4781 SDValue Arg = TailCallArgs[i].Arg;
4782 SDValue FIN = TailCallArgs[i].FrameIdxOp;
4783 int FI = TailCallArgs[i].FrameIdx;
5460 MVT ArgVT = Outs[i].VT;
5461 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
5464 if (Outs[i].IsFixed) {
5532 SDValue Arg = OutVals[RealArgIdx];
5533 ISD::ArgFlagsTy Flags = Outs[RealArgIdx].Flags;
5732 if (Outs[i].Flags.isNest()) continue;
5733 if (CalculateStackSlotUsed(Outs[i].VT, Outs[i].ArgVT, Outs[i].Flags,
5733 if (CalculateStackSlotUsed(Outs[i].VT, Outs[i].ArgVT, Outs[i].Flags,
5733 if (CalculateStackSlotUsed(Outs[i].VT, Outs[i].ArgVT, Outs[i].Flags,
5752 ISD::ArgFlagsTy Flags = Outs[i].Flags;
5753 EVT ArgVT = Outs[i].VT;
5754 EVT OrigVT = Outs[i].ArgVT;
5875 SDValue Arg = OutVals[i];
5876 ISD::ArgFlagsTy Flags = Outs[i].Flags;
5877 EVT ArgVT = Outs[i].VT;
5878 EVT OrigVT = Outs[i].ArgVT;
6101 Lo = DAG.getNode(ISD::BITCAST, dl, MVT::i32, OutVals[i - 1]);
6364 ISD::ArgFlagsTy Flags = Outs[i].Flags;
6365 EVT ArgVT = Outs[i].VT;
6458 SDValue Arg = OutVals[i];
6459 ISD::ArgFlagsTy Flags = Outs[i].Flags;
6659 SDValue Arg = OutVals[i];
6660 EVT ArgType = Outs[i].VT;
6837 SDValue Arg = OutVals[VA.getValNo()];
6908 SDValue Arg = OutVals[RealResIdx];
lib/Target/RISCV/RISCVISelLowering.cpp 1625 MVT ArgVT = Ins[i].VT;
1626 ISD::ArgFlagsTy ArgFlags = Ins[i].Flags;
1631 else if (Ins[i].isOrigArg())
1632 ArgTy = FType->getParamType(Ins[i].getOrigArgIndex());
1651 MVT ArgVT = Outs[i].VT;
1652 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
1653 Type *OrigTy = CLI ? CLI->getArgs()[Outs[i].OrigArgIndex].Ty : nullptr;
1657 ArgFlags, CCInfo, Outs[i].IsFixed, IsRet, OrigTy)) {
1927 unsigned ArgIndex = Ins[i].OrigArgIndex;
1928 assert(Ins[i].PartOffset == 0);
1929 while (i + 1 != e && Ins[i + 1].OrigArgIndex == ArgIndex) {
1931 unsigned PartOffset = Ins[i + 1].PartOffset;
2367 MVT VT = Outs[i].VT;
2368 ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
2401 SDValue Val = OutVals[i];
lib/Target/Sparc/SparcISelLowering.cpp 237 SDValue Arg = OutVals[realRVLocIdx];
319 SDValue OutVal = OutVals[i];
346 SDValue NV = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i64, OutVals[i+1]);
404 if (Ins[InIdx].Flags.isSRet()) {
lib/Target/SystemZ/SystemZCallingConv.h 53 ArgIsShortVector.push_back(IsShortVectorType(Ins[i].ArgVT));
63 ArgIsFixed.push_back(Outs[i].IsFixed);
67 ArgIsShortVector.push_back(IsShortVectorType(Outs[i].ArgVT));
lib/Target/SystemZ/SystemZHazardRecognizer.cpp 227 if (ProcResourceCounters[i] > 0) {
237 if (ProcResourceCounters[i] > 0)
239 << ":" << ProcResourceCounters[i] << " ";
lib/Target/SystemZ/SystemZISelLowering.cpp 1229 VerifyVectorType(Ins[i].VT, Ins[i].ArgVT);
1229 VerifyVectorType(Ins[i].VT, Ins[i].ArgVT);
1234 VerifyVectorType(Outs[i].VT, Outs[i].ArgVT);
1234 VerifyVectorType(Outs[i].VT, Outs[i].ArgVT);
1382 unsigned ArgIndex = Ins[I].OrigArgIndex;
1383 assert (Ins[I].PartOffset == 0);
1384 while (I + 1 != E && Ins[I + 1].OrigArgIndex == ArgIndex) {
1386 unsigned PartOffset = Ins[I + 1].PartOffset;
1684 SDValue RetValue = OutVals[I];
4084 int Elt = Bytes[I];
4122 int Elt = Bytes[From];
4185 if (Bytes[Start + I] >= 0) {
4186 unsigned Elem = Bytes[Start + I];
4210 int Index = Bytes[I];
4277 if (Bytes[I] >= 0)
4278 IndexNodes[I] = DAG.getConstant(Bytes[I], DL, MVT::i32);
lib/Target/X86/AsmParser/X86AsmParser.cpp 2964 return Warning(Ops[0]->getStartLoc(), "mask, index, and destination "
2996 return Warning(Ops[0]->getStartLoc(), "index and destination registers "
3025 return Warning(Ops[0]->getStartLoc(),
lib/Target/X86/X86CallFrameOptimization.cpp 508 MachineBasicBlock::iterator Store = *Context.ArgStoreVector[Idx];
lib/Target/X86/X86CallLowering.cpp 74 SplitArgs.emplace_back(OrigArg.Regs[0], VT.getTypeForEVT(Context),
411 if (OrigArg.Flags[0].isByVal())
419 MIRBuilder.buildUnmerge(Regs, OrigArg.Regs[0]);
lib/Target/X86/X86ISelLowering.cpp 2503 SDValue ValToCopy = OutVals[OutsIndex];
2850 ((Is64Bit || Ins[InsIndex].Flags.isInReg()) && !Subtarget.hasSSE1())) {
3016 ISD::ArgFlagsTy Flags = Ins[i].Flags;
3056 EVT ArgVT = Ins[i].ArgVT;
3058 if (Ins[i].PartOffset == 0) {
3086 DAG.getIntPtrConstant(Ins[i].PartOffset, dl));
3090 Ins[i].PartOffset));
3307 if (VA.getLocInfo() == CCValAssign::Indirect && !Ins[I].Flags.isByVal())
3324 if (Ins[I].Flags.isSRet()) {
4376 if (!Ins[i].Used) {
4430 SDValue Arg = OutVals[i];
4431 ISD::ArgFlagsTy Flags = Outs[i].Flags;
6834 int M = Mask[i];
lib/Target/X86/X86RegisterBankInfo.cpp 134 auto Mapping = getValueMapping(OpRegBankIdx[Idx], 1);
lib/Target/XCore/XCoreISelLowering.cpp 1067 const CCValAssign &VA = RVLocs[i];
1143 SDValue Arg = OutVals[i];
1338 const ArgDataPair ADP = { ArgIn, Ins[i].Flags };
1486 Chain, dl, OutVals[i], FIN,
1501 Chain = DAG.getCopyToReg(Chain, dl, VA.getLocReg(), OutVals[i], Flag);
lib/Testing/Support/Annotations.cpp 71 return I->getValue()[0];
83 return I->getValue()[0];
lib/Transforms/Coroutines/CoroFrame.cpp 62 BasicBlock *indexToBlock(unsigned Index) const { return V[Index]; }
91 BasicBlock *BB = Mapping.indexToBlock(&BD - &Block[0]);
108 assert(Block[UseIndex].Consumes[DefIndex] && "use must consume def");
109 bool const Result = Block[UseIndex].Kills[DefIndex];
171 dump(" Consumes", Block[I].Consumes);
172 dump(" Kills", Block[I].Kills);
lib/Transforms/IPO/HotColdSplitting.cpp 317 Function *OrigF = Region[0]->getParent();
334 &*Region[0]->begin())
343 &*Region[0]->begin())
lib/Transforms/IPO/Inliner.cpp 488 if (InlineHistory[InlineHistoryID].first == F)
490 InlineHistoryID = InlineHistory[InlineHistoryID].second;
lib/Transforms/InstCombine/InstCombineVectorOps.cpp 1398 if (Mask[i] < 0) continue; // Ignore undef values.
1400 isLHSID &= (Mask[i] == (int)i);
1403 isRHSID &= (Mask[i]-e == i);
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 481 if (RegInfos[0].R->getParent()) {
482 OS << "], Parent " << RegInfos[0].R->getParent()->getNameStr();
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 1309 const PGOUseEdge *E = BBCountInfo.OutEdges[s];
lib/Transforms/Scalar/CallSiteSplitting.cpp 329 BasicBlock *PredBB = Preds[i].first;
338 addConditions(NewCS, Preds[i].second);
lib/Transforms/Scalar/GVNHoist.cpp 789 InValue[V[i]->getParent()].push_back(std::make_pair(VN, V[i]));
789 InValue[V[i]->getParent()].push_back(std::make_pair(VN, V[i]));
797 if (DT->properlyDominates(IDFB, V[i]->getParent())) {
800 << ", for Insn: " << *V[i]);
lib/Transforms/Scalar/GVNSink.cpp 294 return llvm::all_of(Values, [&](Value *V) { return V == Values[0]; });
299 Values, [&](Value *V) { return V->getType() == Values[0]->getType(); });
lib/Transforms/Scalar/GuardWidening.cpp 395 if (GuardsInCurBB[Index] == &I)
lib/Transforms/Scalar/JumpThreading.cpp 1961 PredBB = PredBBs[0];
2271 << "' into predecessor block '" << PredBBs[0]->getName()
2288 PredBB = PredBBs[0];
lib/Transforms/Scalar/LoopDistribute.cpp 512 Value *Ptr = RtPtrCheck->Pointers[I].PointerValue;
514 LAI.getInstructionsForAccess(Ptr, RtPtrCheck->Pointers[I].IsWritePtr);
lib/Transforms/Scalar/LoopLoadElimination.cpp 371 std::for_each(MemInstrs.begin(), &MemInstrs[getInstrIndex(LastLoad)],
lib/Transforms/Scalar/LoopRerollPass.cpp 221 return Instructions[i+1];
lib/Transforms/Scalar/LoopStrengthReduce.cpp 3142 const IVInc &Head = Chain.Incs[0];
3573 const SCEV *BaseReg = IsScaledReg ? Base.ScaledReg : Base.BaseRegs[Idx];
3745 const SCEV *G = IsScaledReg ? Base.ScaledReg : Base.BaseRegs[Idx];
3803 const SCEV *G = IsScaledReg ? Base.ScaledReg : Base.BaseRegs[Idx];
4951 VisitedRegs.insert(F.ScaledReg ? F.ScaledReg : F.BaseRegs[0]);
5480 Rewrite(Uses[LUIdx], Fixup, *Solution[LUIdx], Rewriter, DeadInsts);
lib/Transforms/Scalar/LoopUnswitch.cpp 1219 BasicBlock *ExitBlock = ExitBlocks[i];
lib/Transforms/Scalar/MemCpyOptimizer.cpp 406 AMemSet->setDebugLoc(Range.TheStores[0]->getDebugLoc());
lib/Transforms/Scalar/NewGVN.cpp 200 return Components[ComponentID];
lib/Transforms/Scalar/Reassociate.cpp 78 << *Ops[0].Op->getType() << '\t';
81 Ops[i].Op->printAsOperand(dbgs(), false, M);
82 dbgs() << ", #" << Ops[i].Rank << "] ";
1004 unsigned XRank = Ops[i].Rank;
1006 for (unsigned j = i+1; j != e && Ops[j].Rank == XRank; ++j) {
1007 if (Ops[j].Op == X)
1009 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op))
1015 for (unsigned j = i-1; j != ~0U && Ops[j].Rank == XRank; --j) {
1016 if (Ops[j].Op == X)
1018 if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op))
lib/Transforms/Scalar/Scalarizer.cpp 376 CV[I]->takeName(Old);
377 Old->replaceAllUsesWith(CV[I]);
405 if (Instruction *New = dyn_cast<Instruction>(CV[I])) {
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp 673 assert(SpeculatedVals[PredIdx] &&
675 assert(SpeculatedVals[PredIdx]->getType() == OpI->getType() &&
679 U.set(SpeculatedVals[PredIdx]);
lib/Transforms/Utils/ASanStackFrameLayout.cpp 122 SB.resize(Vars[0].Offset / Granularity, kAsanStackLeftRedzoneMagic);
lib/Transforms/Utils/Evaluator.cpp 685 setVal(&*AI, ActualArgs[ArgNo]);
lib/Transforms/Utils/InlineFunction.cpp 156 phi->addIncoming(UnwindDestPHIValues[i], src);
lib/Transforms/Utils/Local.cpp 936 BasicBlock *PredBB = BBPreds[i];
2708 if (A->Provenance[i] != BitPart::Unset &&
2709 B->Provenance[i] != BitPart::Unset &&
2710 A->Provenance[i] != B->Provenance[i])
2710 A->Provenance[i] != B->Provenance[i])
2713 if (A->Provenance[i] == BitPart::Unset)
2714 Result->Provenance[i] = B->Provenance[i];
2716 Result->Provenance[i] = A->Provenance[i];
2786 Result->Provenance[i] = Res->Provenance[i];
lib/Transforms/Utils/MisExpect.cpp 106 llvm::dbgs() << "Weights[" << Idx << "] = " << Weights[Idx] << "\n";
123 const uint64_t ProfileCount = Weights[Index];
lib/Transforms/Utils/PredicateInfo.cpp 740 return ValueInfos[OINI];
lib/Transforms/Utils/SimplifyCFG.cpp 4838 if (ResultVector[0].second.size() == 1 &&
4839 ResultVector[1].second.size() == 1) {
4840 ConstantInt *const FirstCase = ResultVector[0].second[0];
4840 ConstantInt *const FirstCase = ResultVector[0].second[0];
4841 ConstantInt *const SecondCase = ResultVector[1].second[0];
4841 ConstantInt *const SecondCase = ResultVector[1].second[0];
4844 Value *SelectValue = ResultVector[1].first;
4848 SelectValue = Builder.CreateSelect(ValueCompare, ResultVector[1].first,
4853 return Builder.CreateSelect(ValueCompare, ResultVector[0].first,
4990 ConstantInt *CaseVal = Values[I].first;
4991 Constant *CaseRes = Values[I].second;
5450 uint64_t Idx = (ResultList[I].first->getValue() - MinCaseVal->getValue())
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp 861 ArrayRef<Instruction *> Chunk(&Chain.second[CI], Len);
lib/Transforms/Vectorize/SLPVectorizer.cpp 732 return OpsVec[OpIdx][Lane];
732 return OpsVec[OpIdx][Lane];
920 unsigned getNumLanes() const { return OpsVec[0].size(); }
971 ValueList OpVL(OpsVec[OpIdx].size());
972 assert(OpsVec[OpIdx].size() == getNumLanes() &&
975 OpVL[Lane] = OpsVec[OpIdx][Lane].V;
975 OpVL[Lane] = OpsVec[OpIdx][Lane].V;
1204 [this](Value *V, unsigned Idx) { return V == Scalars[Idx]; });
1288 assert(!Operands[OpIdx].empty() && "No operand available");
1289 return Operands[OpIdx][0];
1289 return Operands[OpIdx][0];
1350 for (const Value *V : Operands[OpI])
1433 VectorizableTree[Id]->dump();
2050 OS << "<splat> " << *Entry->Scalars[0];
3277 if (VectorizableTree.size() == 1 && !VectorizableTree[0]->NeedToGather)
3284 if (!VectorizableTree[0]->NeedToGather &&
3285 (allConstant(VectorizableTree[1]->Scalars) ||
3286 isSplat(VectorizableTree[1]->Scalars)))
3290 if (VectorizableTree[0]->NeedToGather || VectorizableTree[1]->NeedToGather)
3290 if (VectorizableTree[0]->NeedToGather || VectorizableTree[1]->NeedToGather)
3300 unsigned NumElts = VectorizableTree[0]->Scalars.size();
3301 Value *FirstReduced = VectorizableTree[0]->Scalars[0];
6031 propagateIRFlags(Op, ReductionOps[0]);
6038 propagateIRFlags(SI->getCondition(), ReductionOps[0]);
6039 propagateIRFlags(Op, ReductionOps[1]);
lib/Transforms/Vectorize/VPlan.h 142 return Entry[Part] != nullptr;
158 assert(Entry[Instance.Part].size() == VF &&
160 return Entry[Instance.Part][Instance.Lane] != nullptr;
160 return Entry[Instance.Part][Instance.Lane] != nullptr;
lib/Transforms/Vectorize/VPlanValue.h 164 return Operands[N];
tools/clang/include/clang/AST/TemplateBase.h 587 return Arguments[I];
tools/clang/include/clang/AST/UnresolvedSet.h 129 const DeclAccessPair &operator[](unsigned I) const { return decls()[I]; }
tools/clang/include/clang/Basic/Diagnostic.h 1401 return DiagObj->DiagRanges[Idx];
1415 return DiagObj->DiagFixItHints[Idx];
tools/clang/include/clang/Basic/DiagnosticOptions.def 46 SEMANTIC_DIAGOPT(IgnoreWarnings, 1, 0) /// -w
47 DIAGOPT(NoRewriteMacros, 1, 0) /// -Wno-rewrite-macros
48 DIAGOPT(Pedantic, 1, 0) /// -pedantic
49 DIAGOPT(PedanticErrors, 1, 0) /// -pedantic-errors
50 DIAGOPT(ShowColumn, 1, 1) /// Show column number on diagnostics.
51 DIAGOPT(ShowLocation, 1, 1) /// Show source location information.
52 DIAGOPT(ShowLevel, 1, 1) /// Show diagnostic level.
53 DIAGOPT(AbsolutePath, 1, 0) /// Use absolute paths.
54 DIAGOPT(ShowCarets, 1, 1) /// Show carets in diagnostics.
55 DIAGOPT(ShowFixits, 1, 1) /// Show fixit information.
56 DIAGOPT(ShowSourceRanges, 1, 0) /// Show source ranges in numeric form.
57 DIAGOPT(ShowParseableFixits, 1, 0) /// Show machine parseable fix-its.
58 DIAGOPT(ShowPresumedLoc, 1, 0) /// Show presumed location for diagnostics.
59 DIAGOPT(ShowOptionNames, 1, 0) /// Show the option name for mappable
61 DIAGOPT(ShowNoteIncludeStack, 1, 0) /// Show include stacks for notes.
62 VALUE_DIAGOPT(ShowCategories, 2, 0) /// Show categories: 0 -> none, 1 -> Number,
67 DIAGOPT(ShowColors, 1, 0) /// Show diagnostics with ANSI color sequences.
70 DIAGOPT(VerifyDiagnostics, 1, 0) /// Check that diagnostics match the expected
77 DIAGOPT(ElideType, 1, 0) /// Elide identical types in template diffing
78 DIAGOPT(ShowTemplateTree, 1, 0) /// Print a template tree when diffing
79 DIAGOPT(CLFallbackMode, 1, 0) /// Format for clang-cl fallback mode
81 VALUE_DIAGOPT(ErrorLimit, 32, 0) /// Limit # errors emitted.
83 VALUE_DIAGOPT(MacroBacktraceLimit, 32, DefaultMacroBacktraceLimit)
85 VALUE_DIAGOPT(TemplateBacktraceLimit, 32, DefaultTemplateBacktraceLimit)
87 VALUE_DIAGOPT(ConstexprBacktraceLimit, 32, DefaultConstexprBacktraceLimit)
89 VALUE_DIAGOPT(SpellCheckingLimit, 32, DefaultSpellCheckingLimit)
91 VALUE_DIAGOPT(SnippetLineLimit, 32, DefaultSnippetLineLimit)
93 VALUE_DIAGOPT(TabStop, 32, DefaultTabStop) /// The distance between tab stops.
95 VALUE_DIAGOPT(MessageLength, 32, 0)
tools/clang/include/clang/Basic/LangOptions.def 82 LANGOPT(C99 , 1, 0, "C99")
83 LANGOPT(C11 , 1, 0, "C11")
84 LANGOPT(C17 , 1, 0, "C17")
85 LANGOPT(C2x , 1, 0, "C2x")
86 LANGOPT(MSVCCompat , 1, 0, "Microsoft Visual C++ full compatibility mode")
87 LANGOPT(MicrosoftExt , 1, 0, "Microsoft C++ extensions")
88 LANGOPT(AsmBlocks , 1, 0, "Microsoft inline asm blocks")
89 LANGOPT(Borland , 1, 0, "Borland extensions")
90 LANGOPT(CPlusPlus , 1, 0, "C++")
91 LANGOPT(CPlusPlus11 , 1, 0, "C++11")
92 LANGOPT(CPlusPlus14 , 1, 0, "C++14")
93 LANGOPT(CPlusPlus17 , 1, 0, "C++17")
94 LANGOPT(CPlusPlus2a , 1, 0, "C++2a")
95 LANGOPT(ObjC , 1, 0, "Objective-C")
96 BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
98 BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,
100 BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1,
102 LANGOPT(AppExt , 1, 0, "Objective-C App Extension")
103 LANGOPT(Trigraphs , 1, 0,"trigraphs")
104 LANGOPT(LineComment , 1, 0, "'//' comments")
105 LANGOPT(Bool , 1, 0, "bool, true, and false keywords")
106 LANGOPT(Half , 1, 0, "half keyword")
107 LANGOPT(WChar , 1, CPlusPlus, "wchar_t keyword")
108 LANGOPT(Char8 , 1, 0, "char8_t keyword")
109 LANGOPT(DeclSpecKeyword , 1, 0, "__declspec keyword")
110 BENIGN_LANGOPT(DollarIdents , 1, 1, "'$' in identifiers")
111 BENIGN_LANGOPT(AsmPreprocessor, 1, 0, "preprocessor in asm mode")
112 LANGOPT(GNUMode , 1, 1, "GNU extensions")
113 LANGOPT(GNUKeywords , 1, 1, "GNU keywords")
114 VALUE_LANGOPT(GNUCVersion , 32, 0, "GNU C compatibility version")
115 BENIGN_LANGOPT(ImplicitInt, 1, !C99 && !CPlusPlus, "C89 implicit 'int'")
116 LANGOPT(Digraphs , 1, 0, "digraphs")
117 BENIGN_LANGOPT(HexFloats , 1, C99, "C99 hexadecimal float constants")
118 LANGOPT(CXXOperatorNames , 1, 0, "C++ operator name keywords")
119 LANGOPT(AppleKext , 1, 0, "Apple kext support")
120 BENIGN_LANGOPT(PascalStrings, 1, 0, "Pascal string support")
121 LANGOPT(WritableStrings , 1, 0, "writable string support")
122 LANGOPT(ConstStrings , 1, 0, "const-qualified string support")
125 LANGOPT(AltiVec , 1, 0, "AltiVec-style vector initializers")
126 LANGOPT(ZVector , 1, 0, "System z vector extensions")
127 LANGOPT(Exceptions , 1, 0, "exception handling")
128 LANGOPT(ObjCExceptions , 1, 0, "Objective-C exceptions")
129 LANGOPT(CXXExceptions , 1, 0, "C++ exceptions")
130 LANGOPT(DWARFExceptions , 1, 0, "dwarf exception handling")
131 LANGOPT(SjLjExceptions , 1, 0, "setjmp-longjump exception handling")
132 LANGOPT(SEHExceptions , 1, 0, "SEH .xdata exception handling")
133 LANGOPT(WasmExceptions , 1, 0, "WebAssembly exception handling")
134 LANGOPT(ExternCNoUnwind , 1, 0, "Assume extern C functions don't unwind")
135 LANGOPT(TraditionalCPP , 1, 0, "traditional CPP emulation")
136 LANGOPT(RTTI , 1, 1, "run-time type information")
137 LANGOPT(RTTIData , 1, 1, "emit run-time type information data")
138 LANGOPT(MSBitfields , 1, 0, "Microsoft-compatible structure layout")
139 LANGOPT(Freestanding, 1, 0, "freestanding implementation")
140 LANGOPT(NoBuiltin , 1, 0, "disable builtin functions")
141 LANGOPT(NoMathBuiltin , 1, 0, "disable math builtin functions")
142 LANGOPT(GNUAsm , 1, 1, "GNU-style inline assembly")
143 LANGOPT(Coroutines , 1, 0, "C++20 coroutines")
144 LANGOPT(DllExportInlines , 1, 1, "dllexported classes dllexport inline methods")
145 LANGOPT(RelaxedTemplateTemplateArgs, 1, 0, "C++17 relaxed matching of template template arguments")
147 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
149 BENIGN_LANGOPT(ThreadsafeStatics , 1, 1, "thread-safe static initializers")
150 LANGOPT(POSIXThreads , 1, 0, "POSIX thread support")
151 LANGOPT(Blocks , 1, 0, "blocks extension to C")
152 BENIGN_LANGOPT(EmitAllDecls , 1, 0, "emitting all declarations")
153 LANGOPT(MathErrno , 1, 1, "errno in math functions")
154 BENIGN_LANGOPT(HeinousExtensions , 1, 0, "extensions that we really don't like and may be ripped out at any time")
155 LANGOPT(Modules , 1, 0, "modules semantics")
156 COMPATIBLE_LANGOPT(ModulesTS , 1, 0, "C++ Modules TS syntax")
157 COMPATIBLE_LANGOPT(CPlusPlusModules, 1, 0, "C++ modules syntax")
160 BENIGN_LANGOPT(CompilingPCH, 1, 0, "building a pch")
161 BENIGN_LANGOPT(BuildingPCHWithObjectFile, 1, 0, "building a pch which has a corresponding object file")
162 BENIGN_LANGOPT(CacheGeneratedPCH, 1, 0, "cache generated PCH files in memory")
163 COMPATIBLE_LANGOPT(ModulesDeclUse , 1, 0, "require declaration of module uses")
164 BENIGN_LANGOPT(ModulesSearchAll , 1, 1, "searching even non-imported modules to find unresolved references")
165 COMPATIBLE_LANGOPT(ModulesStrictDeclUse, 1, 0, "requiring declaration of module uses and all headers to be in modules")
166 BENIGN_LANGOPT(ModulesErrorRecovery, 1, 1, "automatically importing modules as needed when performing error recovery")
167 BENIGN_LANGOPT(ImplicitModules, 1, 1, "building modules that are not specified via -fmodule-file")
168 COMPATIBLE_LANGOPT(ModulesLocalVisibility, 1, 0, "local submodule visibility")
169 COMPATIBLE_LANGOPT(Optimize , 1, 0, "__OPTIMIZE__ predefined macro")
170 COMPATIBLE_LANGOPT(OptimizeSize , 1, 0, "__OPTIMIZE_SIZE__ predefined macro")
171 COMPATIBLE_LANGOPT(Static , 1, 0, "__STATIC__ predefined macro (as opposed to __DYNAMIC__)")
172 VALUE_LANGOPT(PackStruct , 32, 0,
174 VALUE_LANGOPT(MaxTypeAlign , 32, 0,
176 VALUE_LANGOPT(AlignDouble , 1, 0, "Controls if doubles should be aligned to 8 bytes (x86 only)")
177 VALUE_LANGOPT(LongDoubleSize , 32, 0, "width of long double")
178 LANGOPT(PPCIEEELongDouble , 1, 0, "use IEEE 754 quadruple-precision for long double")
179 COMPATIBLE_VALUE_LANGOPT(PICLevel , 2, 0, "__PIC__ level")
180 COMPATIBLE_VALUE_LANGOPT(PIE , 1, 0, "is pie")
181 LANGOPT(ROPI , 1, 0, "Read-only position independence")
182 LANGOPT(RWPI , 1, 0, "Read-write position independence")
183 COMPATIBLE_LANGOPT(GNUInline , 1, 0, "GNU inline semantics")
184 COMPATIBLE_LANGOPT(NoInlineDefine , 1, 0, "__NO_INLINE__ predefined macro")
185 COMPATIBLE_LANGOPT(Deprecated , 1, 0, "__DEPRECATED predefined macro")
186 COMPATIBLE_LANGOPT(FastMath , 1, 0, "fast FP math optimizations, and __FAST_MATH__ predefined macro")
187 COMPATIBLE_LANGOPT(FiniteMathOnly , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
188 COMPATIBLE_LANGOPT(UnsafeFPMath , 1, 0, "Unsafe Floating Point Math")
190 BENIGN_LANGOPT(ObjCGCBitmapPrint , 1, 0, "printing of GC's bitmap layout for __weak/__strong ivars")
192 BENIGN_LANGOPT(AccessControl , 1, 1, "C++ access control")
193 LANGOPT(CharIsSigned , 1, 1, "signed char")
194 LANGOPT(WCharSize , 4, 0, "width of wchar_t")
195 LANGOPT(WCharIsSigned , 1, 0, "signed or unsigned wchar_t")
199 LANGOPT(ShortEnums , 1, 0, "short enum types")
201 LANGOPT(OpenCL , 1, 0, "OpenCL")
202 LANGOPT(OpenCLVersion , 32, 0, "OpenCL C version")
203 LANGOPT(OpenCLCPlusPlus , 1, 0, "C++ for OpenCL")
204 LANGOPT(OpenCLCPlusPlusVersion , 32, 0, "C++ for OpenCL version")
205 LANGOPT(NativeHalfType , 1, 0, "Native half type support")
206 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
207 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
208 LANGOPT(CUDA , 1, 0, "CUDA")
209 LANGOPT(HIP , 1, 0, "HIP")
210 LANGOPT(OpenMP , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")
211 LANGOPT(OpenMPSimd , 1, 0, "Use SIMD only OpenMP support.")
212 LANGOPT(OpenMPUseTLS , 1, 0, "Use TLS for threadprivates or runtime calls")
213 LANGOPT(OpenMPIsDevice , 1, 0, "Generate code only for OpenMP target device")
214 LANGOPT(OpenMPCUDAMode , 1, 0, "Generate code for OpenMP pragmas in SIMT/SPMD mode")
215 LANGOPT(OpenMPCUDAForceFullRuntime , 1, 0, "Force to use full runtime in all constructs when offloading to CUDA devices")
216 LANGOPT(OpenMPCUDANumSMs , 32, 0, "Number of SMs for CUDA devices.")
217 LANGOPT(OpenMPCUDABlocksPerSM , 32, 0, "Number of blocks per SM for CUDA devices.")
218 LANGOPT(OpenMPCUDAReductionBufNum , 32, 1024, "Number of the reduction records in the intermediate reduction buffer used for the teams reductions.")
219 LANGOPT(OpenMPOptimisticCollapse , 1, 0, "Use at most 32 bits to represent the collapsed loop nest counter.")
220 LANGOPT(RenderScript , 1, 0, "RenderScript")
222 LANGOPT(CUDAIsDevice , 1, 0, "compiling for CUDA device")
223 LANGOPT(CUDAAllowVariadicFunctions, 1, 0, "allowing variadic functions in CUDA device code")
224 LANGOPT(CUDAHostDeviceConstexpr, 1, 1, "treating unattributed constexpr functions as __host__ __device__")
225 LANGOPT(CUDADeviceApproxTranscendentals, 1, 0, "using approximate transcendental functions")
226 LANGOPT(GPURelocatableDeviceCode, 1, 0, "generate relocatable device code")
227 LANGOPT(GPUAllowDeviceInit, 1, 0, "allowing device side global init functions for HIP")
229 LANGOPT(SYCLIsDevice , 1, 0, "Generate code for SYCL device")
231 LANGOPT(HIPUseNewLaunchAPI, 1, 0, "Use new kernel launching API for HIP")
233 LANGOPT(SizedDeallocation , 1, 0, "sized deallocation")
234 LANGOPT(AlignedAllocation , 1, 0, "aligned allocation")
235 LANGOPT(AlignedAllocationUnavailable, 1, 0, "aligned allocation functions are unavailable")
236 LANGOPT(NewAlignOverride , 32, 0, "maximum alignment guaranteed by '::operator new(size_t)'")
237 LANGOPT(ConceptsTS , 1, 0, "enable C++ Extensions for Concepts")
238 BENIGN_LANGOPT(ModulesCodegen , 1, 0, "Modules code generation")
239 BENIGN_LANGOPT(ModulesDebugInfo , 1, 0, "Modules debug info")
240 BENIGN_LANGOPT(ElideConstructors , 1, 1, "C++ copy constructor elision")
241 BENIGN_LANGOPT(DumpRecordLayouts , 1, 0, "dumping the layout of IRgen'd records")
242 BENIGN_LANGOPT(DumpRecordLayoutsSimple , 1, 0, "dumping the layout of IRgen'd records in a simple form")
243 BENIGN_LANGOPT(DumpVTableLayouts , 1, 0, "dumping the layouts of emitted vtables")
244 LANGOPT(NoConstantCFStrings , 1, 0, "no constant CoreFoundation strings")
245 BENIGN_LANGOPT(InlineVisibilityHidden , 1, 0, "hidden visibility for inline C++ methods")
246 LANGOPT(GlobalAllocationFunctionVisibilityHidden , 1, 0, "hidden visibility for global operator new and delete declaration")
247 BENIGN_LANGOPT(ParseUnknownAnytype, 1, 0, "__unknown_anytype")
248 BENIGN_LANGOPT(DebuggerSupport , 1, 0, "debugger support")
249 BENIGN_LANGOPT(DebuggerCastResultToId, 1, 0, "for 'po' in the debugger, cast the result to id if it is of unknown type")
250 BENIGN_LANGOPT(DebuggerObjCLiteral , 1, 0, "debugger Objective-C literals and subscripting support")
252 BENIGN_LANGOPT(SpellChecking , 1, 1, "spell-checking")
253 LANGOPT(SinglePrecisionConstants , 1, 0, "treating double-precision floating point constants as single precision constants")
254 LANGOPT(FastRelaxedMath , 1, 0, "OpenCL fast relaxed math")
257 LANGOPT(NoBitFieldTypeAlign , 1, 0, "bit-field type alignment")
258 LANGOPT(HexagonQdsp6Compat , 1, 0, "hexagon-qdsp6 backward compatibility")
259 LANGOPT(ObjCAutoRefCount , 1, 0, "Objective-C automated reference counting")
260 LANGOPT(ObjCWeakRuntime , 1, 0, "__weak support in the ARC runtime")
261 LANGOPT(ObjCWeak , 1, 0, "Objective-C __weak in ARC and MRC files")
262 LANGOPT(ObjCSubscriptingLegacyRuntime , 1, 0, "Subscripting support in legacy ObjectiveC runtime")
263 LANGOPT(CFProtectionBranch , 1, 0, "Control-Flow Branch Protection enabled")
264 LANGOPT(FakeAddressSpaceMap , 1, 0, "OpenCL fake address space map")
266 LANGOPT(IncludeDefaultHeader, 1, 0, "Include default header file for OpenCL")
267 LANGOPT(DeclareOpenCLBuiltins, 1, 0, "Declare OpenCL builtin functions")
268 BENIGN_LANGOPT(DelayedTemplateParsing , 1, 0, "delayed template parsing")
269 LANGOPT(BlocksRuntimeOptional , 1, 0, "optional blocks runtime")
270 LANGOPT(
280 LANGOPT(SetVisibilityForExternDecls, 1, 0,
289 BENIGN_LANGOPT(ArrowDepth, 32, 256,
291 BENIGN_LANGOPT(InstantiationDepth, 32, 1024,
293 BENIGN_LANGOPT(ConstexprCallDepth, 32, 512,
295 BENIGN_LANGOPT(ConstexprStepLimit, 32, 1048576,
297 BENIGN_LANGOPT(EnableNewConstInterp, 1, 0,
299 BENIGN_LANGOPT(ForceNewConstInterp, 1, 0,
301 BENIGN_LANGOPT(BracketDepth, 32, 256,
303 BENIGN_LANGOPT(NumLargeByValueCopy, 32, 0,
305 VALUE_LANGOPT(MSCompatibilityVersion, 32, 0, "Microsoft Visual C/C++ Version")
306 VALUE_LANGOPT(VtorDispMode, 2, 1, "How many vtordisps to insert")
308 LANGOPT(ApplePragmaPack, 1, 0, "Apple gcc-compatible #pragma pack handling")
310 LANGOPT(RetainCommentsFromSystemHeaders, 1, 0, "retain documentation comments from system headers in the AST")
312 LANGOPT(SanitizeAddressFieldPadding, 2, 0, "controls how aggressive is ASan "
316 LANGOPT(Cmse, 1, 0, "ARM Security extensions support")
318 LANGOPT(XRayInstrument, 1, 0, "controls whether to do XRay instrumentation")
319 LANGOPT(XRayAlwaysEmitCustomEvents, 1, 0,
322 LANGOPT(XRayAlwaysEmitTypedEvents, 1, 0,
326 LANGOPT(ForceEmitVTables, 1, 0, "whether to emit all vtables")
328 BENIGN_LANGOPT(AllowEditorPlaceholders, 1, 0,
335 COMPATIBLE_VALUE_LANGOPT(FunctionAlignment, 5, 0, "Default alignment for functions")
337 LANGOPT(FixedPoint, 1, 0, "fixed point types")
338 LANGOPT(PaddingOnUnsignedFixedPoint, 1, 0,
341 LANGOPT(RegisterStaticDestructors, 1, 1, "Register C++ static destructors")
tools/clang/include/clang/Basic/SourceManager.h 1683 return LocalSLocEntryTable[Index];
1702 return LocalSLocEntryTable[0];
tools/clang/include/clang/Lex/MacroInfo.h 237 return ReplacementTokens[Tok];
tools/clang/include/clang/Lex/Preprocessor.h 1503 return CachedTokens[CachedLexPos-1].getLastLoc();
tools/clang/include/clang/Sema/DeclSpec.h 2191 return DeclTypeInfo[i];
2217 if (!DeclTypeInfo[i].isParen())
2218 return &DeclTypeInfo[i];
2228 if (!DeclTypeInfo[i-1].isParen())
2229 return &DeclTypeInfo[i-1];
2249 switch (DeclTypeInfo[i].Kind) {
tools/clang/include/clang/Sema/Designator.h 195 return Designators[Idx];
tools/clang/include/clang/Sema/ScopeInfo.h 705 return Captures[Known->second - 1];
tools/clang/include/clang/Sema/Template.h 101 assert(Index < TemplateArgumentLists[getNumLevels() - Depth - 1].size());
102 return TemplateArgumentLists[getNumLevels() - Depth - 1][Index];
115 if (Index >= TemplateArgumentLists[getNumLevels() - Depth - 1].size())
tools/clang/include/clang/Serialization/ASTReader.h 1815 return getLocalType(F, Record[Idx++]);
2054 return DecodeIdentifierInfo(getGlobalIdentifierID(M, Record[Idx++]));
2123 return getLocalSelector(M, Record[Idx++]);
2215 return ReadSourceLocation(ModuleFile, Record[Idx++]);
2240 Idx += Record[Idx] + 1;
tools/clang/include/clang/Serialization/ModuleManager.h 177 ModuleFile &getPrimaryModule() const { return *Chain[0]; }
180 ModuleFile &operator[](unsigned Index) const { return *Chain[Index]; }
tools/clang/lib/ARCMigrate/ObjCMT.cpp 1120 if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) {
1120 if (Attrs1[i]->getKind() == Attrs2[j]->getKind()) {
1122 AvailabilityArgsMatch = AvailabilityAttrsMatch(Attrs1[i], Attrs2[j]);
1122 AvailabilityArgsMatch = AvailabilityAttrsMatch(Attrs1[i], Attrs2[j]);
tools/clang/lib/AST/CommentCommandTraits.cpp 125 if (RegisteredCommands[i]->Name == Name)
126 return RegisteredCommands[i];
133 return RegisteredCommands[CommandID - llvm::array_lengthof(Commands)];
tools/clang/lib/AST/ExprConstant.cpp 350 Entries[MostDerivedPathLength - 1].getAsArrayIndex() ==
3263 uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3286 uint64_t Index = Sub.Entries[I].getAsArrayIndex();
3308 } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {
3347 const CXXRecordDecl *Base = getAsBaseClass(Sub.Entries[I]);
3459 if (A.Entries[I].getAsArrayIndex() != B.Entries[I].getAsArrayIndex()) {
3459 if (A.Entries[I].getAsArrayIndex() != B.Entries[I].getAsArrayIndex()) {
3468 if (A.Entries[I].getAsBaseOrMember() !=
3469 B.Entries[I].getAsBaseOrMember()) {
3473 if (const FieldDecl *FD = getAsField(A.Entries[I]))
3772 uint64_t CharIndex = LVal.Designator.Entries[0].getAsArrayIndex();
5350 LHS.Designator.Entries[PathLength]
5377 LHS.Designator.Entries[PathLength]
6077 Pointer.Designator.Entries[0].getAsArrayIndex() != 0;
6149 if (!Bytes[I.getQuantity()])
6151 Output.push_back(*Bytes[I.getQuantity()]);
10274 const auto &Entry = LVal.Designator.Entries[I];
tools/clang/lib/AST/VTableBuilder.cpp 228 const CXXBasePathElement &Element = Path[I - 1];
240 const CXXBasePathElement &Element = Path[I];
2908 NextBase = WhichVFPtr.PathToIntroducingObject[BaseDepth];
tools/clang/lib/Basic/Module.cpp 148 if (hasFeature(Current->Requirements[I].first, LangOpts, Target) !=
149 Current->Requirements[I].second) {
150 Req = Current->Requirements[I];
354 Module *Mod = Exports[I].getPointer();
355 if (!Exports[I].getInt()) {
368 if (Module *Restriction = Exports[I].getPointer())
444 if (!Requirements[I].second)
446 OS << Requirements[I].first;
530 if (Module *Restriction = Exports[I].getPointer()) {
532 if (Exports[I].getInt())
543 printModuleId(OS, UnresolvedExports[I].Id);
544 if (UnresolvedExports[I].Wildcard)
545 OS << (UnresolvedExports[I].Id.empty() ? "*" : ".*");
552 OS << DirectUses[I]->getFullModuleName(true);
559 printModuleId(OS, UnresolvedDirectUses[I]);
566 if (LinkLibraries[I].IsFramework)
569 OS.write_escaped(LinkLibraries[I].Library);
tools/clang/lib/Basic/SourceManager.cpp 763 LocalSLocEntryTable[LastFileIDLookup.ID].getOffset() < SLocOffset) {
822 if (!LocalSLocEntryTable[MiddleIndex].isExpansion())
2117 DumpSLocEntry(ID, LocalSLocEntryTable[ID],
2119 : LocalSLocEntryTable[ID + 1].getOffset());
tools/clang/lib/CodeGen/CGBuiltin.cpp 1146 char Size = Layout.Items[I].getSizeByte();
tools/clang/lib/CodeGen/CGCall.cpp 1403 return ArgInfo[ArgNo].PaddingArgIndex != InvalidIndex;
1407 return ArgInfo[ArgNo].PaddingArgIndex;
1414 return std::make_pair(ArgInfo[ArgNo].FirstArgIndex,
1415 ArgInfo[ArgNo].NumberOfArgs);
2567 EmitParmDecl(*Args[I], ArgVals[I], I + 1);
2570 EmitParmDecl(*Args[I], ArgVals[I], I + 1);
4574 llvm::Value *AlignmentVal = CallArgs[AA->getParamIndex().getLLVMIndex()]
tools/clang/lib/CodeGen/CGExprCXX.cpp 1495 auto &Arg = NewArgs[I + NumNonPlacementArgs];
1526 auto &Arg = NewArgs[I + NumNonPlacementArgs];
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 1200 getReductionInit(ClausesData[N].ReductionOp);
5228 const Expr *E = Data.Dependences[I].second;
5260 switch (Data.Dependences[I].first) {
6267 CGM, Loc, RCG, Cnt, Data.ReductionOps[Cnt], LHSExprs[Cnt],
6268 RHSExprs[Cnt], Data.ReductionCopies[Cnt]));
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 186 LValue getSharedLValue(unsigned N) const { return SharedAddresses[N].first; }
190 return Sizes[N];
193 const VarDecl *getBaseDecl(unsigned N) const { return BaseDecls[N]; }
195 const Expr *getRefExpr(unsigned N) const { return ClausesData[N].Ref; }
tools/clang/lib/CodeGen/CGVTT.cpp 62 const VTTVTable &VTTVT = Builder.getVTTVTables()[i->VTableIndex];
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 1242 const std::unique_ptr<VPtrInfo> &VBT = (*VBGlobals.VBTables)[I];
1243 llvm::GlobalVariable *GV = VBGlobals.Globals[I];
1633 const CXXRecordDecl *DerivedRD = Info.PathToIntroducingObject[I - 1];
1634 const CXXRecordDecl *BaseRD = Info.PathToIntroducingObject[I];
1748 mangleVFTableName(getMangleContext(), RD, *VFPtrs[J], Name);
2040 const std::unique_ptr<VPtrInfo>& VBT = (*VBGlobals.VBTables)[I];
2041 llvm::GlobalVariable *GV = VBGlobals.Globals[I];
tools/clang/lib/CodeGen/SwiftCallingConv.cpp 603 unpaddedType = Entries[0].Type;
tools/clang/lib/Driver/Action.cpp 200 getInputs()[i]->propagateDeviceOffloadInfo(OKinds[i], BArchs[i]);
200 getInputs()[i]->propagateDeviceOffloadInfo(OKinds[i], BArchs[i]);
216 if (auto *A = DDeps.getActions()[i]) {
218 A->propagateDeviceOffloadInfo(DDeps.getOffloadKinds()[i],
219 DDeps.getBoundArchs()[i]);
287 return HostTC ? getInputs()[1] : getInputs().front();
tools/clang/lib/Driver/Driver.cpp 1384 CrashReportInfo CrashInfo(TempFiles[0], VFS);
tools/clang/lib/Driver/ToolChains/Ananas.cpp 106 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
tools/clang/lib/Driver/ToolChains/Clang.cpp 1044 SmallString<128> P(Inputs[0].getBaseInput());
1119 : llvm::sys::path::filename(Inputs[0].getBaseInput()))));
1231 if (types::isCXX(Inputs[0].getType())) {
3401 InputInfo HeaderModuleInput(Inputs[0].getType(), ModuleName, ModuleName);
3404 IsHeaderModulePrecompile ? HeaderModuleInput : Inputs[0];
6008 const char *Str = getBaseInputName(Args, Inputs[0]);
6072 const InputInfo &Input = Inputs[0];
6124 SourceAction = SourceAction->getInputs()[0];
6307 const Action *CurDep = JA.getInputs()[I];
6340 if (const auto *OA = dyn_cast<OffloadAction>(JA.getInputs()[I])) {
6347 UB += CurTC->getInputFilename(Inputs[I]);
6412 UB += DepInfo[I].DependentToolChain->getInputFilename(Outputs[I]);
tools/clang/lib/Driver/ToolChains/CloudABI.cpp 78 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
tools/clang/lib/Driver/ToolChains/Darwin.cpp 92 const InputInfo &Input = Inputs[0];
98 SourceAction = SourceAction->getInputs()[0];
535 getStatsFileName(Args, Output, Inputs[0], getToolChain().getDriver());
694 const InputInfo &Input = Inputs[0];
715 const InputInfo &Input = Inputs[0];
tools/clang/lib/Driver/ToolChains/FreeBSD.cpp 264 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
tools/clang/lib/Driver/ToolChains/Fuchsia.cpp 111 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
tools/clang/lib/Driver/ToolChains/Gnu.cpp 515 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
891 SplitDebugName(Args, Inputs[0], Output));
tools/clang/lib/Driver/ToolChains/HIP.cpp 242 std::string Prefix = llvm::sys::path::stem(Inputs[0].getFilename()).str();
tools/clang/lib/Driver/ToolChains/MSVC.cpp 710 const InputInfo &II = Inputs[0];
tools/clang/lib/Driver/ToolChains/MinGW.cpp 56 SplitDebugName(Args, Inputs[0], Output));
tools/clang/lib/Driver/ToolChains/Myriad.cpp 31 const InputInfo &II = Inputs[0];
92 const InputInfo &II = Inputs[0];
tools/clang/lib/Driver/ToolChains/PS4CPU.cpp 59 const InputInfo &Input = Inputs[0];
tools/clang/lib/Driver/ToolChains/RISCVToolchain.cpp 106 AddGoldPlugin(ToolChain, Args, CmdArgs, Output, Inputs[0],
tools/clang/lib/Format/BreakableToken.cpp 276 if (CommentPragmasRegex.match(Content[LineIndex]))
278 return getCommentSplit(Content[LineIndex].substr(TailOffset),
286 StringRef Text = Content[LineIndex].substr(TailOffset);
300 return Tokens[LineIndex] ? *Tokens[LineIndex] : Tok;
300 return Tokens[LineIndex] ? *Tokens[LineIndex] : Tok;
463 if (CommentPragmasRegex.match(Content[LineIndex]))
465 return getCommentSplit(Content[LineIndex].substr(TailOffset),
512 encoding::columnWidthWithTabs(Content[LineIndex].substr(Offset, Length),
522 if (Content[LineIndex].substr(Offset, StringRef::npos).empty()) {
540 return std::max(0, ContentColumn[LineIndex]);
556 StringRef ContentWithNoDecoration = Content[LineIndex];
571 StringRef Text = Content[LineIndex].substr(TailOffset);
608 size_t Trimmed = Content[LineIndex].find_first_not_of(Blanks);
622 Lines[0].substr(1).find_first_not_of(Blanks) != StringRef::npos;
627 StringRef TrimmedContent = Content[LineIndex].ltrim(Blanks);
629 assert(Tokens[LineIndex - 1] == Tokens[LineIndex] &&
629 assert(Tokens[LineIndex - 1] == Tokens[LineIndex] &&
633 unsigned WhitespaceOffsetInToken = Content[LineIndex - 1].data() +
634 Content[LineIndex - 1].size() -
654 size_t BreakLength = Lines[0].substr(1).find_first_not_of(Blanks);
664 if (Content[LineIndex].empty()) {
677 if (ContentColumn[LineIndex] == 1) {
684 unsigned WhitespaceOffsetInToken = Content[LineIndex - 1].data() +
685 Content[LineIndex - 1].size() -
687 unsigned WhitespaceLength = Content[LineIndex].data() -
692 InPPDirective, /*Newlines=*/1, ContentColumn[LineIndex] - Prefix.size());
713 StringRef IndentContent = Content[LineIndex];
714 if (Lines[LineIndex].ltrim(Blanks).startswith("*")) {
715 IndentContent = Lines[LineIndex].ltrim(Blanks).substr(1);
718 mayReflowContent(Content[LineIndex]) && !Tok.Finalized &&
815 Content[LineIndex].substr(Offset, Length), StartColumn, Style.TabWidth,
822 return OriginalContentColumn[LineIndex];
823 return ContentColumn[LineIndex];
829 StringRef Text = Content[LineIndex].substr(TailOffset);
837 unsigned IndentAtLineBreak = OriginalContentColumn[LineIndex] +
838 Prefix[LineIndex].size() -
839 OriginalPrefix[LineIndex].size();
840 assert(IndentAtLineBreak >= Prefix[LineIndex].size());
843 Prefix[LineIndex], InPPDirective, /*Newlines=*/1,
844 /*Spaces=*/IndentAtLineBreak - Prefix[LineIndex].size());
852 size_t Trimmed = Content[LineIndex].find_first_not_of(Blanks);
863 if (LineIndex > 0 && Tokens[LineIndex] != Tokens[LineIndex - 1]) {
863 if (LineIndex > 0 && Tokens[LineIndex] != Tokens[LineIndex - 1]) {
867 *Tokens[LineIndex], /*Newlines=*/0, /*Spaces=*/0,
880 unsigned Offset = Lines[LineIndex - 1].data() +
881 Lines[LineIndex - 1].size() -
886 Lines[LineIndex].data() - tokenAt(LineIndex).TokenText.data() - Offset;
887 Whitespaces.replaceWhitespaceInToken(*Tokens[LineIndex], Offset,
897 Lines[LineIndex].data() - tokenAt(LineIndex).TokenText.data();
899 Content[LineIndex].data() - Lines[LineIndex].data();
899 Content[LineIndex].data() - Lines[LineIndex].data();
900 Whitespaces.replaceWhitespaceInToken(*Tokens[LineIndex], Offset,
917 if (LineIndex > 0 && Tokens[LineIndex] != Tokens[LineIndex - 1]) {
917 if (LineIndex > 0 && Tokens[LineIndex] != Tokens[LineIndex - 1]) {
924 ContentColumn[LineIndex] -
925 (Content[LineIndex].data() - Lines[LineIndex].data()) +
925 (Content[LineIndex].data() - Lines[LineIndex].data()) +
926 (OriginalPrefix[LineIndex].size() - Prefix[LineIndex].size());
926 (OriginalPrefix[LineIndex].size() - Prefix[LineIndex].size());
932 Whitespaces.replaceWhitespace(*Tokens[LineIndex],
938 if (OriginalPrefix[LineIndex] != Prefix[LineIndex]) {
938 if (OriginalPrefix[LineIndex] != Prefix[LineIndex]) {
942 assert(Prefix[LineIndex] == (OriginalPrefix[LineIndex] + " ").str() &&
942 assert(Prefix[LineIndex] == (OriginalPrefix[LineIndex] + " ").str() &&
946 tokenAt(LineIndex), OriginalPrefix[LineIndex].size(), 0, "", "",
961 StringRef IndentContent = Content[LineIndex];
962 if (Lines[LineIndex].startswith("//")) {
963 IndentContent = Lines[LineIndex].substr(2);
972 mayReflowContent(Content[LineIndex]) && !Tok.Finalized &&
974 OriginalPrefix[LineIndex] == OriginalPrefix[LineIndex - 1];
974 OriginalPrefix[LineIndex] == OriginalPrefix[LineIndex - 1];
tools/clang/lib/Format/Format.cpp 1419 if (!AnnotatedLines[i]->First->Next)
1421 FormatToken *Tok = AnnotatedLines[i]->First->Next;
1848 unsigned Start = Includes[Indices[i]].Offset;
1848 unsigned Start = Includes[Indices[i]].Offset;
1849 unsigned End = Start + Includes[Indices[i]].Text.size();
1849 unsigned End = Start + Includes[Indices[i]].Text.size();
1852 CursorIndex = Indices[i];
1856 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1856 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1856 while (--i >= 0 && Includes[CursorIndex].Text == Includes[Indices[i]].Text)
1909 return std::tie(Includes[LHSI].Priority, Includes[LHSI].Filename) <
1909 return std::tie(Includes[LHSI].Priority, Includes[LHSI].Filename) <
1910 std::tie(Includes[RHSI].Priority, Includes[RHSI].Filename);
1910 std::tie(Includes[RHSI].Priority, Includes[RHSI].Filename);
1924 return Includes[LHSI].Text == Includes[RHSI].Text;
1924 return Includes[LHSI].Text == Includes[RHSI].Text;
1947 CurrentCategory != Includes[Index].Category)
1950 result += Includes[Index].Text;
1953 CurrentCategory = Includes[Index].Category;
2088 findJavaImportGroup(Style, Imports[i].Identifier));
2092 return std::make_tuple(!Imports[LHSI].IsStatic, JavaImportGroups[LHSI],
2093 Imports[LHSI].Identifier) <
2094 std::make_tuple(!Imports[RHSI].IsStatic, JavaImportGroups[RHSI],
2095 Imports[RHSI].Identifier);
2101 return Imports[LHSI].Text == Imports[RHSI].Text;
2101 return Imports[LHSI].Text == Imports[RHSI].Text;
2105 bool CurrentIsStatic = Imports[Indices.front()].IsStatic;
2112 if (CurrentIsStatic != Imports[Index].IsStatic ||
2116 for (StringRef CommentLine : Imports[Index].AssociatedCommentLines) {
2120 result += Imports[Index].Text;
2121 CurrentIsStatic = Imports[Index].IsStatic;
tools/clang/lib/Format/FormatToken.cpp 116 ExtraSpaces += Format->ColumnSizes[Column] - ItemLengths[Item];
tools/clang/lib/Format/NamespaceEndCommentsFixer.cpp 163 const FormatToken *NamespaceTok = AnnotatedLines[StartLineIndex]->First;
168 NamespaceTok = AnnotatedLines[StartLineIndex - 1]->First;
tools/clang/lib/Format/TokenAnnotator.cpp 2248 Prev->Children[0]->First->MustBreakBefore) ||
3550 llvm::errs() << Tok->FakeLParens[i] << "/";
tools/clang/lib/Format/UnwrappedLineFormatter.cpp 146 return AnnotatedLines[StartLineIndex]->First->getNamespaceToken();
1069 LevelIndentTracker IndentTracker(Style, Keywords, Lines[0]->Level,
tools/clang/lib/Format/UnwrappedLineParser.cpp 2673 if (Comments[i]->OriginalColumn == NextTok->OriginalColumn) {
2680 FormatToken *FormatTok = Comments[i];
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 1092 ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
1100 RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
1197 SourceLocation LocStart = DG[0]->getBeginLoc();
5207 DeclRefExpr *Exp = InnerBlockDeclRefs[i];
5227 if (InnerBlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() ||
5228 InnerBlockDeclRefs[i]->getType()->isObjCObjectPointerType() ||
5229 InnerBlockDeclRefs[i]->getType()->isBlockPointerType())
5230 ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl());
tools/clang/lib/Frontend/Rewrite/RewriteObjC.cpp 931 ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
939 RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
1029 SourceLocation LocStart = DG[0]->getBeginLoc();
4360 DeclRefExpr *Exp = InnerBlockDeclRefs[i];
4380 if (InnerBlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() ||
4381 InnerBlockDeclRefs[i]->getType()->isObjCObjectPointerType() ||
4382 InnerBlockDeclRefs[i]->getType()->isBlockPointerType())
4383 ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl());
tools/clang/lib/Frontend/TextDiagnostic.cpp 275 return m_byteToColumn[n];
281 while (m_byteToColumn[N] == -1)
283 return m_byteToColumn[N];
291 return m_columnToByte[n];
tools/clang/lib/Index/CommentToXML.cpp 986 const AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(Attrs[i]);
988 if (const DeprecatedAttr *DA = dyn_cast<DeprecatedAttr>(Attrs[i])) {
997 else if (const UnavailableAttr *UA = dyn_cast<UnavailableAttr>(Attrs[i])) {
tools/clang/lib/Lex/MacroInfo.cpp 96 const Token &A = ReplacementTokens[i];
97 const Token &B = Other.ReplacementTokens[i];
tools/clang/lib/Lex/ModuleMap.cpp 128 Module *Context = lookupModuleUnqualified(Id[0].first, Mod);
131 Diags.Report(Id[0].second, diag::err_mmap_missing_module_unqualified)
132 << Id[0].first << Mod->getFullModuleName();
139 Module *Sub = lookupModuleQualified(Id[I].first, Context);
142 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
143 << Id[I].first << Context->getFullModuleName()
144 << SourceRange(Id[0].second, Id[I-1].second);
144 << SourceRange(Id[0].second, Id[I-1].second);
2647 OS << Id[I].first;
tools/clang/lib/Lex/PPCaching.cpp 144 const Token LastCachedTok = CachedTokens[CachedLexPos - 1];
tools/clang/lib/Parse/ParseDeclCXX.cpp 262 getCurScope(), InnerNSs[index].InlineLoc, InnerNSs[index].NamespaceLoc,
262 getCurScope(), InnerNSs[index].InlineLoc, InnerNSs[index].NamespaceLoc,
263 InnerNSs[index].IdentLoc, InnerNSs[index].Ident,
263 InnerNSs[index].IdentLoc, InnerNSs[index].Ident,
tools/clang/lib/Sema/DeclSpec.cpp 314 switch (DeclTypeInfo[i].Kind) {
tools/clang/lib/Sema/MultiplexExternalSemaSource.cpp 196 Sources[i]->getMemoryBufferSizes(sizes);
tools/clang/lib/Sema/Sema.cpp 1820 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1822 return FunctionScopes[e];
tools/clang/lib/Sema/SemaCodeComplete.cpp 4357 Results.Ignore(Data.IgnoreDecls[I]);
tools/clang/lib/Sema/SemaDeclCXX.cpp 2790 if (Path[I - 1].Base->isVirtual()) {
2798 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
tools/clang/lib/Sema/SemaInit.cpp 7287 switch (Path[I].Kind) {
7297 if (cast<VarDecl>(Path[I].D)->isImplicit())
7301 return Path[I].E->getSourceRange();
tools/clang/lib/Sema/SemaLookup.cpp 4305 const auto *TI = Types[I];
tools/clang/lib/Sema/SemaOpenMP.cpp 6713 Pair.second[CurrentNestedLoopCount].first,
6714 Pair.second[CurrentNestedLoopCount].second);
tools/clang/lib/Sema/SemaOverload.cpp11675 return Matches[0].second;
11680 return &Matches[0].first;
tools/clang/lib/Sema/SemaTemplate.cpp 3002 if (!Converted[1].getAsType()->isIntegralType(Context)) {
3010 TemplateArgument NumArgsArg = Converted[2];
3032 return SemaRef.CheckTemplateIdType(Converted[0].getAsTemplate(),
3044 TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
3044 TemplateArgument IndexArg = Converted[0], Ts = Converted[1];
tools/clang/lib/Sema/SemaTemplateDeduction.cpp 3395 OriginalCallArg OriginalArg = (*OriginalCallArgs)[I];
tools/clang/lib/Serialization/ASTReader.cpp 1274 for (unsigned I = 0; Record[Idx]; ++I) {
1284 int FID = Record[Idx++];
1290 unsigned NumEntries = Record[Idx++];
1295 unsigned FileOffset = Record[Idx++];
1296 unsigned LineNo = Record[Idx++];
1297 int FilenameID = FileIDs[Record[Idx++]];
1299 = (SrcMgr::CharacteristicKind)Record[Idx++];
1300 unsigned IncludeOffset = Record[Idx++];
1664 Tok.setLength(Record[Idx++]);
1665 if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
1667 Tok.setKind((tok::TokenKind)Record[Idx++]);
1668 Tok.setFlag((Token::TokenFlags)Record[Idx++]);
4721 Metadata.MajorVersion = Record[0];
4722 Metadata.MinorVersion = Record[1];
4724 unsigned BlockNameLen = Record[2];
4725 unsigned UserInfoLen = Record[3];
5690 for (unsigned N = Record[Idx++]; N; --N)
5693 ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
5700 for (unsigned N = Record[Idx++]; N; --N) {
5704 LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
5707 for (unsigned N = Record[Idx++]; N; --N) {
5725 for (unsigned N = Record[Idx++]; N; --N) {
5728 for (unsigned N = Record[Idx++]; N; --N) {
5745 for (unsigned N = Record[Idx++]; N; --N)
5747 for (unsigned N = Record[Idx++]; N; --N)
5769 for (unsigned N = Record[Idx++]; N; --N) {
5772 = static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
5773 bool IsFramework = Record[Idx++];
5774 bool IgnoreSysRoot = Record[Idx++];
5780 for (unsigned N = Record[Idx++]; N; --N) {
5782 bool IsSystemHeader = Record[Idx++];
5789 HSOpts.DisableModuleHash = Record[Idx++];
5790 HSOpts.ImplicitModuleMaps = Record[Idx++];
5791 HSOpts.ModuleMapFileHomeIsCwd = Record[Idx++];
5792 HSOpts.UseBuiltinIncludes = Record[Idx++];
5793 HSOpts.UseStandardSystemIncludes = Record[Idx++];
5794 HSOpts.UseStandardCXXIncludes = Record[Idx++];
5795 HSOpts.UseLibcxx = Record[Idx++];
5810 for (unsigned N = Record[Idx++]; N; --N) {
5812 bool IsUndef = Record[Idx++];
5817 for (unsigned N = Record[Idx++]; N; --N) {
5822 for (unsigned N = Record[Idx++]; N; --N) {
5826 PPOpts.UsePredefines = Record[Idx++];
5827 PPOpts.DetailedRecord = Record[Idx++];
5830 static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
6896 static_cast<ExceptionSpecificationType>(Record[Idx++]);
6899 for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
6962 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++]));
6963 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++]));
6964 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++]));
6965 TL.setModeAttr(Record[Idx++]);
7009 if (Record[Idx++])
7214 TL.setHasBaseTypeAsWritten(Record[Idx++]);
7578 if (Record[Index++]) // bool InfoHasSameExpr.
7591 unsigned NumArgsAsWritten = Record[Index++];
7908 return getGlobalDeclID(F, Record[Idx++]);
8854 PreloadedDeclIDs.push_back(DeclIDs[I]);
8858 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
9119 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
9147 (OverloadedOperatorKind)Record[Idx++]);
9206 unsigned NumTPLists = Record[Idx++];
9220 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
9226 unsigned size = Record[Idx++];
9241 bool hasTemplKeyword = Record[Idx++];
9248 if (Record[Idx++]) // isIdentifier
9253 (OverloadedOperatorKind)Record[Idx++]);
9295 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
9317 if (unsigned NumExpansions = Record[Idx++])
9324 unsigned NumArgs = Record[Idx++];
9342 unsigned NumParams = Record[Idx++];
9348 bool HasRequiresClause = Record[Idx++];
9361 unsigned NumTemplateArgs = Record[Idx++];
9370 unsigned NumDecls = Record[Idx++];
9374 AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
9382 bool isVirtual = static_cast<bool>(Record[Idx++]);
9383 bool isBaseOfClass = static_cast<bool>(Record[Idx++]);
9384 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]);
9385 bool inheritConstructors = static_cast<bool>(Record[Idx++]);
9399 unsigned NumInitializers = Record[Idx++];
9408 CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
9412 IsBaseVirtual = Record[Idx++];
9450 if (/*IsWritten*/Record[Idx++]) {
9451 unsigned SourceOrder = Record[Idx++];
9465 unsigned N = Record[Idx++];
9469 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9495 bool Template = Record[Idx++];
9520 unsigned N = Record[Idx++];
9524 = (NestedNameSpecifier::SpecifierKind)Record[Idx++];
9549 bool Template = Record[Idx++];
9591 unsigned Width = Record[Idx++];
9592 unsigned Scale = Record[Idx++];
9593 uint64_t Tmp = Record[Idx++];
9602 unsigned Kind = Record[Idx++];
9612 static_cast<llvm::APFloatBase::Semantics>(Record[Idx++]));
9625 static_cast<llvm::APFloatBase::Semantics>(Record[Idx++]));
9628 static_cast<llvm::APFloatBase::Semantics>(Record[Idx++]));
9646 unsigned BitWidth = Record[Idx++];
9648 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]);
9655 bool isUnsigned = Record[Idx++];
9668 unsigned Len = Record[Idx++];
9691 unsigned Major = Record[Idx++];
9692 unsigned Minor = Record[Idx++];
9693 unsigned Subminor = Record[Idx++];
tools/clang/lib/Serialization/ASTReaderDecl.cpp 2661 const uint64_t &readInt() { return Record[Idx++]; }
tools/clang/lib/Serialization/GlobalModuleIndex.cpp 752 endian::write<uint32_t>(Out, Data[I], little);
tools/clang/lib/StaticAnalyzer/Checkers/CloneChecker.cpp 122 R->addNote("Similar code here", makeLocation(Group[i], Mgr),
123 Group[i].getSourceRange());
135 VariablePattern PatternA(Group[i]);
138 VariablePattern PatternB(Group[j]);
tools/clang/lib/Tooling/ASTDiff/ASTDiff.cpp 323 getNode(Parent).Children[0] == Cur) {
346 Position += getNode(Siblings[I]).Shift;
347 if (Siblings[I] == Id) {
766 if (!identical(N1.Children[Id], N2.Children[Id]))
766 if (!identical(N1.Children[Id], N2.Children[Id]))
tools/clang/lib/Tooling/Transformer/RewriteRule.cpp 123 assert(hasValidKind(Cases[I].Matcher) &&
125 Buckets[Cases[I].Matcher.getSupportedKind()].emplace_back(I, Cases[I]);
125 Buckets[Cases[I].Matcher.getSupportedKind()].emplace_back(I, Cases[I]);
167 return Rule.Cases[0];
173 return Rule.Cases[i];
tools/clang/tools/clang-diff/ClangDiff.cpp 379 printNodeAsJson(OS, Tree, N.Children[0]);
382 printNodeAsJson(OS, Tree, N.Children[I]);
tools/clang/tools/clang-refactor/TestSupport.cpp 219 TestRanges.GroupedRanges[Group.index()].Ranges[I.index()].Begin);
tools/clang/tools/extra/clang-doc/MDGenerator.cpp 94 Attrs << " \"" << I.AttrKeys[Idx] << "=" << I.AttrValues[Idx] << "\"";
94 Attrs << " \"" << I.AttrKeys[Idx] << "=" << I.AttrValues[Idx] << "\"";
tools/clang/tools/extra/clang-doc/Representation.cpp 255 int D = tolower(Name[I]) - tolower(Other.Name[I]);
255 int D = tolower(Name[I]) - tolower(Other.Name[I]);
tools/clang/tools/extra/clang-tidy/bugprone/BranchCloneCheck.cpp 47 if (!areStatementsIdentical(LHS[i]->stripLabelLikeStatements(),
48 RHS[i]->stripLabelLikeStatements(), Context)) {
tools/clang/tools/extra/clang-tidy/modernize/UseTrailingReturnTypeCheck.cpp 291 if (!SM.isBeforeInTranslationUnit(Tokens[I].T.getLocation(),
296 for (int J = static_cast<int>(I) - 1; J >= 0 && Tokens[J].isQualifier;
298 ReturnTypeRange.setBegin(Tokens[J].T.getLocation());
303 Tokens[I].T.getLocation())) {
304 for (size_t J = I; J < Tokens.size() && Tokens[J].isQualifier; J++)
305 ReturnTypeRange.setEnd(Tokens[J].T.getLocation());
tools/clang/tools/extra/clangd/CodeComplete.cpp 226 return RankedIncludeHeaders[0];
1802 const auto *InsertInclude = Includes.empty() ? nullptr : &Includes[0];
tools/clang/tools/extra/clangd/SemanticHighlighting.cpp 316 uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8) + Bytes[I + 2];
316 uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8) + Bytes[I + 2];
316 uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8) + Bytes[I + 2];
323 uint32_t X = (Bytes[I] << 16);
328 uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8);
328 uint32_t X = (Bytes[I] << 16) + (Bytes[I + 1] << 8);
tools/clang/tools/extra/clangd/unittests/CodeCompleteTests.cpp 68 return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader;
71 return !arg.Includes.empty() && arg.Includes[0].Header == IncludeHeader &&
72 bool(arg.Includes[0].Insertion);
75 return !arg.Includes.empty() && bool(arg.Includes[0].Insertion);
tools/clang/tools/extra/clangd/unittests/DiagnosticsTests.cpp 88 if (arg.Edits[I].range != Fix.Edits[I].range ||
88 if (arg.Edits[I].range != Fix.Edits[I].range ||
89 arg.Edits[I].newText != Fix.Edits[I].newText)
89 arg.Edits[I].newText != Fix.Edits[I].newText)
tools/clang/tools/extra/modularize/ModularizeUtilities.cpp 380 Mod.Headers[clang::Module::HK_Normal][Index]);
388 std::string MissingFile = Mod.MissingHeaders[Index].FileName;
389 SourceLocation Loc = Mod.MissingHeaders[Index].FileNameLoc;
tools/clang/unittests/CodeGen/IRMatchers.h 97 return MatchStack[MatchStack.size() - 1 - Offset];
tools/lld/ELF/Thunks.h 56 Defined *getThunkTargetSym() const { return syms[0]; }
tools/lld/wasm/WriterUtils.cpp 50 s += toString(sig.Returns[0]);
116 writeValueType(os, sig.Returns[0], "result type");
tools/lldb/include/lldb/Utility/RangeMap.h 244 return ((i < m_entries.size()) ? &m_entries[i] : nullptr);
249 const Entry &GetEntryRef(size_t i) const { return m_entries[i]; }
699 return ((i < m_entries.size()) ? &m_entries[i] : nullptr);
888 return ((i < m_entries.size()) ? &m_entries[i] : nullptr);
893 const Entry &GetEntryRef(size_t i) const { return m_entries[i]; }
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.h 58 return m_infos[i].cu;
61 return m_infos[i].die_offset;
64 return m_infos[i].attr.get_attr();
66 dw_attr_t FormAtIndex(uint32_t i) const { return m_infos[i].attr.get_form(); }
tools/lldb/source/Plugins/SymbolFile/NativePDB/CompileUnitIndex.cpp 209 CVType dir_cvt = types.getType(item.m_build_info[0]);
210 CVType file_cvt = types.getType(item.m_build_info[2]);
tools/lldb/source/Symbol/ClangASTContext.cpp 1439 const char *name = template_param_infos.names[i];
1444 if (IsValueParam(template_param_infos.args[i])) {
1448 template_param_infos.args[i].getIntegralType(), parameter_pack,
7216 clang::CXXBasePathElement elem = (*path)[e];
tools/lldb/unittests/tools/lldb-server/tests/MessageObjects.cpp 258 auto RegValOr = parseRegisterValue(RegInfos[Reg], Val[0], Endian);
tools/llvm-diff/DiffLog.cpp 27 Value *LogBuilder::getArgument(unsigned I) const { return Arguments[I]; }
46 return (Diff[I].first ? (Diff[I].second ? DC_match : DC_left)
46 return (Diff[I].first ? (Diff[I].second ? DC_match : DC_left)
49 Instruction *DiffLogBuilder::getLeft(unsigned I) const { return Diff[I].first; }
50 Instruction *DiffLogBuilder::getRight(unsigned I) const { return Diff[I].second; }
tools/llvm-dwarfdump/Statistics.cpp 260 uint64_t FirstDef = List->Entries[0].Begin;
tools/llvm-exegesis/lib/CodeTemplate.cpp 40 return VariableValues[Var.getIndex()];
48 return getValueFor(Instr.Variables[Op.getVariableIndex()]);
tools/llvm-exegesis/lib/MCInstrDescView.cpp 27 return TiedOperands[0];
173 return Operands[PrimaryOperandIndex];
tools/llvm-exegesis/lib/SnippetGenerator.cpp 179 static auto randomElement(const C &Container) -> decltype(Container[0]) {
182 return Container[randomIndex(Container.size() - 1)];
tools/llvm-exegesis/lib/X86/Target.cpp 200 Instr.Operands[kDestOp].getRegisterAliasing().sourceBits();
203 Instr.Operands[kBaseOp].getRegisterAliasing().sourceBits();
206 Instr.Operands[kIndexOp].getRegisterAliasing().sourceBits();
317 Instr.Operands[0].getRegisterAliasing().sourceBits();
tools/llvm-mca/Views/BottleneckAnalysis.cpp 52 unsigned ProcResID = ResIdx2ProcResID[Index];
198 const DGNode &N = Nodes[I];
279 Seq.resize(Nodes[IID].Depth);
281 const DGNode &N = Nodes[IID];
tools/llvm-mca/Views/BottleneckAnalysis.h 132 unsigned Index = ProcResID2ResourceUsersIndex[ProcResID];
133 return ResourceUsers[Index + UnitID];
166 unsigned ProcResID = ResIdx2ProcResID[Index];
tools/llvm-mca/Views/DispatchStatistics.cpp 68 printStalls(SS, HWStalls[HWStallEvent::RegisterFileStall], NumCycles);
70 printStalls(SS, HWStalls[HWStallEvent::RetireControlUnitStall], NumCycles);
72 printStalls(SS, HWStalls[HWStallEvent::SchedulerQueueFull], NumCycles);
74 printStalls(SS, HWStalls[HWStallEvent::LoadQueueFull], NumCycles);
76 printStalls(SS, HWStalls[HWStallEvent::StoreQueueFull], NumCycles);
78 printStalls(SS, HWStalls[HWStallEvent::DispatchGroupStall], NumCycles);
tools/llvm-mca/Views/RegisterFileStatistics.cpp 109 const RegisterFileUsage &GlobalUsage = PRFUsage[0];
116 const RegisterFileUsage &RFU = PRFUsage[I];
139 const MoveEliminationInfo &MEI = MoveElimInfo[I];
tools/llvm-objdump/MachODump.cpp 8011 Encoding = CommonEncodings[EncodingIdx];
tools/llvm-rc/ResourceFileWriter.cpp 1470 if (!FixedData.IsTypePresent[(int)Type])
tools/polly/include/polly/ScopInfo.h 297 return DimensionSizes[Dim];
307 return DimensionSizesPw[Dim];
901 const SCEV *getSubscript(unsigned Dim) const { return Subscripts[Dim]; }
tools/polly/lib/Analysis/ScopInfo.cpp 1247 return NestLoops[Dimension];
unittests/Analysis/VectorFunctionABITest.cpp 51 EXPECT_EQ(VFS.Shape.Parameters[0], VFParameter({0, VFParamKind::Vector, 0}));
52 EXPECT_EQ(VFS.Shape.Parameters[1],
54 EXPECT_EQ(VFS.Shape.Parameters[2],
56 EXPECT_EQ(VFS.Shape.Parameters[3],
58 EXPECT_EQ(VFS.Shape.Parameters[4],
unittests/tools/llvm-exegesis/X86/SnippetGeneratorTest.cpp 90 EXPECT_THAT(IT.VariableValues[0], IsInvalid()) << "Immediate is not set";
113 EXPECT_THAT(IT.VariableValues[0], IsInvalid()) << "Operand 1 is not set";
114 EXPECT_THAT(IT.VariableValues[1], IsInvalid()) << "Operand 2 is not set";
216 EXPECT_THAT(IT.VariableValues[0], IsInvalid());
217 EXPECT_THAT(IT.VariableValues[1], IsInvalid());
264 AllDefRegisters.insert(IT.VariableValues[0].getReg());
295 EXPECT_THAT(IT.VariableValues[0].getReg(), Not(IT.VariableValues[1].getReg()))
295 EXPECT_THAT(IT.VariableValues[0].getReg(), Not(IT.VariableValues[1].getReg()))
297 EXPECT_THAT(IT.VariableValues[0].getReg(), Not(IT.VariableValues[2].getReg()))
297 EXPECT_THAT(IT.VariableValues[0].getReg(), Not(IT.VariableValues[2].getReg()))
299 EXPECT_THAT(IT.VariableValues[3], IsInvalid());
330 EXPECT_EQ(IT.VariableValues[2].getImm(), 1);
331 EXPECT_EQ(IT.VariableValues[3].getReg(), 0u);
332 EXPECT_EQ(IT.VariableValues[4].getImm(), 0);
333 EXPECT_EQ(IT.VariableValues[5].getReg(), 0u);
utils/TableGen/AsmMatcherEmitter.cpp 624 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
624 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
626 if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
626 if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
665 if (AsmOperands[i].Class->Kind != RHS.AsmOperands[i].Class->Kind ||
665 if (AsmOperands[i].Class->Kind != RHS.AsmOperands[i].Class->Kind ||
666 AsmOperands[i].Class->Kind == ClassInfo::Token)
667 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class ||
667 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class ||
668 *RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
668 *RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
676 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
676 if (*AsmOperands[i].Class < *RHS.AsmOperands[i].Class)
678 if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
678 if (*RHS.AsmOperands[i].Class < *AsmOperands[i].Class)
807 const AsmOperand &Op = AsmOperands[i];
2906 OS << '_' << II.RequiredFeatures[i]->TheDef->getName();
utils/TableGen/CodeGenDAGPatterns.cpp 2959 InNodes[0]->getNumTypes() == 1 &&
2961 MadeChange |= Node->UpdateNodeType(0, InNodes[0]->getExtType(0),
utils/TableGen/CodeGenRegisters.cpp 581 CodeGenRegister *SR = ExplicitSubRegs[i];
1307 Name += Parts[i]->getName();
1308 Size += Parts[i]->Size;
1309 if (Parts[i]->Offset != (LastOffset + LastSize))
1311 LastOffset = Parts[i]->Offset;
1312 LastSize = Parts[i]->Size;
2430 dbgs() << ' ' << RegUnits[Unit].Roots[0]->getName();
utils/TableGen/CodeGenRegisters.h 357 return VTs[VTNum];
698 const RegUnit &getRegUnit(unsigned RUID) const { return RegUnits[RUID]; }
utils/TableGen/DAGISelMatcher.cpp 110 return Operands[i];
296 OS << ' ' << getEnumName(VTs[i]);
299 OS << Operands[i] << ' ';
utils/TableGen/DAGISelMatcher.h 194 const Matcher *getChild(unsigned i) const { return Children[i]; }
480 const SDNodeInfo &getCaseOpcode(unsigned i) const { return *Cases[i].first; }
482 const Matcher *getCaseMatcher(unsigned i) const { return Cases[i].second; }
530 MVT::SimpleValueType getCaseType(unsigned i) const { return Cases[i].first; }
532 const Matcher *getCaseMatcher(unsigned i) const { return Cases[i].second; }
916 return ChainNodes[i];
1012 return VTs[i];
1018 return Operands[i];
1100 unsigned getResult(unsigned R) const { return Results[R]; }
utils/TableGen/DFAEmitter.cpp 309 OS << "using " << Name << "Action = " << ActionTypes[0] << ";\n";
utils/TableGen/FastISelEmitter.cpp 141 if (Operands[i].isImm() && Operands[i].getImmCode() != 0)
141 if (Operands[i].isImm() && Operands[i].getImmCode() != 0)
151 if (!Operands[i].isImm())
152 Result.Operands.push_back(Operands[i]);
294 if (Operands[i].isReg()) {
296 } else if (Operands[i].isImm()) {
298 } else if (Operands[i].isFP()) {
319 if (Operands[i].isReg()) {
322 } else if (Operands[i].isImm()) {
325 } else if (Operands[i].isFP()) {
336 if (Operands[i].isReg()) {
338 } else if (Operands[i].isImm()) {
340 } else if (Operands[i].isFP()) {
362 Operands[i].printManglingSuffix(OS, ImmPredicates, StripImmCodes);
369 Operands[i].printManglingSuffix(OS, ImmPredicates, StripImmCodes);
utils/TableGen/RegisterInfoEmitter.cpp 803 const MaskRolPair &P = Sequence[p];
utils/TableGen/SearchableTableEmitter.cpp 198 if (Index.Fields[0].Enum) {
199 Record *EnumEntry = Rec->getValueAsDef(Index.Fields[0].Name);
200 return Index.Fields[0].Enum->EntryMap[EnumEntry]->second;
203 return getInt(Rec, Index.Fields[0].Name);
362 (Index.Fields[0].Enum || isa<BitsRecTy>(Index.Fields[0].RecType))) {
362 (Index.Fields[0].Enum || isa<BitsRecTy>(Index.Fields[0].RecType))) {
374 OS << " size_t Idx = " << Index.Fields[0].Name << ";\n";
386 const GenericField &Field = Index.Fields[0];