Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "ret", ";" ]

[ "_", "_", "builtin_aarch64_simd_oi", "_", "_", "o", ";", "_", "_", "o", "=", "_", "_", "builtin_aarch64_ld2v2si", "(", "(", "const", "_", "_", "builtin_aarch64_simd_si", "*", ")", "_", "_", "a", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "uint32x2_t", ")", "_", "_", "builtin_aarch64_get_dregoiv2si", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";", "ret", ".", "val", "[", "<NUM_LIT>", "]", "=", "(", "uint32x2_t", ")", "_", "_", "builtin_aarch64_get_dregoiv2si", "(", "_", "_", "o", ",", "<NUM_LIT>", ")", ";", "return" ]

[ "<STR_LIT>", ")" ]

[ "(", "UNSPEC_AESIMC", "<STR_LIT>", ")", "(", "UNSPEC_AESD", "<STR_LIT>", ")", "(", "UNSPEC_AESE", "<STR_LIT>", ")", "(", "UNSPEC_SHA1SU1", "<STR_LIT>", ")", "(", "UNSPEC_SHA256SU0", "<STR_LIT>", ")", "(", "UNSPEC_SHA1C", "<STR_LIT>", ")", "(", "UNSPEC_SHA1M", "<STR_LIT>", ")", "(", "UNSPEC_SHA1P", "<STR_LIT>", ")", "(", "UNSPEC_SHA1SU0", "<STR_LIT>", ")", "(", "UNSPEC_SHA256H" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "<FIXS>", "{", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE_INNER", "(", "MODE", ">", "mode", ")", ")", "=", "=", "<NUM_LIT>", ")", "return", "<STR_LIT>", "return", "<STR_LIT>", "}", "<FIXE>" ]

[ "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "x86_64_sign_extended_value", "(", "value", ")", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "int", "<BUGS>", "x86_64_sign_extended_value", "(", "value", ",", "allow_rip", ")", "<BUGE>", "rtx", "value", ";", "<BUGS>", "int", "allow_rip", ";", "<BUGE>", "{", "switch", "(", "GET_CODE", "(", "value", ")", ")", "{" ]

[ "const", "char", "*", "output_387_reg_move", "(", "rtx", "insn", ",", "rtx", "*", "operands", ")", "{", "if", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "if", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&&", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "{", "if", "(", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "FIRST_STACK_REG", ")", "return", "output_387_ffreep", "(", "operands", ",", "<NUM_LIT>", ")", ";", "return", "<STR_LIT>", "fstp\\t%y0", "<STR_LIT>", ";", "}", "if", "(", "STACK_TOP_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "return", "<STR_LIT>", "fld%Z1\\t%y1", "<STR_LIT>", ";", "return", "<STR_LIT>", "fst\\t%y0", "<STR_LIT>", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", "{", "gcc_assert", "(", "REG_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "if", "(", "find_regno_note", "(", "insn", ",", "REG_DEAD", ",", "REGNO", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")", "return", "<STR_LIT>", "fstp%Z0\\t%y0", "<STR_LIT>", ";", "else", "{", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "XFmode", ")", "return", "<STR_LIT>", "fstp%Z0\\t%y0\\n\\tfld%Z0\\t%y0", "<STR_LIT>", ";", "else", "return", "<STR_LIT>", "fst%Z0\\t%y0", "<STR_LIT>", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "}" ]

[ "Output", "code", "to", "perform", "an", "x87", "FP", "register", "move", ",", "from", "OPERANDS", "[", "1", "]", "to", "OPERANDS", "[", "0", "]", "." ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "if", "(", "!", "SearchForUse", "(", "Start", ",", "MBB", "->", "end", "(", ")", ",", "ARM", "::", "LR", ")", ")", "return", "Start", ";" ]

[ "if", "(", "PredLRDef", "&&", "!", "IsMoveLR", "(", "PredLRDef", ",", "CountReg", ")", ")", "PredLRDef", "=", "nullptr", ";", "MachineInstr", "*", "SuccLRDef", "=", "SearchForDef", "(", "Start", ",", "MBB", "->", "end", "(", ")", ",", "ARM", "::", "LR", ")", ";", "if", "(", "SuccLRDef", "&&", "!", "IsMoveLR", "(", "SuccLRDef", ",", "CountReg", ")", ")", "SuccLRDef", "=", "nullptr", ";", "if", "(", "SuccLRDef", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "(", "SuccLRDef", ")", ";", "if", "(", "!", "SearchForDef", "(", "Start", ",", "End", ",", "CountReg", ")", ")", "{", "return", "SuccLRDef", ";", "}", "else", "SuccLRDef", "=", "nullptr", ";", "}", "if", "(", "PredLRDef", ")", "{", "MachineBasicBlock", "::", "reverse_iterator", "End", "(", "PredLRDef", ")", ";", "if", "(", "!", "SearchForDef", "(", "Start", ",", "End", ",", "CountReg", ")", ")", "{", "return", "PredLRDef", ";", "}", "else", "PredLRDef", "=", "nullptr", ";", "}", "if", "(", "Start", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "ARM", "::", "LR", ")", "return", "Start", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "LivePhysRegs", "LiveRegs", "(", "*", "TRI", ")", ";", "LiveRegs", ".", "addLiveOuts", "(", "*", "MBB", ")", ";", "if", "(", "LiveRegs", ".", "contains", "(", "ARM", "::", "LR", ")", ")", "return", "nullptr", ";" ]

[ "}" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicateLate", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "USR_OVF", "]", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ ")" ]

[ "(", "and", "(", "match_code", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", ")" ]

[ "<STR_LIT>", ";" ]

[ "return", "<STR_LIT>", "X86 FP_REG_KILL inserter" ]

[ "<STR_LIT>", ")" ]

[ "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")" ]

[ "int", "fp_mov_p", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_DOUBLE", ")", "{", "long", "i", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op", ")", ",", "i", ")", ";", "return", "SPARC_SIMM13_P", "(", "i", ")", ";", "}", "return", "<NUM_LIT>", ";", "}" ]

[ "Nonzero", "if", "OP", "is", "a", "floating", "point", "constant", "which", "can", "be", "loaded", "into", "an", "integer", "register", "using", "a", "single", "mov", "instruction", "." ]

[ ")", "{" ]

[ "static", "scalar_int_mode", "s390_libgcc_shift_count_mode", "(", "void" ]

[ "}" ]

[ "def", "_4H", ":", "N2VShR_Narrow", "<", "<NUM_LIT>", ",", "u", ",", "opcode", ",", "asmop", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "shr_imm16", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "(", "ashiftrt", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "neg", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]" ]

[ "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<FIXE>" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", "<BUGE>", ")", "(", "define_insn", "<STR_LIT>" ]

[ ")", ";" ]

[ "bool", "isLegalMaskedLoad", "(", "Type", "*", "DataType", ")", "{", "return", "ST", "->", "hasSVE", "(" ]

[ "return", "MBB", ".", "erase", "(", "I", ")", ";" ]

[ "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "Op", "=", "IsDestroy", "?", "AMDGPU", "::", "S_SUB_U32", ":", "AMDGPU", "::", "S_ADD_U32", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "<NUM_LIT>", ")", "{", "llvm_unreachable", "(", "<STR_LIT>", "is this used?", "<STR_LIT>", ")", ";", "}" ]

[ "<NUM_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ">", ";" ]

[ "def", "MVE_v4s32", ":", "MVEVectorVTInfo", "<", "v4i32", ",", "v2i64", ",", "v4i1", ",", "v4i1", "," ]

[ "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=" ]

[ ";" ]

[ "errs", "(", ")", "<<", "<STR_LIT>", "XNCMISelAddressMode ", "<STR_LIT>", "<<", "this", "<<", "'", "\\n", "'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "<NUM_LIT>", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "Base.Reg ", "<STR_LIT>", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", " Base.FrameIndex ", "<STR_LIT>", "<<", "Base", ".", "FrameIndex", "<<", "'", "\\n", "'", ";", "}", "errs", "(", ")", "<<", "<STR_LIT>", " Disp ", "<STR_LIT>", "<<", "Disp", "<<", "'", "\\n", "'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "<STR_LIT>", "GV ", "<STR_LIT>" ]

[ "return", "true", ";" ]

[ "const", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "G_SEXTLOAD", ")", "{", "auto", "WideLoad", "=", "B", ".", "buildLoadFromOffset", "(", "S32", ",", "PtrReg", ",", "*", "MMO", ",", "<NUM_LIT>", ")", ";", "B", ".", "buildSExtInReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "WideLoad", ",", "MemSize", ")", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "AMDGPU", "::", "G_ZEXTLOAD", ")", "{", "auto", "WideLoad", "=", "B", ".", "buildLoadFromOffset", "(", "S32", ",", "PtrReg", ",", "*", "MMO", ",", "<NUM_LIT>", ")", ";", "B", ".", "buildZExtInReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "WideLoad", ",", "MemSize", ")", ";", "}", "else", "B", ".", "buildLoadFromOffset", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "PtrReg", ",", "*", "MMO", ",", "<NUM_LIT>", ")", ";", "}", "else", "{", "if", "(", "MMO", "->", "getAlign", "(", ")", "<", "Align", "(", "<NUM_LIT>", ")", ")", "{", "LegalizerHelper", "Helper", "(", "B", ".", "getMF", "(", ")", ",", "ApplyBank", ",", "B", ")", ";", "LLT", "Part64", ",", "Part32", ";", "std", "::", "tie", "(", "Part64", ",", "Part32", ")", "=", "splitUnequalType", "(", "LoadTy", ",", "<NUM_LIT>", ")", ";", "if", "(", "Helper", ".", "reduceLoadStoreWidth", "(", "cast", "<", "GAnyLoad", ">", "(", "MI", ")", ",", "<NUM_LIT>", ",", "Part64", ")", "!=", "LegalizerHelper", "::", "Legalized", ")", "return", "false", ";", "return", "true", ";", "}", "LLT", "WiderTy", "=", "widen96To128", "(", "LoadTy", ")", ";", "auto", "WideLoad", "=", "B", ".", "buildLoadFromOffset", "(", "WiderTy", ",", "PtrReg", ",", "*", "MMO", ",", "<NUM_LIT>", ")", ";", "if", "(", "WiderTy", ".", "isScalar", "(", ")", ")", "{", "B", ".", "buildTrunc", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "WideLoad", ")", ";", "}", "else", "{", "B", ".", "buildDeleteTrailingVectorElements", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "WideLoad", ")", ";", "}", "}", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "if", "(", "LoadSize", "<=", "MaxNonSmrdLoadSize", ")", "return", "false", ";", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "DefRegs", "(", "OpdMapper", ".", "getVRegs", "(", "<NUM_LIT>", ")", ")", ";", "SmallVector", "<", "Register", ",", "<NUM_LIT>", ">", "SrcRegs", "(", "OpdMapper", ".", "getVRegs", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "SrcRegs", ".", "empty", "(", ")", ")", "SrcRegs", ".", "push_back", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "assert", "(", "LoadSize", "%", "MaxNonSmrdLoadSize", "==", "<NUM_LIT>", ")", ";", "Register", "BasePtrReg", "=", "SrcRegs", "[", "<NUM_LIT>", "]", ";", "LLT", "PtrTy", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "MRI", ".", "setType", "(", "BasePtrReg", ",", "PtrTy", ")", ";", "unsigned", "NumSplitParts", "=", "LoadTy", ".", "getSizeInBits", "(", ")", "/", "MaxNonSmrdLoadSize", ";", "const", "LLT", "LoadSplitTy", "=", "LoadTy", ".", "divide", "(", "NumSplitParts", ")", ";", "ApplyRegBankMapping", "O", "(", "B", ",", "*", "this", ",", "MRI", ",", "&", "AMDGPU", "::", "VGPRRegBank", ")", ";", "LegalizerHelper", "Helper", "(", "B", ".", "getMF", "(", ")", ",", "O", ",", "B", ")", ";", "if", "(", "LoadTy", ".", "isVector", "(", ")", ")", "{", "if", "(", "Helper", ".", "fewerElementsVector", "(", "MI", ",", "<NUM_LIT>", ",", "LoadSplitTy", ")", "!=", "LegalizerHelper", "::", "Legalized", ")", "return", "false", ";", "}", "else", "{", "if", "(", "Helper", ".", "narrowScalar", "(", "MI", ",", "<NUM_LIT>", ",", "LoadSplitTy", ")", "!=", "LegalizerHelper", "::", "Legalized", ")", "return", "false", ";", "}", "MRI", ".", "setRegBank", "(", "DstReg", ",", "AMDGPU", "::", "VGPRRegBank", ")", ";" ]

[ "ARM Loops: Found instruction using vpr: ", "<STR_LIT>", "<<", "*", "MI", ")", ";" ]

[ "}", "if", "(", "isVCTP", "(", "MI", ")", ")", "{", "if", "(", "VCTP", ")", "{", "if", "(", "!", "VCTP", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isIdenticalTo", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", "||", "!", "RDA", ".", "hasSameReachingDef", "(", "VCTP", ",", "MI", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found VCTP with a different reaching ", "<STR_LIT>", "<STR_LIT>", "definition from the main VCTP", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found secondary VCTP: ", "<STR_LIT>", "<<", "*", "MI", ")", ";", "SecondaryVCTPs", ".", "insert", "(", "MI", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "ARM Loops: Found 'main' VCTP: ", "<STR_LIT>", "<<", "*", "MI", ")", ";", "VCTP", "=", "MI", ";", "}", "}", "else", "if", "(", "isVPTOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "MI", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "MVE_VPST", ")", "{", "assert", "(", "MI", "->", "findRegisterDefOperandIdx", "(", "ARM", "::", "VPR", ")", "!=", "-", "<NUM_LIT>", "&&", "<STR_LIT>", "VPT does not implicitly define VPR?!", "<STR_LIT>", ")", ";", "CurrentPredicate", ".", "clear", "(", ")", ";", "CurrentPredicate", ".", "insert", "(", "MI", ")", ";", "}", "VPTBlocks", ".", "emplace_back", "(", "MI", ",", "CurrentPredicate", ")", ";", "CurrentBlock", "=", "&", "VPTBlocks", ".", "back", "(", ")", ";", "return", "true", ";", "}", "bool", "IsUse", "=", "false", ";", "bool", "IsDef", "=", "false", ";", "for", "(", "int", "i", "=", "MI", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "--", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "i", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "ARM", "::", "VPR", ")", "continue", ";", "if", "(", "MO", ".", "isDef", "(", ")", ")", "{", "CurrentPredicate", ".", "insert", "(", "MI", ")", ";", "IsDef", "=", "true", ";", "}", "else", "if", "(", "ARM", "::", "isVpred", "(", "MCID", ".", "OpInfo", "[", "i", "]", ".", "OperandType", ")", ")", "{", "CurrentBlock", "->", "addInst", "(", "MI", ",", "CurrentPredicate", ")", ";", "IsUse", "=", "true", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>" ]

[ "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x8_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "poly16x8x2_t", "_", "_", "rv", ";", "_", "_", "rv", ".", "val", "[", "<NUM_LIT>", "]", "=", "_", "_", "builtin_shuffle", "(", "_", "_", "a", ",", "_", "_", "b", ",", "(", "uint16x8_t", ")", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ")", ";" ]

[ "}" ]

[ "reportParseError", "(", "<STR_LIT>", "unexpected token, expected end of statement", "<STR_LIT>", ")", ";", "return", "false", ";", "}", "AssemblerOptions", ".", "back", "(", ")", "->", "setMacro", "(", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";" ]

[ "{", "CTL_HW", ",", "HW_CACHELINE", "}", ";" ]

[ "unsigned", "l1_sizekb", ",", "l1_line", ",", "l1_assoc", ",", "l2_sizekb", ";", "size_t", "len", "=", "<NUM_LIT>", ";", "static", "int", "l1_size_name", "[", "<NUM_LIT>", "]", "=", "{", "CTL_HW", ",", "HW_L1DCACHESIZE", "}", ";", "static", "int", "l1_line_name", "[", "<NUM_LIT>", "]", "=" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_subh_h16_sat_hh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_779080bf", ",", "TypeALU64", ">", ",", "Enc_bd6011", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "prefersSlot3", "=" ]

[ "<FIXS>", "output_asm_insn", "(", "MOTOROLA", "?", "<STR_LIT>", "cmp%.l %2,%0\\n\\tjbne %l4\\n\\tcmp%.l %3,%1", "<STR_LIT>", ":", "<STR_LIT>", "cmp%.l %2,%0\\n\\tjne %l4\\n\\tcmp%.l %3,%1", "<STR_LIT>", ",", "loperands", ")", ";", "<FIXE>", "<FIXS>", "output_asm_insn", "(", "<STR_LIT>", "cmp%.w #0,%0", "<STR_LIT>", ",", "loperands", ")", ";", "<FIXE>" ]

[ "loperands", "[", "<NUM_LIT>", "]", "=", "gen_label_rtx", "(", ")", ";", "if", "(", "operand2", "!=", "const0_rtx", ")", "{", "<BUGS>", "output_asm_insn", "(", "MOTOROLA", "?", "<STR_LIT>", "cmp%.l %2,%0\\n\\tjbne %l4\\n\\tcmp%.l %3,%1", "<STR_LIT>", ":", "<STR_LIT>", "cmp%.l %2,%0\\n\\tjne %l4\\n\\tcmp%.l %3,%1", "<STR_LIT>", ",", "loperands", ")", ";", "<BUGE>", "}", "else", "{", "if", "(", "TARGET_68020", "||", "TARGET_COLDFIRE", "||", "!", "ADDRESS_REG_P", "(", "loperands", "[", "<NUM_LIT>", "]", ")", ")", "output_asm_insn", "(", "<STR_LIT>", "tst%.l %0", "<STR_LIT>", ",", "loperands", ")", ";", "else", "<BUGS>", "{", "output_asm_insn", "(", "<STR_LIT>", "cmp%.w #0,%0", "<STR_LIT>", ",", "loperands", ")", ";", "}", "<BUGE>", "output_asm_insn", "(", "MOTOROLA", "?", "<STR_LIT>", "jbne %l4", "<STR_LIT>", ":", "<STR_LIT>", "jne %l4", "<STR_LIT>", ",", "loperands", ")", ";" ]

[ "unsigned", "RV16KInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "<NUM_LIT>", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isUnconditionalBranch", "(", ")", "&&", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "<NUM_LIT>", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", ")", "return", "<NUM_LIT>", ";", "--", "I", ";", "if", "(", "!", "I", "->", "getDesc", "(", ")", ".", "isConditionalBranch", "(", ")", ")", "return", "<NUM_LIT>", ";", "I", "->", "eraseFromParent", "(", ")", ";", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "+=", "getInstSizeInBytes", "(", "*", "I", ")", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "}" ]

[ "MIB", ".", "addReg", "(", "X86", "::", "RAX", ",", "RegState", "::", "ImplicitDefine", ")", ".", "addRegMask", "(", "RegMask", ")", ";", "}", "else", "if", "(", "F", "->", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOV32rm", ")", ",", "X86", "::", "EAX", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addGlobalAddress", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getGlobal", "(", ")", ",", "<NUM_LIT>", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getTargetFlags", "(", ")", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "CALL32m", ")", ")", ";", "addDirectMem", "(", "MIB", ",", "X86", "::", "EAX", ")", ";", "MIB", ".", "addReg", "(", "X86", "::", "EAX", ",", "RegState", "::", "ImplicitDefine", ")", ".", "addRegMask", "(", "RegMask", ")", ";", "}", "else", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "MOV32rm", ")", ",", "X86", "::", "EAX", ")", ".", "addReg", "(", "TII", "->", "getGlobalBaseReg", "(", "F", ")", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ".", "addGlobalAddress", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getGlobal", "(", ")", ",", "<NUM_LIT>", ",", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getTargetFlags", "(", ")", ")", ".", "addReg", "(", "<NUM_LIT>", ")", ";", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "X86", "::", "CALL32m", ")", ")", ";", "addDirectMem", "(", "MIB", ",", "X86", "::", "EAX", ")", ";", "MIB", ".", "addReg", "(", "X86", "::", "EAX", ",", "RegState", "::", "ImplicitDefine", ")", ".", "addRegMask", "(", "RegMask", ")", ";" ]

[ "MIB", ".", "addImm", "(", "Enc", ")", ";" ]

[ "assert", "(", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_CONSTANT", "&&", "<STR_LIT>", "Expected G_CONSTANT", "<STR_LIT>", ")", ";", "uint64_t", "CstVal", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getCImm", "(", ")", "->", "getZExtValue", "(", ")", ";", "uint64_t", "Enc", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "CstVal", ",", "<NUM_LIT>", ")", ";" ]

[ "v8hi", ")", "_", "mm_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_add_epi16", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_paddw128_mask", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "B", ",", "(", "_", "_" ]

[ "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "II", ".", "ImplicitDefs", "[", "<NUM_LIT>", "]", ")", ")", ";" ]

[ "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "TargetInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "<NUM_LIT>", ")", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Imm", ")", ")", ";", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Imm", ")", ")", ";" ]

[ "EXEC", ",", "false", ",", "true", ")", ")", ";" ]

[ "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "COPY", ":", "if", "(", "TII", "->", "isVGPRCopy", "(", "MI", ")", "&&", "!", "MI", ".", "readsRegister", "(", "AMDGPU", "::", "EXEC", ",", "TRI", ")", ")", "{", "MI", ".", "addOperand", "(", "MF", ",", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::" ]

[ "A", ",", "_", "_", "m128", "_", "_", "B", ")", "{" ]

[ "static", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "always_inline__", ")", ")", "_", "mm_or_ps", "(", "_", "_", "m128", "_", "_" ]

[ "B", ",", "-", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_fnmsub_pd", "(", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ",", "_", "_", "m512d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmaddpd512_mask", "(", "-", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_" ]

[ "<FIXS>", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_n_flash", ")", "<FIXE>" ]

[ "if", "(", "reason", ")", "{", "<BUGS>", "if", "(", "avr_addrspace", "[", "as", "]", ".", "segment", ">=", "avr_current_device", "->", "n_flash", ")", "<BUGE>", "{", "if", "(", "TYPE_P", "(", "node", ")", ")", "error", "(", "<STR_LIT>", "%qT uses address space %qs beyond flash of %qs", "<STR_LIT>", "," ]

[ "assert", "(", "none_of", "(", "Preds", ",", "[", "=", "]", "(", "SIScheduleBlock", "*", "P", ")", "{", "return", "SuccID", "==", "P", "->", "getID", "(", ")", ";", "}", ")", "&&", "<STR_LIT>", "Loop in the Block Graph!", "<STR_LIT>", ")", ";" ]

[ "}", "}", "if", "(", "Succ", "->", "isHighLatencyBlock", "(", ")", ")", "++", "NumHighLatencySuccessors", ";", "Succs", ".", "emplace_back", "(", "Succ", ",", "Kind", ")", ";" ]

[ "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "<STR_LIT>", "Branch Coalescing", "<STR_LIT>", ";", "}" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "}" ]

[ "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";" ]

[ "<NUM_LIT>", ",", "<NUM_LIT>", "]", ";" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";", "let", "ResourceCycles", "=", "[", "<NUM_LIT>", "," ]

[ "<STR_LIT>", ")" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_test", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_operand", "<NUM_LIT>" ]

[ "<FIXS>", "return", "false", ";", "<FIXE>" ]

[ "SmallVectorImpl", "MachineCombinerPattern", ">", "&", "Patterns", ")", "{", "if", "(", "!", "isCombineInstrCandidateFP", "(", "Root", ")", ")", "<BUGS>", "return", "<NUM_LIT>", ";", "<BUGE>", "MachineBasicBlock", "&", "MBB", "=", "*", "Root", ".", "getParent", "(", ")", ";", "bool", "Found", "=", "false", ";" ]

[ "}" ]

[ "MachineBasicBlock", "::", "iterator", "NI", "=", "std", "::", "next", "(", "I", ")", ";", "TII", "->", "insertNoop", "(", "MBB", ",", "NI", ")", ";" ]

[ "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{" ]

[ "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SmallVector", "<", "const", "ValueMapping", "*", ",", "<NUM_LIT>", ">", "OpdsMapping", "(", "MI", ".", "getNumOperands", "(", ")", ")", ";" ]

[ "=", "<NUM_LIT>", ";" ]

[ "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "Addr", ".", "Base", ".", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "Addr", ".", "Base", ".", "Reg", "=", "ResultReg", ";", "Addr", ".", "BaseType", "=", "Address", "::", "RegBase", ";", "}", "if", "(", "needsLowering", ")", "{", "Addr", ".", "Base", ".", "Reg", "=", "fastEmit_ri_", "(", "MVT", "::", "i32", ",", "ISD", "::", "ADD", ",", "Addr", ".", "Base", ".", "Reg", ",", "Addr", ".", "Offset", ",", "MVT", "::", "i32", ")", ";", "Addr", ".", "Offset" ]

[ "<FIXS>", "int", "fsize", "=", "(", "size", "+", "STACK_BOUNDARY", "/", "<NUM_LIT>", "-", "<NUM_LIT>", ")", "&", "-", "STACK_BOUNDARY", "/", "<NUM_LIT>", ";", "<FIXE>" ]

[ "{", "register", "int", "regno", ";", "register", "int", "mask", "=", "<NUM_LIT>", ";", "<BUGS>", "int", "fsize", "=", "(", "size", "+", "<NUM_LIT>", ")", "&", "-", "<NUM_LIT>", ";", "<BUGE>", "int", "nregs", ";", "int", "offset", ";", "int", "idx", ";" ]

[ "list", "<", "dag", ">", "Pattern", "=", "[", "]", ";" ]

[ "class", "MSA_CBRANCH_DESC_BASE", "<", "string", "instr_asm", ",", "RegisterOperand", "ROWD", ">", "{", "dag", "OutOperandList", "=", "(", "outs", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWD", ":", "$", "wt", ",", "brtarget", ":", "$", "offset", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm", ",", "<STR_LIT>", ")", ";" ]

[ "}" ]

[ "def", "VMOVSR", ":", "AVConv4I", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "SPR", ":", "$", "Sn", ")", ",", "(", "ins", "GPR", ":", "$", "Rt", ")", ",", "IIC_fpMOVIS", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "SPR", ":", "$", "Sn", ",", "(", "bitconvert", "GPR", ":", "$", "Rt", ")", ")", "]", ">", ",", "Requires", "<", "[", "HasFPRegs", ",", "UseVMOVSR", "]", ">", ",", "Sched", "<", "[", "WriteFPMOV", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Sn", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Sn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Sn", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "D", "=", "VFPNeonDomain", ";" ]

[ "(", ")", "{" ]

[ "FunctionPass", "*", "llvm", "::", "createPPCExpandAtomicPseudoPass" ]

[ "A", ",", "_", "_", "B", ")", ";" ]

[ "return", "_", "_", "builtin_ia32_vcvtqq2ph128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "C", ",", "_", "_" ]

[ "return", "MIB", ".", "constrainAllUses", "(", "TII", ",", "TRI", ",", "RBI", ")", ";" ]

[ "unsigned", "OpOffset", "=", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "Register", "Ptr", "=", "I", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getReg", "(", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addDef", "(", "ResVReg", ")", ".", "addUse", "(", "GR", ".", "getSPIRVTypeID", "(", "ResType", ")", ")", ".", "addUse", "(", "Ptr", ")", ";", "if", "(", "!", "I", ".", "getNumMemOperands", "(", ")", ")", "{", "assert", "(", "I", ".", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "G_INTRINSIC_W_SIDE_EFFECTS", ")", ";", "addMemoryOperands", "(", "I", ".", "getOperand", "(", "<NUM_LIT>", "+", "OpOffset", ")", ".", "getImm", "(", ")", ",", "MIB", ")", ";", "}", "else", "{", "addMemoryOperands", "(", "*", "I", ".", "memoperands_begin", "(", ")", ",", "MIB", ")", ";", "}" ]

[ "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(" ]

[ "::", "i8", ")", ";" ]

[ "SrcOp", "=", "DAG", ".", "getBitcast", "(", "ShVT", ",", "SrcOp", ")", ";", "assert", "(", "NumBits", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Only support byte sized shifts", "<STR_LIT>", ")", ";", "SDValue", "ShiftVal", "=", "DAG", ".", "getConstant", "(", "NumBits", "/", "<NUM_LIT>", ",", "dl", ",", "MVT" ]

[ "}" ]

[ "unsigned", "BR", "=", "getBaseAddressRegister", "(", "MI", ")", ";", "if", "(", "BR", "==", "BaseReg", ")", "{", "Group", ".", "push_back", "(", "MI", ")", ";", "*", "I", "=", "nullptr", ";", "continue", ";", "}", "}", "if", "(", "MI", "->", "isCall", "(", ")", "||", "MI", "->", "hasUnmodeledSideEffects", "(", ")", ")", "return", ";", "if", "(", "MI", "->", "mayLoad", "(", ")", "||", "MI", "->", "mayStore", "(", ")", ")", "{", "if", "(", "MI", "->", "hasOrderedMemoryRef", "(", ")", "||", "instrAliased", "(", "Group", ",", "MI", ")", ")", "return", ";", "Other", ".", "push_back", "(", "MI", ")", ";", "}", "}" ]

[ "ValVReg", ",", "VA", ")", ";" ]

[ "MIRBuilder", ".", "buildCopy", "(", "Register", "(", "PhysReg", "+", "(", "IsEL", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ",", "Unmerge", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "Register", "(", "PhysReg", "+", "(", "IsEL", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ",", "Unmerge", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";", "}", "else", "if", "(", "VT", "==", "MVT", "::", "f32", "&&", "PhysReg", ">=", "Mips", "::", "A0", "&&", "PhysReg", "<=", "Mips", "::", "A3", ")", "{", "MIRBuilder", ".", "buildCopy", "(", "PhysReg", ",", "ValVReg", ")", ";", "}", "else", "{", "Register", "ExtReg", "=", "extendRegister", "(" ]

[ "<FIXS>", "HowToPassCallArgument", "(", "Arg", ".", "getValueType", "(", ")", ",", "ArgInRegs", "[", "i", "]", ",", "NumIntRegs", ",", "NumXMMRegs", ",", "<NUM_LIT>", ",", "ObjSize", ",", "ObjIntRegs", ",", "ObjXMMRegs", ",", "!", "isStdCall", ")", ";", "if", "(", "ObjSize", ">", "<NUM_LIT>", ")", "ArgIncrement", "=", "ObjSize", ";", "if", "(", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i8", "||", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "i16", ")", "{", "<FIXE>", "<FIXS>", "unsigned", "Flags", "=", "cast", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", ";", "unsigned", "ExtOp", "=", "(", "Flags", "&", "<NUM_LIT>", ")", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ";", "<FIXE>", "<FIXS>", "if", "(", "ObjIntRegs", "||", "ObjXMMRegs", ")", "{", "switch", "(", "Arg", ".", "getValueType", "(", ")", ")", "{", "default", ":", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unhandled argument type!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i32", ":", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR32ArgRegs", "[", "NumIntRegs", "]", ",", "Arg", ")", ")", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "assert", "(", "!", "isStdCall", "&&", "<STR_LIT>", "Unhandled argument type!", "<STR_LIT>", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "XMMArgRegs", "[", "NumXMMRegs", "]", ",", "Arg", ")", ")", ";", "break", ";", "}", "NumIntRegs", "+=", "ObjIntRegs", ";", "NumXMMRegs", "+=", "ObjXMMRegs", ";", "<FIXE>", "<FIXS>", "if", "(", "ObjSize", ")", "{", "if", "(", "ObjSize", "==", "<NUM_LIT>", ")", "ArgOffset", "=", "(", "(", "ArgOffset", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ";", "<FIXE>", "<FIXS>", "ArgOffset", "+=", "ArgIncrement", ";", "if", "(", "SRetArgs", "[", "i", "]", ")", "NumSRetBytes", "+=", "ArgIncrement", ";", "<FIXE>" ]

[ "unsigned", "ArgOffset", "=", "<NUM_LIT>", ";", "NumXMMRegs", "=", "<NUM_LIT>", ";", "std", "::", "vector", "std", "::", "pair", "unsigned", ",", "SDOperand", ">", ">", "RegsToPass", ";", "std", "::", "vector", "SDOperand", ">", "MemOpChains", ";", "SDOperand", "StackPtr", "=", "DAG", ".", "getRegister", "(", "X86StackPtr", ",", "getPointerTy", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "{", "SDOperand", "Arg", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "i", ")", ";", "<BUGS>", "switch", "(", "Arg", ".", "getValueType", "(", ")", ")", "{", "default", ":", "assert", "(", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected ValueType for argument!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "{", "<BUGE>", "<BUGS>", "unsigned", "ExtOp", "=", "dyn_cast", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "i", "+", "<NUM_LIT>", ")", ")", "->", "getValue", "(", ")", "?", "ISD", "::", "SIGN_EXTEND", ":", "ISD", "::", "ZERO_EXTEND", ";", "<BUGE>", "Arg", "=", "DAG", ".", "getNode", "(", "ExtOp", ",", "MVT", "::", "i32", ",", "Arg", ")", ";", "}", "<BUGS>", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "f32", ":", "{", "SDOperand", "PtrOff", "=", "DAG", ".", "getConstant", "(", "ArgOffset", ",", "getPointerTy", "(", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "getPointerTy", "(", ")", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ")", ")", ";", "ArgOffset", "+=", "<NUM_LIT>", ";", "break", ";", "<BUGE>", "}", "<BUGS>", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f64", ":", "{", "<BUGE>", "SDOperand", "PtrOff", "=", "DAG", ".", "getConstant", "(", "ArgOffset", ",", "getPointerTy", "(", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "getPointerTy", "(", ")", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ")", ")", ";", "<BUGS>", "ArgOffset", "+=", "<NUM_LIT>", ";", "break", ";", "}", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "if", "(", "NumXMMRegs", "<NUM_LIT>", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "XMMArgRegs", "[", "NumXMMRegs", "]", ",", "Arg", ")", ")", ";", "NumXMMRegs", "++", ";", "}", "else", "{", "ArgOffset", "=", "(", "(", "ArgOffset", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ")", "*", "<NUM_LIT>", ";", "SDOperand", "PtrOff", "=", "DAG", ".", "getConstant", "(", "ArgOffset", ",", "getPointerTy", "(", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "getPointerTy", "(", ")", ",", "StackPtr", ",", "PtrOff", ")", ";", "MemOpChains", ".", "push_back", "(", "DAG", ".", "getStore", "(", "Chain", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ")", ")", ";", "ArgOffset", "+=", "<NUM_LIT>", ";", "}", "<BUGE>", "}", "}" ]

[ "<FIXS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>" ]

[ "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "unspec_volatile", "[", "(", "match_operand", ":", "SWI48", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]" ]

[ ":", "VSX_M", "<NUM_LIT>", "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand" ]

[ ")", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "XS", ";" ]

[ "def", "POPCNT64rr", ":", "RI", "<", "<NUM_LIT>", ",", "MRMSrcReg", ",", "(", "outs", "GR64", ":", "$", "dst", ")", ",", "(", "ins", "GR64", ":", "$", "src" ]

[ "default", ":" ]

[ "if", "(", "need_longbranch", ")", "ccode", "=", "<STR_LIT>", "jmpf", "<STR_LIT>", ";", "else", "ccode", "=", "<STR_LIT>", "br", "<STR_LIT>", ";", "sprintf", "(", "string", ",", "<STR_LIT>", "%s %s", "<STR_LIT>", ",", "ccode", ",", "label", ")", ";", "return", "string", ";", "}", "code", "=", "GET_CODE", "(", "op", ")", ";", "if", "(", "!", "REG_P", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", "{", "code", "=", "swap_condition", "(", "code", ")", ";", "operands", "=", "<STR_LIT>", "%3,%2", "<STR_LIT>", ";", "}", "else", "operands", "=", "<STR_LIT>", "%2,%3", "<STR_LIT>", ";", "if", "(", "really_reversed", ")", "code", "=", "reverse_condition", "(", "code", ")", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "ccode", "=", "<STR_LIT>", "z", "<STR_LIT>", ";", "break", ";", "case", "NE", ":", "ccode", "=", "<STR_LIT>", "nz", "<STR_LIT>", ";", "break", ";", "case", "GE", ":", "ccode", "=", "<STR_LIT>", "ge", "<STR_LIT>", ";", "break", ";", "case", "LT", ":", "ccode", "=", "<STR_LIT>", "lt", "<STR_LIT>", ";", "break", ";", "case", "GT", ":", "ccode", "=", "<STR_LIT>", "gt", "<STR_LIT>", ";", "break", ";", "case", "LE", ":", "ccode", "=", "<STR_LIT>", "le", "<STR_LIT>", ";", "break", ";", "case", "GEU", ":", "ccode", "=", "<STR_LIT>", "nc", "<STR_LIT>", ";", "break", ";", "case", "LTU", ":", "ccode", "=", "<STR_LIT>", "c", "<STR_LIT>", ";", "break", ";", "case", "GTU", ":", "ccode", "=", "<STR_LIT>", "hi", "<STR_LIT>", ";", "break", ";", "case", "LEU", ":", "ccode", "=", "<STR_LIT>", "ls", "<STR_LIT>", ";", "break", ";" ]

[ "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "bool", "explicit_type0", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_type_suffix_p", "(", "<NUM_LIT>", ")", ";", "bool", "explicit_type1", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_type_suffix_p", "(", "<NUM_LIT>", ")", ";", "bool", "explicit_group", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_group_suffix_p", "(", ")", ";", "auto", "add_function", "=", "[", "&", "]", "(", "const", "type_suffix_pair", "&", "types", ",", "group_suffix_index", "group_suffix_id", ",", "unsigned", "int", "pi", ")", "{", "function_instance", "instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "mode", ",", "types", ",", "group_suffix_id", ",", "group", ".", "preds", "[", "pi", "]", ")", ";", "add_overloaded_function", "(", "instance", ",", "group", ".", "required_extensions", ")", ";", "}", ";", "auto", "add_group_suffix", "=", "[", "&", "]", "(", "group_suffix_index", "group_suffix_id", ",", "unsigned", "int", "pi", ")", "<FIXE>", "<FIXS>", "add_function", "(", "types_none", "[", "<NUM_LIT>", "]", ",", "group_suffix_id", ",", "pi", ")", ";", "<FIXE>" ]

[ "function_builder", "::", "add_overloaded_functions", "(", "const", "function_group_info", "&", "group", ",", "mode_suffix_index", "mode", ")", "{", "<BUGS>", "unsigned", "int", "explicit_type0", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_type_suffix_p", "(", "<NUM_LIT>", ")", ";", "unsigned", "int", "explicit_type1", "=", "(", "*", "group", ".", "shape", ")", "->", "explicit_type_suffix_p", "(", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "int", "pi", "=", "<NUM_LIT>", ";", "group", ".", "preds", "[", "pi", "]", "!=", "NUM_PREDS", ";", "++", "pi", ")", "<BUGE>", "{", "if", "(", "!", "explicit_type0", "&&", "!", "explicit_type1", ")", "<BUGS>", "{", "function_instance", "instance", "(", "group", ".", "base_name", ",", "*", "group", ".", "base", ",", "*", "group", ".", "shape", ",", "mode", ",", "types_none", "[", "<NUM_LIT>", "]", ",", "group", ".", "preds", "[", "pi", "]", ")", ";", "add_overloaded_function", "(", "instance", ",", "group", ".", "required_extensions", ")", ";", "}", "<BUGE>", "elsefor", "(", "unsigned", "int", "ti", "=", "<NUM_LIT>", ";", "group", ".", "types", "[", "ti", "]", "[", "<NUM_LIT>", "]", "!=", "NUM_TYPE_SUFFIXES", ";" ]

[ ",", "(", "_", "_", "mmask32", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m512i", ")", "_", "_", "builtin_ia32_pmovsxbw512_mask", "(", "(", "_", "_", "v32qi", ")", "_", "_", "A", ",", "(", "_", "_", "v32hi", ")", "_", "mm512_setzero_si512", "(", ")" ]

[ ")" ]

[ "(", "define_automaton", "<STR_LIT>" ]

[ "let", "OutOfSlotData", "=", "<NUM_LIT>", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "SrcExtra", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "sw", ";", "let", "PredAddress", "=", "pred", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "VectorPred", "=", "<NUM_LIT>", ";", "let", "PredPolarity", "=", "pred", "{", "<NUM_LIT>", "}", ";" ]

[ "<<", "Name", ";" ]

[ "if", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Name", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", ")", ".", "toString", "(", "Val", ",", "STI", ".", "getFeatureBits", "(", ")", ",", "Valid", ")", ";", "else", "Name", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", ")", ".", "toString", "(", "Val", ",", "STI", ".", "getFeatureBits", "(", ")", ",", "Valid", ")", ";", "if", "(", "Valid", ")", "O" ]

[ ")", ")", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "[", "(", "set", "(", "reg", ":", "SI", "SP_REG", ")", "(", "plus", ":", "SI", "(", "reg", ":", "SI", "SP_REG", ")", "(", "match_dup", "<NUM_LIT>" ]

[ "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op2", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "off18", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "off18", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "off18", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "b", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "bpos3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "call", "(", "mem", ":", "QI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "return", ")", "]", "<STR_LIT>" ]

[ "StringRef", "ID", ";" ]

[ "amd_kernel_code_t", "Header", ";", "AMDGPU", "::", "initDefaultAMDKernelCodeT", "(", "Header", ",", "&", "getSTI", "(", ")", ")", ";", "while", "(", "true", ")", "{", "while", "(", "trySkipToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvttps_epu32", "(", "_", "_", "m128", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_cvttps2udq128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_", "mm_avx512_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "NewDstRC", ";" ]

[ "case", "AMDGPU", "::", "REG_SEQUENCE", ":", "case", "AMDGPU", "::", "INSERT_SUBREG", ":", "case", "AMDGPU", "::", "WQM", ":", "case", "AMDGPU", "::", "SOFT_WQM", ":", "case", "AMDGPU", "::", "STRICT_WWM", ":", "case", "AMDGPU", "::", "STRICT_WQM", ":", "{", "const", "TargetRegisterClass", "*", "SrcRC", "=", "getOpRegClass", "(", "Inst", ",", "<NUM_LIT>", ")", ";", "if", "(", "RI", ".", "isAGPRClass", "(", "SrcRC", ")", ")", "{", "if", "(", "RI", ".", "isAGPRClass", "(", "NewDstRC", ")", ")", "return", "nullptr", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "PHI", ":", "case", "AMDGPU", "::", "REG_SEQUENCE", ":", "case", "AMDGPU", "::", "INSERT_SUBREG", ":", "NewDstRC", "=", "RI", ".", "getEquivalentAGPRClass", "(", "NewDstRC", ")", ";", "break", ";", "default", ":", "NewDstRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "NewDstRC", ")", ";", "}", "if", "(", "!", "NewDstRC", ")", "return", "nullptr", ";", "}", "else", "{", "if", "(", "RI", ".", "isVGPRClass", "(", "NewDstRC", ")", "||", "NewDstRC", "==", "&", "AMDGPU", "::", "VReg_1RegClass", ")", "return", "nullptr", ";", "NewDstRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "NewDstRC", ")", ";", "if", "(", "!", "NewDstRC", ")", "return", "nullptr", ";", "}", "return", "NewDstRC", ";", "}", "default", ":" ]

[ "bool", "TLCS900AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "<NUM_LIT>", "]", ")", "return", "true", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "<FIXS>", "TB", ",", "Requires", "[", "HasSSE1", "]", ">", ";", "<FIXE>", "<FIXS>", "TB", ",", "Requires", "[", "HasSSE2", "]", ">", ";", "<FIXE>", "<FIXS>", "TB", ",", "Requires", "[", "HasMFence", "]", ">", ";", "<FIXE>" ]

[ "def", "SFENCE", ":", "I", "<NUM_LIT>", ",", "MRM7X", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "(", "int_x86_sse_sfence", ")", "]", ">", ",", "<BUGS>", "TB", ",", "PS", ",", "Requires", "[", "HasSSE1", "]", ">", ";", "<BUGE>", "def", "LFENCE", ":", "I", "<NUM_LIT>", ",", "MRM5X", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "(", "int_x86_sse2_lfence", ")", "]", ">", ",", "<BUGS>", "TB", ",", "PS", ",", "Requires", "[", "HasSSE2", "]", ">", ";", "<BUGE>", "def", "MFENCE", ":", "I", "<NUM_LIT>", ",", "MRM6X", ",", "(", "outs", ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "(", "int_x86_sse2_mfence", ")", "]", ">", ",", "<BUGS>", "TB", ",", "PS", ",", "Requires", "[", "HasMFence", "]", ">", ";", "<BUGE>", "}", "def", ":", "Pat", "(", "X86MFence", ")", ",", "(", "MFENCE", ")", ">", ";" ]

[ ")", ";" ]

[ "const", "InstrItineraryData", "*", "II", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG" ]

[ "}" ]

[ "def", "v1i32_indexed", ":", "BaseSIMDIndexed", "<", "<NUM_LIT>", ",", "U", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "opc", ",", "FPR32Op", ",", "FPR32Op", ",", "V128", ",", "VectorIndexS", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "(", "i32", "FPR32Op", ":", "$", "Rd", ")", ",", "(", "OpNode", "FPR32Op", ":", "$", "Rn", ",", "(", "i32", "(", "vector_extract", "(", "v4i32", "V128", ":", "$", "Rm", ")", ",", "VectorIndexS", ":", "$", "idx", ")", ")", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";" ]

[ "return", "Error", "(", "Parser", ".", "getTok", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "unexpected input in .req directive.", "<STR_LIT>", ")", ";" ]

[ "unsigned", "Reg", ";", "SMLoc", "SRegLoc", ",", "ERegLoc", ";", "if", "(", "ParseRegister", "(", "Reg", ",", "SRegLoc", ",", "ERegLoc", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "SRegLoc", ",", "<STR_LIT>", "register name expected", "<STR_LIT>", ")", ";", "}", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "Parser", ".", "EatToEndOfStatement", "(", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_test", "<STR_LIT>", ")", "(", "and", "(", "eq_attr", "<STR_LIT>" ]

[ "case", "'", "w", "'", ":" ]

[ "op", "=", "CONST_VECTOR_ELT", "(", "op", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "op", ")", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "op", ")", ")", ";", "}", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "c", "'", ":", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "op", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "unsupported operand for code '%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "C", "'", ":", "loongarch_print_int_branch_condition", "(", "file", ",", "code", ",", "letter", ")", ";", "break", ";", "case", "'", "d", "'", ":", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "op", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "F", "'", ":", "loongarch_print_float_branch_condition", "(", "file", ",", "code", ",", "letter", ")", ";", "break", ";", "case", "'", "G", "'", ":", "if", "(", "loongarch_cas_failure_memorder_needs_acquire", "(", "memmodel_from_int", "(", "INTVAL", "(", "op", ")", ")", ")", ")", "fputs", "(", "<STR_LIT>", "dbar\\t0b10100", "<STR_LIT>", ",", "file", ")", ";", "else", "if", "(", "!", "ISA_HAS_LD_SEQ_SA", ")", "fputs", "(", "<STR_LIT>", "dbar\\t0x700", "<STR_LIT>", ",", "file", ")", ";", "break", ";", "case", "'", "h", "'", ":", "if", "(", "code", "==", "HIGH", ")", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "loongarch_print_operand_reloc", "(", "file", ",", "op", ",", "false", ",", "true", ")", ";", "break", ";", "case", "'", "H", "'", ":", "loongarch_print_operand_reloc", "(", "file", ",", "op", ",", "true", ",", "true", ")", ";", "break", ";", "case", "'", "i", "'", ":", "if", "(", "code", "!=", "REG", ")", "fputs", "(", "<STR_LIT>", "i", "<STR_LIT>", ",", "file", ")", ";", "break", ";", "case", "'", "L", "'", ":", "loongarch_print_operand_reloc", "(", "file", ",", "op", ",", "false", ",", "false", ")", ";", "break", ";", "case", "'", "B", "'", ":", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST_VECTOR", ")", "{", "gcc_assert", "(", "loongarch_const_vector_same_val_p", "(", "op", ",", "GET_MODE", "(", "op", ")", ")", ")", ";", "op", "=", "CONST_VECTOR_ELT", "(", "op", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "op", ")", ")", ";", "unsigned", "HOST_WIDE_INT", "val8", "=", "UINTVAL", "(", "op", ")", "&", "GET_MODE_MASK", "(", "QImode", ")", ";", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_UNSIGNED", ",", "val8", ")", ";", "}", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "m", "'", ":", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "op", ")", "-", "<NUM_LIT>", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "N", "'", ":", "loongarch_print_int_branch_condition", "(", "file", ",", "reverse_condition", "(", "code", ")", ",", "letter", ")", ";", "break", ";", "case", "'", "Q", "'", ":", "if", "(", "!", "TARGET_LINKER_RELAXATION", ")", "break", ";", "if", "(", "code", "==", "HIGH", ")", "op", "=", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ";", "if", "(", "loongarch_classify_symbolic_expression", "(", "op", ")", "==", "SYMBOL_TLS_IE", ")", "fprintf", "(", "file", ",", "<STR_LIT>", ".reloc\\t.,R_LARCH_RELAX\\n\\t", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "r", "'", ":", "loongarch_print_operand_reloc", "(", "file", ",", "op", ",", "false", ",", "true", ")", ";", "break", ";", "case", "'", "R", "'", ":", "loongarch_print_operand_reloc", "(", "file", ",", "op", ",", "true", ",", "false", ")", ";", "break", ";", "case", "'", "t", "'", ":", "case", "'", "T", "'", ":", "{", "int", "truth", "=", "(", "code", "==", "NE", ")", "==", "(", "letter", "==", "'", "T", "'", ")", ";", "fputc", "(", "<STR_LIT>", "zfnt", "<STR_LIT>", "[", "truth", "*", "<NUM_LIT>", "+", "FCC_REG_P", "(", "REGNO", "(", "XEXP", "(", "op", ",", "<NUM_LIT>", ")", ")", ")", "]", ",", "file", ")", ";", "}", "break", ";", "case", "'", "V", "'", ":", "if", "(", "CONST_VECTOR_P", "(", "op", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE_INNER", "(", "GET_MODE", "(", "op", ")", ")", ";", "unsigned", "HOST_WIDE_INT", "val", "=", "UINTVAL", "(", "CONST_VECTOR_ELT", "(", "op", ",", "<NUM_LIT>", ")", ")", ";", "int", "vlog2", "=", "exact_log2", "(", "val", "&", "GET_MODE_MASK", "(", "mode", ")", ")", ";", "if", "(", "vlog2", "!=", "-", "<NUM_LIT>", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%d", "<STR_LIT>", ",", "vlog2", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "}", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "W", "'", ":", "loongarch_print_float_branch_condition", "(", "file", ",", "reverse_condition", "(", "code", ")", ",", "letter", ")", ";", "break", ";", "case", "'", "x", "'", ":", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "op", ")", "&", "<NUM_LIT>", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "X", "'", ":", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "op", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "y", "'", ":", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "{", "int", "val", "=", "exact_log2", "(", "INTVAL", "(", "op", ")", ")", ";", "if", "(", "val", "!=", "-", "<NUM_LIT>", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "%d", "<STR_LIT>", ",", "val", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "}", "else", "output_operand_lossage", "(", "<STR_LIT>", "invalid use of '%%%c'", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "Y", "'", ":", "if", "(", "code", "==", "CONST_INT", "&&", "UINTVAL", "(", "op", ")", "<", "ARRAY_SIZE", "(", "loongarch_fp_conditions", ")", ")", "fputs", "(", "loongarch_fp_conditions", "[", "UINTVAL", "(", "op", ")", "]", ",", "file", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "'%%%c' is not a valid operand prefix", "<STR_LIT>", ",", "letter", ")", ";", "break", ";", "case", "'", "Z", "'", ":", "loongarch_print_operand", "(", "file", ",", "op", ",", "<NUM_LIT>", ")", ";", "fputc", "(", "'", ",", "'", ",", "file", ")", ";", "break", ";" ]

[ "ISD", "::", "BasicBlock", ")", ";" ]

[ "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Pred", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Target", "=", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "PredOp", "=", "CurDAG", "->", "getTargetConstant", "(", "PTXPredicate", "::", "Normal", ",", "MVT", "::", "i32", ")", ";", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "Target", ".", "getOpcode", "(", ")", "==" ]

[ "const", "int", "_", "_", "offset", ")", "{" ]

[ "_", "_", "arm_vldrdq_gather_base_s64", "(", "uint64x2_t", "_", "_", "addr", "," ]

[ "MII", ";" ]

[ "void", "HexagonInstrInfo", "::", "translateInstrsForDup", "(", "MachineBasicBlock", "::", "instr_iterator", "MII", ",", "bool", "ToBigInstrs", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "MII", "->", "getParent", "(", ")", ";", "while", "(", "(", "MII", "!=", "MBB", "->", "instr_end", "(", ")", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ")", "{", "changeDuplexOpcode", "(", "MII", ",", "ToBigInstrs", ")", ";", "++" ]

[ "void", "alpha_expand_prologue", "(", "void", ")", "{", "unsigned", "long", "imask", "=", "<NUM_LIT>", ";", "unsigned", "long", "fmask", "=", "<NUM_LIT>", ";", "HOST_WIDE_INT", "sa_size", ",", "sa_bias", ";", "HOST_WIDE_INT", "frame_size", ";", "HOST_WIDE_INT", "probed_size", ";", "HOST_WIDE_INT", "reg_offset", ";", "rtx", "sa_reg", ";", "int", "i", ";", "sa_size", "=", "alpha_sa_size", "(", ")", ";", "frame_size", "=", "compute_frame_size", "(", "get_frame_size", "(", ")", ",", "sa_size", ")", ";", "if", "(", "flag_stack_usage_info", ")", "current_function_static_stack_size", "=", "frame_size", ";", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "reg_offset", "=", "<NUM_LIT>", "+", "<NUM_LIT>", "*", "cfun", "->", "machine", "->", "uses_condition_handler", ";", "else", "reg_offset", "=", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ";", "alpha_sa_mask", "(", "&", "imask", ",", "&", "fmask", ")", ";", "if", "(", "TARGET_ABI_OSF", ")", "{", "alpha_function_needs_gp", "=", "alpha_does_function_need_gp", "(", ")", ";", "if", "(", "alpha_function_needs_gp", ")", "emit_insn", "(", "gen_prologue_ldgp", "(", ")", ")", ";", "}", "if", "(", "TARGET_PROFILING_NEEDS_GP", "&&", "crtl", "->", "profile", ")", "emit_insn", "(", "gen_prologue_mcount", "(", ")", ")", ";", "probed_size", "=", "frame_size", ";", "if", "(", "flag_stack_check", "||", "flag_stack_clash_protection", ")", "probed_size", "+=", "get_stack_check_protect", "(", ")", ";", "if", "(", "probed_size", "<=", "<NUM_LIT>", ")", "{", "if", "(", "probed_size", ">", "<NUM_LIT>", ")", "{", "int", "probed", ";", "for", "(", "probed", "=", "<NUM_LIT>", ";", "probed", "<", "probed_size", ";", "probed", "+=", "<NUM_LIT>", ")", "emit_insn", "(", "gen_stack_probe_internal", "(", "GEN_INT", "(", "-", "probed", ")", ")", ")", ";", "if", "(", "(", "sa_size", "==", "<NUM_LIT>", "&&", "probed_size", ">", "probed", "-", "<NUM_LIT>", ")", "||", "flag_stack_check", "||", "flag_stack_clash_protection", ")", "emit_insn", "(", "gen_stack_probe_internal", "(", "GEN_INT", "(", "-", "probed_size", ")", ")", ")", ";", "}", "if", "(", "frame_size", "!=", "<NUM_LIT>", ")", "FRP", "(", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "frame_size", ")", ")", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "blocks", "=", "(", "probed_size", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "HOST_WIDE_INT", "leftover", "=", "probed_size", "+", "<NUM_LIT>", "-", "blocks", "*", "<NUM_LIT>", ";", "rtx", "ptr", "=", "gen_rtx_REG", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "rtx", "count", "=", "gen_rtx_REG", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "rtx", "seq", ";", "emit_move_insn", "(", "count", ",", "GEN_INT", "(", "blocks", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "ptr", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_prologue_stack_probe_loop", "(", "count", ",", "ptr", ")", ")", ";", "if", "(", "(", "leftover", ">", "<NUM_LIT>", "&&", "sa_size", "==", "<NUM_LIT>", ")", "||", "flag_stack_check", "||", "flag_stack_clash_protection", ")", "{", "rtx", "last", "=", "gen_rtx_MEM", "(", "DImode", ",", "plus_constant", "(", "Pmode", ",", "ptr", ",", "-", "leftover", ")", ")", ";", "MEM_VOLATILE_P", "(", "last", ")", "=", "<NUM_LIT>", ";", "emit_move_insn", "(", "last", ",", "const0_rtx", ")", ";", "}", "if", "(", "flag_stack_check", "||", "flag_stack_clash_protection", ")", "{", "HOST_WIDE_INT", "lo", ",", "hi", ";", "lo", "=", "(", "(", "frame_size", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "hi", "=", "frame_size", "-", "lo", ";", "emit_move_insn", "(", "ptr", ",", "GEN_INT", "(", "hi", ")", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "ptr", ",", "ptr", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "seq", "=", "emit_insn", "(", "gen_subdi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "ptr", ")", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "gen_adddi3", "(", "stack_pointer_rtx", ",", "ptr", ",", "GEN_INT", "(", "-", "leftover", ")", ")", ")", ";", "}", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "<NUM_LIT>", ";", "add_reg_note", "(", "seq", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "-", "frame_size", ")", ")", ")", ";", "}", "sa_bias", "=", "<NUM_LIT>", ";", "sa_reg", "=", "stack_pointer_rtx", ";", "if", "(", "reg_offset", "+", "sa_size", ">", "<NUM_LIT>", ")", "{", "int", "low", "=", "(", "(", "reg_offset", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "rtx", "sa_bias_rtx", ";", "if", "(", "low", "+", "sa_size", "<=", "<NUM_LIT>", ")", "sa_bias", "=", "reg_offset", "-", "low", ",", "reg_offset", "=", "low", ";", "else", "sa_bias", "=", "reg_offset", ",", "reg_offset", "=", "<NUM_LIT>", ";", "sa_reg", "=", "gen_rtx_REG", "(", "DImode", ",", "<NUM_LIT>", ")", ";", "sa_bias_rtx", "=", "GEN_INT", "(", "sa_bias", ")", ";", "if", "(", "add_operand", "(", "sa_bias_rtx", ",", "DImode", ")", ")", "emit_insn", "(", "gen_adddi3", "(", "sa_reg", ",", "stack_pointer_rtx", ",", "sa_bias_rtx", ")", ")", ";", "else", "{", "emit_move_insn", "(", "sa_reg", ",", "sa_bias_rtx", ")", ";", "emit_insn", "(", "gen_adddi3", "(", "sa_reg", ",", "stack_pointer_rtx", ",", "sa_reg", ")", ")", ";", "}", "}", "if", "(", "TARGET_ABI_OPEN_VMS", "&&", "alpha_procedure_type", "==", "PT_STACK", ")", "emit_frame_store", "(", "REG_PV", ",", "stack_pointer_rtx", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "imask", "&", "(", "<NUM_LIT>", "UL", "<<", "REG_RA", ")", ")", "{", "emit_frame_store", "(", "REG_RA", ",", "sa_reg", ",", "sa_bias", ",", "reg_offset", ")", ";", "imask", "&=", "~", "(", "<NUM_LIT>", "UL", "<<", "REG_RA", ")", ";", "reg_offset", "+=", "<NUM_LIT>", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "imask", "&", "(", "<NUM_LIT>", "UL", "<<", "i", ")", ")", "{", "emit_frame_store", "(", "i", ",", "sa_reg", ",", "sa_bias", ",", "reg_offset", ")", ";", "reg_offset", "+=", "<NUM_LIT>", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "fmask", "&", "(", "<NUM_LIT>", "UL", "<<", "i", ")", ")", "{", "emit_frame_store", "(", "i", "+", "<NUM_LIT>", ",", "sa_reg", ",", "sa_bias", ",", "reg_offset", ")", ";", "reg_offset", "+=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_ABI_OPEN_VMS", ")", "{", "if", "(", "alpha_procedure_type", "==", "PT_REGISTER", ")", "{", "rtx_insn", "*", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "DImode", ",", "vms_save_fp_regno", ")", ",", "hard_frame_pointer_rtx", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "NULL", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "<NUM_LIT>", ";", "}", "if", "(", "alpha_procedure_type", "!=", "PT_NULL", "&&", "vms_base_regno", "!=", "REG_PV", ")", "emit_insn", "(", "gen_force_movdi", "(", "gen_rtx_REG", "(", "DImode", ",", "vms_base_regno", ")", ",", "gen_rtx_REG", "(", "DImode", ",", "REG_PV", ")", ")", ")", ";", "if", "(", "alpha_procedure_type", "!=", "PT_NULL", "&&", "vms_unwind_regno", "==", "HARD_FRAME_POINTER_REGNUM", ")", "FRP", "(", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "if", "(", "crtl", "->", "outgoing_args_size", "!=", "<NUM_LIT>", ")", "{", "rtx_insn", "*", "seq", "=", "emit_move_insn", "(", "stack_pointer_rtx", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "-", "(", "ALPHA_ROUND", "(", "crtl", "->", "outgoing_args_size", ")", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "!", "frame_pointer_needed", ";", "}", "}", "else", "{", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "TARGET_CAN_FAULT_IN_PROLOGUE", ")", "FRP", "(", "emit_move_insn", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ")", ")", ";", "else", "FRP", "(", "emit_insn", "(", "gen_init_fp", "(", "hard_frame_pointer_rtx", ",", "stack_pointer_rtx", ",", "sa_reg", ")", ")", ")", ";", "}", "}", "if", "(", "!", "TARGET_CAN_FAULT_IN_PROLOGUE", ")", "emit_insn", "(", "gen_blockage", "(", ")", ")", ";", "}" ]

[ "On", "vms", "we", "have", "two", "kinds", "of", "functions", ":", "-", "stack", "frame", "(", "PROC_STACK", ")", "these", "are", "'normal", "'", "functions", "with", "local", "vars", "and", "which", "are", "calling", "other", "functions", "-", "register", "frame", "(", "PROC_REGISTER", ")", "keeps", "all", "data", "in", "registers", ",", "needs", "no", "stack", "We", "must", "pass", "this", "to", "the", "assembler", "so", "it", "can", "generate", "the", "proper", "pdsc", "(", "procedure", "descriptor", ")", "This", "is", "done", "with", "the", "'.pdesc", "'", "command", ".", "On", "not-vms", ",", "we", "do", "n't", "really", "differentiate", "between", "the", "two", ",", "as", "we", "can", "simply", "allocate", "stack", "without", "saving", "registers", "." ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_12", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ ")", ";" ]

[ "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "Decs", ";", "SmallVector", "<", "MachineInstr", "*", ",", "<NUM_LIT>", ">", "Ends", ";", "for", "(", "auto", "&", "I", ":", "MBB", ")", "{", "if", "(", "IsLoopStart", "(", "I", ")", ")", "Starts", ".", "push_back", "(", "&", "I", ")", ";", "else", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopDec", ")", "Decs", ".", "push_back", "(", "&", "I", ")", ";", "else", "if", "(", "I", ".", "getOpcode", "(", ")", "==", "ARM", "::", "t2LoopEnd", ")", "Ends", ".", "push_back", "(", "&", "I", ")", ";", "}", "if", "(", "Starts", ".", "empty", "(", ")", "&&", "Decs", ".", "empty", "(", ")", "&&", "Ends", ".", "empty", "(", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "*", "Start", ":", "Starts", ")", "{", "if", "(", "Start", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2WhileLoopStart", ")", "RevertWhile", "(", "Start", ")", ";", "else", "Start", "->", "eraseFromParent", "(" ]

[ "emit_insn", "(", "gen_addqi3_cconly_overflow", "(", "tmpreg", ",", "tmpreg", ")", ")", ";" ]

[ "rtx", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "reg2", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "reg", ",", "tmpreg", ")", ";", "emit_insn", "(", "gen_lshrsi3", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_testsi_ccno_1", "(", "tmpreg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "tmpreg", ",", "gen_rtx_IF_THEN_ELSE", "(", "SImode", ",", "tmp", ",", "reg", ",", "tmpreg", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg2", ",", "plus_constant", "(", "Pmode", ",", "out", ",", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "out", ",", "gen_rtx_IF_THEN_ELSE", "(", "Pmode", ",", "tmp", ",", "reg2", ",", "out", ")", ")", ")", ";", "}", "else", "{", "rtx_code_label", "*", "end_2_label", "=", "gen_label_rtx", "(", ")", ";", "emit_insn", "(", "gen_testsi_ccno_1", "(", "tmpreg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "end_2_label", ")", ",", "pc_rtx", ")", ";", "tmp", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp", ")", ")", ";", "JUMP_LABEL", "(", "tmp", ")", "=", "end_2_label", ";", "emit_insn", "(", "gen_lshrsi3", "(", "tmpreg", ",", "tmpreg", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "out", ",", "const2_rtx", ")", ")", ";", "emit_label", "(", "end_2_label", ")", ";", "}", "tmpreg", "=", "gen_lowpart", "(", "QImode", ",", "tmpreg", ")", ";" ]

[ "true", ";" ]

[ "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "NumOps", ";", "++", "i", ")", "if", "(", "!", "(", "isUndefOrEqual", "(", "Mask", "[", "i", "]", ",", "i", "+", "NumOps", ")", "||", "(", "V2IsUndef", "&&", "isUndefOrInRange", "(", "Mask", "[", "i", "]", ",", "NumOps", ",", "NumOps", "*", "<NUM_LIT>", ")", ")", "||", "(", "V2IsSplat", "&&", "isUndefOrEqual", "(", "Mask", "[", "i", "]", ",", "NumOps", ")", ")", ")", ")", "return", "false", ";", "return" ]

[ "RTLIB", "::", "DIV_F128", ")", ",", "<NUM_LIT>", ")", ";" ]

[ "bool", "hasHardQuad", "=", "Subtarget", "->", "hasHardQuad", "(", ")", ";", "bool", "isV9", "=", "Subtarget", "->", "isV9", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Should not custom lower this!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ",", "*", "this", ",", "Subtarget", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ",", "*", "this", ",", "hasHardQuad", ")", ";", "case", "ISD", "::", "EH_SJLJ_SETJMP", ":", "return", "LowerEH_SJLJ_SETJMP", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "LowerEH_SJLJ_LONGJMP", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ",", "Subtarget", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FADD", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "ADD_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FSUB", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "SUB_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FMUL", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(", "RTLIB", "::", "MUL_F128", ")", ",", "<NUM_LIT>", ")", ";", "case", "ISD", "::", "FDIV", ":", "return", "LowerF128Op", "(", "Op", ",", "DAG", ",", "getLibcallName", "(" ]

[ "(", "match_operand", ":", "HF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "[", "(", "set", "(", "match_operand", ":", "HF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "HF", "(", "match_operand", ":", "HF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "emit_nop_after", "(", "int", "cycles", ",", "rtx_insn", "*", "after", ")", "<FIXE>" ]

[ "static", "rtx_insn", "*", "<BUGS>", "emit_nop_after", "(", "int", "cycles", ",", "rtx", "after", ")", "<BUGE>", "{", "rtx_insn", "*", "insn", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<FIXE>" ]

[ "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_select", ":", "V2SI", "(", "vec_concat", ":", "V4SI", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V2SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "{" ]

[ "+", "resultStr", "[", "<NUM_LIT>", "]", ";" ]

[ "if", "(", "const", "SCEVCommutativeExpr", "*", "CommutativeExp", "=", "dyn_cast", "<", "SCEVCommutativeExpr", ">", "(", "scev", ")", ")", "{", "string", "operatorVal", "=", "returnOperator", "(", "CommutativeExp", ",", "functionArgs", ")", ";", "string", "resultStr", "[", "<NUM_LIT>", "]", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "CommutativeExp", "->", "getNumOperands", "(", ")", ";", "i", "++", ")", "{", "resultStr", "[", "i", "]", "=", "printHelper", "(", "CommutativeExp", "->", "getOperand", "(", "i", ")", ",", "functionArgs", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "CommutativeExp", "->", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ";", "i", "++", ")", "{", "result", "+=", "resultStr", "[", "i", "]", "+", "operatorVal", ";", "}", "result", "+=", "resultStr", "[", "i", "]", ";", "return", "<STR_LIT>", "(", "<STR_LIT>", "+", "result", "+", "<STR_LIT>", ")", "<STR_LIT>", ";", "}", "if", "(", "const", "SCEVUDivExpr", "*", "divExp", "=", "dyn_cast", "<", "SCEVUDivExpr", ">", "(", "scev", ")", ")", "{", "string", "resultStr", "[", "<NUM_LIT>", "]", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "resultStr", "[", "<NUM_LIT>", "]", "=", "printHelper", "(", "divExp", "->", "getLHS", "(", ")", ",", "functionArgs", ")", ";", "resultStr", "[", "<NUM_LIT>", "]", "=", "printHelper", "(", "divExp", "->", "getRHS", "(", ")", ",", "functionArgs", ")", ";", "result", "+=", "resultStr", "[", "i", "]", "+", "string", "(", "<STR_LIT>", "/", "<STR_LIT>", ")" ]

[ "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";" ]

[ "DAG", ".", "getConstant", "(", "Cond", ",", "DL", ",", "MVT", "::", "i8", ")", ",", "BT", ")", ";" ]

[ "if", "(", "Src", ".", "getValueType", "(", ")", "==", "MVT", "::", "i8", "||", "Src", ".", "getValueType", "(", ")", "==", "MVT", "::", "i16", ")", "Src", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "MVT", "::", "i32", ",", "Src", ")", ";", "if", "(", "Src", ".", "getValueType", "(", ")", "!=", "BitNo", ".", "getValueType", "(", ")", ")", "BitNo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "Src", ".", "getValueType", "(", ")", ",", "BitNo", ")", ";", "SDValue", "BT", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i32", ",", "Src", ",", "BitNo", ")", ";", "M68k", "::", "CondCode", "Cond", "=", "CC", "==", "ISD", "::", "SETEQ", "?", "M68k", "::", "COND_NE", ":", "M68k", "::", "COND_EQ", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "i8", "," ]

[ "}" ]

[ "for", "(", "SuperRegClassIterator", "RCI", "(", "RC", ",", "TRI", ")", ";", "RCI", ".", "isValid", "(", ")", ";", "++", "RCI", ")", "{", "if", "(", "RCI", ".", "getSubReg", "(", ")", "==", "SubRegIdx", ")", "{", "I", "->", "second", "=", "RCI", ".", "getMask", "(", ")", ";", "break", ";", "}", "}", "}", "return", "I", "->", "second", ";" ]

[ "_", "_", "b", ")", "{" ]

[ "vqshrnh_n_s16", "(", "int16_t", "_", "_", "a", ",", "const", "int" ]

[ "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>" ]

[ "(", "mult", ":", "V2DI", "(", "sign_extend", ":", "V2DI", "(", "vec_select", ":", "V2SI", "<BUGS>", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "vec_select", ":", "V2SI" ]