Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "TI", "TF", "]", ")" ]

[ "(", "define_mode_iterator", "VT_HW_HSDT", "[", "V8HI", "V4SI", "V4SF", "V2DI", "V2DF", "V1TI", "V1TF" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "MSA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "MSA", "[", "(", "match_operand", ":", "MSA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "MSA", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_MSA_SLD", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ ")", "{" ]

[ "vsha1h_u32", "(", "uint32_t", "hash_e" ]

[ ")", ";" ]

[ "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "GP", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "HiSym", "=", "MCSymbolRefExpr", "::", "Create", "(", "<STR_LIT>", "_gp_disp", "<STR_LIT>", ",", "MCSymbolRefExpr", "::", "VK_Mips_ABS_HI", ",", "MCA", ".", "getContext", "(", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "HiSym", ")", ")", ";", "getStreamer", "(", ")", ".", "EmitInstruction", "(", "TmpInst", ",", "STI", ")", ";", "TmpInst", ".", "clear", "(", ")", ";", "TmpInst", ".", "setOpcode", "(", "Mips", "::", "ADDiu", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "GP", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "GP", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "LoSym", "=", "MCSymbolRefExpr", "::", "Create", "(", "<STR_LIT>", "_gp_disp", "<STR_LIT>", ",", "MCSymbolRefExpr", "::", "VK_Mips_ABS_LO", ",", "MCA", ".", "getContext", "(", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "LoSym", ")", ")", ";", "getStreamer", "(", ")", ".", "EmitInstruction", "(", "TmpInst", ",", "STI", ")", ";", "TmpInst", ".", "clear", "(" ]

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

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

[ "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";" ]

[ "void", "addSImm7s8Operands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";" ]

[ "}" ]

[ "unsigned", "Width", "=", "countTrailingOnes", "(", "And_imm", ")", "-", "<NUM_LIT>", ";", "unsigned", "LSB", "=", "Srl_imm", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "if", "(", "(", "LSB", "+", "Width", "+", "<NUM_LIT>", ")", "==", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getSizeInBits", "(", ")", ")", "{", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "{", "Opc", "=", "isSigned", "?", "ARM", "::", "t2ASRri", ":", "ARM", "::", "t2LSRri", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "LSB", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opc", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}", "<STR_LIT>", "::", "<STR_LIT>", "ShOpcVal", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "ISD", "::", "SRL", ")", ";", "SDValue", "ShOpc", "=", "CurDAG", "->", "getTargetConstant", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "ShOpcVal", ",", "LSB", ")", ",", "dl", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "ShOpc", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "ARM", "::", "MOVsi", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "LSB", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "Width", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opc", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "unsigned", "Shl_imm", "=", "<NUM_LIT>", ";", "if", "(", "isOpcWithIntImmediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "ISD", "::", "SHL", ",", "Shl_imm", ")", ")", "{", "assert", "(", "Shl_imm", ">", "<NUM_LIT>", "&&", "Shl_imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "bad amount in shift node!", "<STR_LIT>", ")", ";", "unsigned", "Srl_imm", "=", "<NUM_LIT>", ";", "if", "(", "isInt32Immediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Srl_imm", ")", ")", "{", "assert", "(", "Srl_imm", ">", "<NUM_LIT>", "&&", "Srl_imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "bad amount in shift node!", "<STR_LIT>", ")", ";", "unsigned", "Width", "=", "<NUM_LIT>", "-", "Srl_imm", "-", "<NUM_LIT>", ";", "int", "LSB", "=", "Srl_imm", "-", "Shl_imm", ";", "if", "(", "LSB", "<", "<NUM_LIT>", ")", "return", "false", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "LSB", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "Width", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opc", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}", "}", "if", "(", "isOpcWithIntImmediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ",", "ISD", "::", "AND", ",", "And_imm", ")", "&&", "isShiftedMask_32", "(", "And_imm", ")", ")", "{", "unsigned", "Srl_imm", "=", "<NUM_LIT>", ";", "unsigned", "LSB", "=", "countTrailingZeros", "(", "And_imm", ")", ";", "if", "(", "isInt32Immediate", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Srl_imm", ")", "&&", "Srl_imm", "==", "LSB", ")", "{", "assert", "(", "Srl_imm", ">", "<NUM_LIT>", "&&", "Srl_imm", "<", "<NUM_LIT>", "&&", "<STR_LIT>", "bad amount in shift node!", "<STR_LIT>", ")", ";", "unsigned", "MSB", "=", "<NUM_LIT>", "-", "countLeadingZeros", "(", "And_imm", ")", ";", "unsigned", "Width", "=", "MSB", "-", "LSB", ";", "SDValue", "Reg0", "=", "CurDAG", "->", "getRegister", "(", "<NUM_LIT>", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "Srl_imm", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "CurDAG", "->", "getTargetConstant", "(", "Width", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "getAL", "(", "CurDAG", ",", "dl", ")", ",", "Reg0", "}", ";", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opc", ",", "MVT", "::", "i32", ",", "Ops", ")", ";", "return", "true", ";", "}" ]

[ ")", ";" ]

[ "Start", "-=", "<NUM_LIT>", "-", "BitsPerElement", ";", "End", "-=", "<NUM_LIT>", "-", "BitsPerElement", ";", "MVT", "VecVT", "=", "MVT", "::", "getVectorVT", "(", "MVT", "::", "getIntegerVT", "(", "BitsPerElement", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "/", "BitsPerElement", ")", ";", "SDValue", "Op", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VecVT", ",", "DAG", ".", "getConstant", "(", "Start", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "DAG", ".", "getConstant", "(", "End", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VT", ",", "Op", ")", ";", "}", "return", "SDValue", "(" ]

[ "<FIXS>", "cl", "::", "init", "(", "true", ")", ")", ";", "<FIXE>" ]

[ "static", "cl", "::", "opt", "bool", ">", "EnableM0Merge", "(", "<STR_LIT>", "amdgpu-enable-merge-m0", "<STR_LIT>", ",", "cl", "::", "desc", "(", "<STR_LIT>", "Merge and hoist M0 initializations", "<STR_LIT>", ")", ",", "<BUGS>", "cl", "::", "init", "(", "false", ")", ")", ";", "<BUGE>", "namespace", "{" ]

[ ")", ")" ]

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

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

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "if", "(", "tryToMergeLdStInst", "(", "MBBI", ")", ")", "{", "Modified", "=", "true", ";", "break", ";", "}", "++", "MBBI", ";", "break", ";", "}", "}", "}", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", ")", "{", "MachineInstr", "*", "MI", "=", "MBBI", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "++", "MBBI", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "if", "(", "tryToPairLdStInst", "(", "MBBI", ")", ")", "{", "Modified", "=", "true", ";", "break", ";", "}", "++", "MBBI", ";", "break", ";", "}", "}", "}", "for", "(", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ",", "E", "=", "MBB", ".", "end", "(", ")", ";", "MBBI", "!=", "E", ";", ")", "{", "MachineInstr", "*", "MI", "=", "MBBI", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "++", "MBBI", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>" ]

[ "static", "int", "msp430_muldiv_costs", "(", "rtx", "src", ",", "rtx", "dst", ",", "bool", "speed", ",", "rtx", "outer_rtx", ",", "machine_mode", "outer_mode", ")", "{", "enum", "rtx_code", "outer_code", "=", "GET_CODE", "(", "outer_rtx", ")", ";", "const", "struct", "msp430_multlib_costs", "*", "cost_p", ";", "cost_p", "=", "(", "msp430_use_16bit_hwmult", "(", ")", "?", "&", "cycle_cost_multlib_32bit", ":", "&", "cycle_cost_multlib_16bit", ")", ";", "int", "factor", "=", "<NUM_LIT>", ";", "int", "mode_factor", "=", "<NUM_LIT>", ";", "if", "(", "outer_mode", "==", "SImode", ")", "mode_factor", "=", "<NUM_LIT>", ";", "else", "if", "(", "outer_mode", "==", "PSImode", ")", "mode_factor", "=", "<NUM_LIT>", ";", "else", "if", "(", "outer_mode", "==", "DImode", ")", "mode_factor", "=", "<NUM_LIT>", ";", "if", "(", "!", "speed", ")", "{", "if", "(", "outer_code", "!=", "MULT", ")", "factor", "=", "<NUM_LIT>", ";", "else", "if", "(", "(", "(", "msp430_use_16bit_hwmult", "(", ")", "&&", "outer_mode", "!=", "DImode", ")", "||", "msp430_use_32bit_hwmult", "(", ")", "||", "msp430_use_f5_series_hwmult", "(", ")", ")", ")", "factor", "=", "<NUM_LIT>", ";", "else", "factor", "=", "<NUM_LIT>", ";", "return", "factor", "*", "mode_factor", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ";", "}", "if", "(", "outer_code", "!=", "MULT", "||", "!", "msp430_has_hwmult", "(", ")", "||", "(", "outer_mode", "==", "DImode", "&&", "msp430_use_16bit_hwmult", "(", ")", ")", ")", "{", "factor", "=", "(", "outer_code", "==", "MULT", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "factor", "*", "mode_factor", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ";", "}", "switch", "(", "outer_mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "return", "cost_p", "->", "mulhi", "+", "(", "<NUM_LIT>", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ")", ";", "case", "E_PSImode", ":", "factor", "=", "<NUM_LIT>", ";", "case", "E_SImode", ":", "return", "factor", "*", "(", "cost_p", "->", "mulsi", "+", "(", "<NUM_LIT>", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ")", ")", ";", "case", "E_DImode", ":", "default", ":", "return", "cost_p", "->", "muldi", "+", "(", "<NUM_LIT>", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ")", ";", "}", "}" ]

[ "Given", "source", "operand", "SRC", "and", "destination", "operand", "DST", "from", "the", "MULT/DIV/MOD", "RTX", "OUTER_RTX", ",", "return", "the", "cost", "of", "performing", "that", "operation", ",", "assuming", "optimization", "for", "speed", "when", "SPEED", "is", "true", "." ]

[ "]" ]

[ "[", "(", "unspec_volatile", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", "UNSPECV_RSTORSSP", ")" ]

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

[ "(", "float", ":", "VSX_F", "(", "match_operand", ":", "<", "VSI", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

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

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

[ "void", "X86InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasVLX", "=", "Subtarget", ".", "hasVLX", "(", ")", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "MOV64rr", ";", "else", "if", "(", "X86", "::", "GR32RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "MOV32rr", ";", "else", "if", "(", "X86", "::", "GR16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "MOV16rr", ";", "else", "if", "(", "X86", "::", "GR8RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "(", "isHReg", "(", "DestReg", ")", "||", "isHReg", "(", "SrcReg", ")", ")", "&&", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Opc", "=", "X86", "::", "MOV8rr_NOREX", ";", "assert", "(", "X86", "::", "GR8_NOREXRegClass", ".", "contains", "(", "SrcReg", ",", "DestReg", ")", "&&", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "}", "else", "Opc", "=", "X86", "::", "MOV8rr", ";", "}", "else", "if", "(", "X86", "::", "VR64RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "MMX_MOVQ64rr", ";", "else", "if", "(", "X86", "::", "VR128XRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "HasVLX", ")", "Opc", "=", "X86", "::", "VMOVAPSZ128rr", ";", "else", "if", "(", "X86", "::", "VR128RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "HasAVX", "?", "X86", "::", "VMOVAPSrr", ":", "X86", "::", "MOVAPSrr", ";", "else", "{", "Opc", "=", "X86", "::", "VMOVAPSZrr", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "DestReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "X86", "::", "sub_xmm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "SrcReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "X86", "::", "sub_xmm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "}", "}", "else", "if", "(", "X86", "::", "VR256XRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "{", "if", "(", "HasVLX", ")", "Opc", "=", "X86", "::", "VMOVAPSZ256rr", ";", "else", "if", "(", "X86", "::", "VR256RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "VMOVAPSYrr", ";", "else", "{", "Opc", "=", "X86", "::", "VMOVAPSZrr", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "DestReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "DestReg", ",", "X86", "::", "sub_ymm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "SrcReg", "=", "TRI", "->", "getMatchingSuperReg", "(", "SrcReg", ",", "X86", "::", "sub_ymm", ",", "&", "X86", "::", "VR512RegClass", ")", ";", "}", "}", "else", "if", "(", "X86", "::", "VR512RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "X86", "::", "VMOVAPSZrr", ";", "else", "if", "(", "X86", "::", "VK16RegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "Opc", "=", "Subtarget", ".", "hasBWI", "(", ")", "?", "X86", "::", "KMOVQkk", ":", "X86", "::", "KMOVWkk", ";", "if", "(", "!", "Opc", ")", "Opc", "=", "CopyToFromAsymmetricReg", "(", "DestReg", ",", "SrcReg", ",", "Subtarget", ")", ";", "if", "(", "Opc", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "if", "(", "SrcReg", "==", "X86", "::", "EFLAGS", "||", "DestReg", "==", "X86", "::", "EFLAGS", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "Unable to copy EFLAGS physical register!", "<STR_LIT>", ")", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Cannot copy ", "<STR_LIT>", "<<", "RI", ".", "getName", "(", "SrcReg", ")", "<<", "<STR_LIT>", " to ", "<STR_LIT>", "<<", "RI", ".", "getName", "(", "DestReg", ")", "<<", "'", "\\n", "'", ")", ";", "llvm_unreachable", "(", "<STR_LIT>", "Cannot emit physreg copy instruction", "<STR_LIT>", ")", ";", "}" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "<STR_LIT>", ")" ]

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

[ "OutStreamer", ".", "getTargetStreamer", "(", ")", ")", ";" ]

[ "return", "static_cast", "<", "WDC65816TargetStreamer", "&", ">", "(" ]

[ ";" ]

[ "bool", "isToken", "(", ")", "const", "{", "return", "Kind", "==", "Token" ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p0s", "-", "isa", "(", "SLOTS", "P0S", ")", "(", "INTRINSIC", "<STR_LIT>", "cpsraa0", "<STR_LIT>", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "qqqqq", "<NUM_LIT>", "<NUM_LIT>", "cpsraa0", "crqp", "(", "p0_1", ")", "(", "dni", "cpsraa0_P0S", "<STR_LIT>", "cpsraa0 $crqp Pn", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "p0s", "-", "isa", "(", "SLOTS", "P0S", ")", "(", "INTRINSIC", "<STR_LIT>", "cpsraa0", "<STR_LIT>", ")", ")", "<BUGE>", "<STR_LIT>", "cpsraa0 $crqp", "<STR_LIT>", "(", "+", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u0", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u8", "#", "x19", ")", "crqp", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u18", "#", "x19", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u23", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u28", "<NUM_LIT>", ")", ")", "(", "sequence", "(", ")" ]

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

[ "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", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "mayStore", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "U", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opcode", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "m256i", "_", "_", "C", ",", "const", "int", "_", "_", "I", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_permute2_ps", "(", "_", "_", "m256", "_", "_", "X", ",", "_", "_", "m256", "_", "_", "Y", ",", "_", "_" ]

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

[ "if", "(", "const", "MCSymbolRefExpr", "*", "SRE", "=", "dyn_cast", "<", "MCSymbolRefExpr", ">", "(", "Val", ")", ")", "if", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_PPC_TLS", ")", "return", "CreateTLSReg", "(", "SRE", ",", "S", ",", "E", ",", "IsPPC64", ")", ";", "if", "(", "const", "PPCMCExpr", "*", "TE", "=", "dyn_cast", "<", "PPCMCExpr", ">" ]

[ "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "bswap", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")" ]

[ "imm", ")", "{" ]

[ "_", "_", "arm_vddupq_n_u8", "(", "uint32_t", "_", "_", "a", ",", "const", "int", "_", "_" ]

[ "reg_class_t", "rclass", ")", "{" ]

[ "static", "reg_class_t", "loongarch_canonicalize_move_class", "(" ]

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "R", ",", "DAG", ".", "getConstant", "(", "RotateAmt", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";" ]

[ "if", "(", "getTargetConstantBitsFromNode", "(", "Amt", ",", "EltSizeInBits", ",", "UndefElts", ",", "EltBits", ")", ")", "{", "if", "(", "!", "UndefElts", "&&", "llvm", "::", "all_of", "(", "EltBits", ",", "[", "EltBits", "]", "(", "APInt", "&", "V", ")", "{", "return", "EltBits", "[", "<NUM_LIT>", "]", "==", "V", ";", "}", ")", ")", "{", "unsigned", "Op", "=", "(", "Opcode", "==", "ISD", "::", "ROTL", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "uint64_t", "RotateAmt", "=", "EltBits", "[", "<NUM_LIT>", "]", ".", "urem", "(", "EltSizeInBits", ")", ";", "return", "DAG", ".", "getNode", "(", "Op", ",", "DL", ",", "VT", ",", "R", ",", "DAG", ".", "getConstant", "(", "RotateAmt", ",", "DL", ",", "MVT", "::", "i8", ")", ")", ";", "}", "}", "return", "Op", ";", "}", "assert", "(", "VT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Custom lowering only for vector rotates!", "<STR_LIT>", ")", ";", "assert", "(", "Subtarget", ".", "hasXOP", "(", ")", "&&", "<STR_LIT>", "XOP support required for vector rotates!", "<STR_LIT>", ")", ";", "assert", "(", "(", "Opcode", "==", "ISD", "::", "ROTL", ")", "&&", "<STR_LIT>", "Only ROTL supported", "<STR_LIT>", ")", ";", "if", "(", "VT", ".", "is256BitVector", "(", ")", ")", "return", "Lower256IntArith", "(", "Op", ",", "DAG", ")", ";", "assert", "(", "VT", ".", "is128BitVector", "(", ")", "&&", "<STR_LIT>", "Only rotate 128-bit vectors!", "<STR_LIT>", ")", ";", "if", "(", "auto", "*", "BVAmt", "=", "dyn_cast", "<", "BuildVectorSDNode", ">", "(", "Amt", ")", ")", "{", "if", "(", "auto", "*", "RotateConst", "=", "BVAmt", "->", "getConstantSplatNode", "(", ")", ")", "{", "uint64_t", "RotateAmt", "=", "RotateConst", "->", "getAPIntValue", "(", ")", ".", "getZExtValue", "(", ")", ";", "assert", "(", "RotateAmt", "<", "EltSizeInBits", "&&", "<STR_LIT>", "Rotation out of range", "<STR_LIT>", ")", ";" ]

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

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

[ "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "MVT", "::", "Other", ",", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "SType", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "unsigned", "SType", "=", "<NUM_LIT>", ";", "DebugLoc", "DL", "=", "Op", ".", "getDebugLoc", "(", ")", ";" ]

[ "FI", ")", "{" ]

[ "void", "setGPFI", "(", "int" ]

[ "<FIXS>", "increment_stack", "(", "-", "(", "signed", ")", "init_stack_alloc", ")", ";", "<FIXE>" ]

[ "offset", "=", "init_stack_alloc", "-", "<NUM_LIT>", ";", "if", "(", "init_stack_alloc", ")", "<BUGS>", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "(", "signed", ")", "init_stack_alloc", ")", ")", ")", ";", "<BUGE>", "if", "(", "num_save", ">", "<NUM_LIT>", "&&", "REGNO", "(", "save_regs", "[", "num_save", "-", "<NUM_LIT>", "]", ")", "==", "LINK_POINTER_REGNUM", ")" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_tfrf", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_2op", ">", ",", "PredNewRel", ",", "ImmRegRel", "{", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPseudo", "=" ]

[ "f", "'", ":" ]

[ "else", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "}", "return", ";", "case", "'", "S", "'", ":", "{", "struct", "s390_address", "ad", ";", "int", "ret", ";", "if", "(", "!", "MEM_P", "(", "x", ")", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "memory reference expected for ", "<STR_LIT>", "<STR_LIT>", "'S' output modifier", "<STR_LIT>", ")", ";", "return", ";", "}", "ret", "=", "s390_decompose_address", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "&", "ad", ")", ";", "if", "(", "!", "ret", "||", "(", "ad", ".", "base", "&&", "!", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "ad", ".", "base", ")", ")", ")", "||", "ad", ".", "indx", ")", "{", "output_operand_lossage", "(", "<STR_LIT>", "invalid address for 'S' output modifier", "<STR_LIT>", ")", ";", "return", ";", "}", "if", "(", "ad", ".", "disp", ")", "output_addr_const", "(", "file", ",", "ad", ".", "disp", ")", ";", "else", "fprintf", "(", "file", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ")", ";", "if", "(", "ad", ".", "base", ")", "fprintf", "(", "file", ",", "<STR_LIT>", "(%s)", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "ad", ".", "base", ")", "]", ")", ";", "}", "return", ";", "case", "'", "N", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "x", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "x", ")", ",", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "x", "=", "change_address", "(", "x", ",", "VOIDmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "register or memory expression expected ", "<STR_LIT>", "<STR_LIT>", "for 'N' output modifier", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "M", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", "x", "=", "gen_rtx_REG", "(", "GET_MODE", "(", "x", ")", ",", "REGNO", "(", "x", ")", "+", "<NUM_LIT>", ")", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", ")", "x", "=", "change_address", "(", "x", ",", "VOIDmode", ",", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ")", ";", "else", "output_operand_lossage", "(", "<STR_LIT>", "register or memory expression expected ", "<STR_LIT>", "<STR_LIT>", "for 'M' output modifier", "<STR_LIT>", ")", ";", "break", ";", "case", "'", "Y", "'", ":", "print_shift_count_operand", "(", "file", ",", "x", ")", ";", "return", ";", "}", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "<STR_LIT>", "%s", "<STR_LIT>", ",", "reg_names", "[", "REGNO", "(", "x", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "CONST", ":", "case", "CODE_LABEL", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "break", ";", "case", "CONST_INT", ":", "ival", "=", "INTVAL", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "<NUM_LIT>", ":", "break", ";", "case", "'", "b", "'", ":", "ival", "&=", "<NUM_LIT>", ";", "break", ";", "case", "'", "c", "'", ":", "ival", "=", "(", "(", "ival", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "break", ";", "case", "'", "x", "'", ":", "ival", "&=", "<NUM_LIT>", ";", "break", ";", "case", "'", "h", "'", ":", "ival", "=", "(", "(", "ival", "&", "<NUM_LIT>", ")", "^", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "break", ";", "case", "'", "i", "'", ":", "ival", "=", "s390_extract_part", "(", "x", ",", "HImode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "j", "'", ":", "ival", "=", "s390_extract_part", "(", "x", ",", "HImode", ",", "-", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "k", "'", ":", "ival", "=", "s390_extract_part", "(", "x", ",", "SImode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "m", "'", ":", "ival", "=", "s390_extract_part", "(", "x", ",", "SImode", ",", "-", "<NUM_LIT>", ")", ";", "break", ";", "case", "'", "o", "'", ":", "ival", "&=", "<NUM_LIT>", ";", "break", ";", "case", "'", "e", "'", ":", "case", "'" ]

[ "}", ";" ]

[ "field", "bits", "<", "<NUM_LIT>", ">", "Inst", ";", "field", "bits", "<", "<NUM_LIT>", ">", "SoftFail", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "V1", ";", "bits", "<", "<NUM_LIT>", ">", "V2", ";", "bits", "<", "<NUM_LIT>", ">", "V3", ";", "bits", "<", "<NUM_LIT>", ">", "V4", ";", "bits", "<", "<NUM_LIT>", ">", "M5", ";", "bits", "<", "<NUM_LIT>", ">", "M6", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "<FIXS>", "I", "(", "outs", ")", ",", "(", "ins", "TypeIndex", ":", "$", "type", ",", "i32imm", ":", "$", "flags", ",", "variable_ops", ")", ",", "(", "outs", ")", ",", "(", "ins", "TypeIndex", ":", "$", "type", ",", "i32imm", ":", "$", "flags", ")", ",", "[", "]", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ">", ";", "<FIXE>" ]

[ "let", "variadicOpsAreDefs", "=", "<NUM_LIT>", "indefm", "CALL_INDIRECT", ":", "<BUGS>", "I", "(", "outs", ")", ",", "(", "ins", "TypeIndex", ":", "$", "type", ",", "table32_op", ":", "$", "table", ",", "variable_ops", ")", ",", "(", "outs", ")", ",", "(", "ins", "TypeIndex", ":", "$", "type", ",", "table32_op", ":", "$", "table", ")", ",", "[", "]", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<NUM_LIT>", ">", ";", "<BUGE>", "let", "isReturn", "=", "<NUM_LIT>", ",", "isTerminator", "=", "<NUM_LIT>", ",", "hasCtrlDep", "=", "<NUM_LIT>", ",", "isBarrier", "=", "<NUM_LIT>", "indefm", "RET_CALL", ":" ]

[ "void", "BPFRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected", "<STR_LIT>", ")", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "if", "(", "!", "DL", ")", "for", "(", "auto", "&", "I", ":", "MBB", ")", "if", "(", "I", ".", "getDebugLoc", "(", ")", ")", "{", "DL", "=", "I", ".", "getDebugLoc", "(", ")", ";", "break", ";", "}", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "<STR_LIT>", "Instr doesn't have FrameIndex operand!", "<STR_LIT>", ")", ";", "}", "Register", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "i", ")", ".", "getIndex", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "WarnSize", "(", "Offset", ",", "MF", ",", "DL", ")", ";", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "Register", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "return", ";", "}", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", "+", "MI", ".", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isInt", "<", "<NUM_LIT>", ">", "(", "Offset", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "bug in frame offset", "<STR_LIT>", ")", ";", "WarnSize", "(", "Offset", ",", "MF", ",", "DL", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "Register", "reg", "=", "MI", ".", "getOperand", "(", "i", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "++", "II", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg", ")", ".", "addReg", "(", "FrameReg", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "DL", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "reg", ")", ".", "addReg", "(", "reg", ")", ".", "addImm", "(", "Offset", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "}", "else", "{", "MI", ".", "getOperand", "(", "i", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "i", "+", "<NUM_LIT>", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "}" ]

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

[ ")", ";" ]

[ "}", "OutStreamer", "->", "emitLabel", "(", "GetCPISymbol", "(", "LabelId", ")", ")", ";", "const", "MachineConstantPoolEntry", "&", "MCPE", "=", "MCP", "->", "getConstants", "(", ")", "[", "CPIdx", "]", ";", "if", "(", "MCPE", ".", "isMachineConstantPoolEntry", "(", ")", ")", "emitMachineConstantPoolValue", "(", "MCPE", ".", "Val", ".", "MachineCPVal", ")", ";", "else", "emitGlobalConstant", "(", "MF", "->", "getDataLayout", "(", ")", ",", "MCPE", ".", "Val", ".", "ConstVal", ")", ";", "return", ";", "}", "switch", "(", "Opc", ")", "{", "case", "Mips", "::", "PATCHABLE_FUNCTION_ENTER", ":", "LowerPATCHABLE_FUNCTION_ENTER", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_FUNCTION_EXIT", ":", "LowerPATCHABLE_FUNCTION_EXIT", "(", "*", "MI", ")", ";", "return", ";", "case", "Mips", "::", "PATCHABLE_TAIL_CALL", ":", "LowerPATCHABLE_TAIL_CALL", "(", "*", "MI", ")", ";", "return", ";", "}", "if", "(", "EmitJalrReloc", "&&", "(", "MI", "->", "isReturn", "(", ")", "||", "MI", "->", "isCall", "(", ")", "||", "MI", "->", "isIndirectBranch", "(", ")", ")", ")", "{", "emitDirectiveRelocJalr", "(", "*", "MI", ",", "OutContext", ",", "TM", ",", "*", "OutStreamer", ",", "*", "Subtarget", ")", ";", "}", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", "->", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "do", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ")", "continue", ";", "if", "(", "I", "->", "isBundle", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoReturn64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "PseudoIndirectBranch64", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG", "||", "I", "->", "getOpcode", "(", ")", "==", "Mips", "::", "TAILCALLREG64", ")", "{", "emitPseudoIndirectBranch", "(", "*", "OutStreamer", ",", "&", "*", "I", ")", ";", "continue", ";", "}", "if", "(", "I", "->", "isPseudo", "(", ")", "&&", "!", "Subtarget", "->", "inMips16Mode", "(", ")", "&&", "!", "isLongBranchPseudo", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "llvm_unreachable", "(", "<STR_LIT>", "Pseudo opcode found in emitInstruction()", "<STR_LIT>", ")", ";", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "&", "*", "I", ",", "TmpInst0", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst0" ]

[ "&", "new", "_", "opts_set", ")", ";" ]

[ "if", "(", "!", "s390_valid_target_attribute_inner_p", "(", "args", ",", "opts", ",", "&", "new", "_", "opts_set", ",", "force_pragma", ")", ")", "return", "error_mark_node", ";", "if", "(", "new", "_", "opts_set", ".", "x_target_flags", "||", "new", "_", "opts_set", ".", "x_s390_arch", "||", "new", "_", "opts_set", ".", "x_s390_tune", "||", "new", "_", "opts_set", ".", "x_s390_stack_guard", "||", "new", "_", "opts_set", ".", "x_s390_stack_size", "||", "new", "_", "opts_set", ".", "x_s390_branch_cost", "||", "new", "_", "opts_set", ".", "x_s390_warn_framesize", "||", "new", "_", "opts_set", ".", "x_s390_warn_dynamicstack_p", ")", "{", "const", "unsigned", "char", "*", "src", "=", "(", "const", "unsigned", "char", "*", ")", "opts_set", ";", "unsigned", "char", "*", "dest", "=", "(", "unsigned", "char", "*", ")", "&", "new", "_", "opts_set", ";", "unsigned", "int", "i", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "sizeof", "(", "*", "opts_set", ")", ";", "i", "++", ")", "dest", "[", "i", "]", "|=", "src", "[", "i", "]", ";", "s390_option_override_internal", "(", "false", ",", "opts", "," ]

[ "int", "SparcFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SparcRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "const", "SparcMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SparcMachineFunctionInfo", ">", "(", ")", ";", "bool", "isFixed", "=", "MFI", ".", "isFixedObjectIndex", "(", "FI", ")", ";", "bool", "UseFP", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "if", "(", "isFixed", ")", "{", "UseFP", "=", "true", ";", "}", "else", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "UseFP", "=", "false", ";", "}", "else", "{", "UseFP", "=", "true", ";", "}", "int64_t", "FrameOffset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", "+", "Subtarget", ".", "getStackPointerBias", "(", ")", ";", "if", "(", "UseFP", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FrameOffset", ";", "}", "else", "{", "FrameReg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "FrameOffset", "+", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "}", "}" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "MCNumEmitted", ";" ]

[ "MCFixupKind", "Fixup", "=", "MCFixupKind", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getExpr", "(", ")", ",", "Fixup", ")", ")", ";", "return", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "return", ";", "}", "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint32_t", ">", "(", "OS", ",", "Binary", ",", "support", "::", "little", ")", ";", "++" ]

[ "<FIXS>", "case", "<NUM_LIT>", ":", "<FIXE>" ]

[ "switch", "(", "OpSize", ")", "{", "<BUGS>", "case", "<NUM_LIT>", ":", "{", "<BUGE>", "if", "(", "isInt", "<NUM_LIT>", ">", "(", "Val", ")", "&&", "AMDGPU", "::", "isInlinableLiteral32", "(", "static_cast", "int32_t", ">", "(", "Val", ")", ",", "AsmParser", "->", "hasInv2PiInlineImm", "(", ")", ")", ")", "{" ]

[ "<", "GPRC", ">", ";" ]

[ "def", "r128", ":", "LRRegInst" ]

[ "TargetSupported", "=", "(", "(", "Subtarget", "->", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "&&", "(", "Subtarget", "->", "hasMips32r2", "(", ")", "&&", "(", "Subtarget", "->", "isABI_O32", "(", ")", ")", ")", ")", ";" ]

[ "MFI", "=", "funcInfo", ".", "MF", "->", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "Context", "=", "&", "funcInfo", ".", "Fn", "->", "getContext", "(", ")", ";" ]

[ "(", "CVI_XLANE", ",", "<NUM_LIT>", ")", ";" ]

[ "void", "HexagonCVIResource", "::", "SetupTUL", "(", "TypeUnitsAndLanes", "*", "TUL", ",", "StringRef", "CPU", ")", "{", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", "|", "CVI_SHIFT", "|", "CVI_MPY0", "|", "CVI_MPY1", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", "|", "CVI_MPY0", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_MPY0", "|", "CVI_MPY1", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_MPY0", "|", "CVI_MPY1", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_MPY0", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_SHIFT", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "(", "CPU", "==", "<STR_LIT>", "hexagonv60", "<STR_LIT>", ")", "?", "UnitsAndLanes", "(", "CVI_SHIFT", ",", "<NUM_LIT>", ")", ":", "UnitsAndLanes", "(", "CVI_XLANE", "|", "CVI_SHIFT", "|", "CVI_MPY0", "|", "CVI_MPY1", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", "|", "CVI_SHIFT", "|", "CVI_MPY0", "|", "CVI_MPY1", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_NONE", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", "|", "CVI_SHIFT", "|", "CVI_MPY0", "|", "CVI_MPY1", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_NONE", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes", "(", "CVI_XLANE", ",", "<NUM_LIT>", ")", ";", "(", "*", "TUL", ")", "[", "<STR_LIT>", "::", "<STR_LIT>", "]", "=", "UnitsAndLanes" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ ")", ";" ]

[ "else", "if", "(", "mips_rewrite_small_data_p", "(", "*", "loc", ",", "context", ")", ")", "{", "*", "loc", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "pic_offset_table_rtx", ",", "*", "loc", ")", ";", "iter", ".", "skip_subrtxes", "(" ]

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

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

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

[ "(", "if_then_else", "(", "ne", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "label_ref", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "pc", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "(", "unspec", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_LSETUP_END", ")", "(", "clobber", "(", "match_scratch", ":", "SI", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>" ]

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

[ "def", "VecListTwoQHWordIndexAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";" ]

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

[ "void", "TPCPassConfig", "::" ]

[ "}" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "llwpcb", "(", "void", "*", "pcbAddress", ")", "{", "_", "_", "builtin_ia32_llwpcb", "(", "pcbAddress", ")", ";" ]

[ "void", "AArch64InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "bool", "Offset", "=", "true", ";", "switch", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ")", "{", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "assert", "(", "SrcReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", ")", "MF", ".", "getRegInfo", "(", ")", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "else", "assert", "(", "SrcReg", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "storeRegPairToStackSlot", "(", "getRegisterInfo", "(", ")", ",", "MBB", ",", "MBBI", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "SrcReg", ",", "isKill", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FI", ",", "MMO", ")", ";", "return", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "storeRegPairToStackSlot", "(", "getRegisterInfo", "(", ")", ",", "MBB", ",", "MBBI", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "SrcReg", ",", "isKill", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FI", ",", "MMO", ")", ";", "return", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "assert", "(", "Subtarget", ".", "hasNEON", "(", ")", "&&", "<STR_LIT>", "Unexpected register store without NEON", "<STR_LIT>", ")", ";", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Offset", "=", "false", ";", "}", "break", ";", "}", "assert", "(", "Opc", "&&", "<STR_LIT>", "Unknown register class", "<STR_LIT>", ")", ";", "const", "MachineInstrBuilder", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ";", "if", "(", "Offset", ")", "MI", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "MI", ".", "addMemOperand", "(", "MMO", ")", ";", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_slli_epi64", "(", "_", "_", "m128i", "_", "_", "A", ",", "int", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_psllqi128", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "_", "_", "B", ")", ";" ]

[ "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m256", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_cvt_roundepi64_ps", "(", "_", "_", "m512i", "_", "_", "A", ",", "const" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "bool", "ARMConstantIslands", "::", "OffsetIsInRange", "(", "unsigned", "UserOffset", ",", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "}", "<BUGS>", "<BUGE>", "<BUGS>", "bool", "ARMConstantIslands", "::", "OffsetIsInRange", "(", "unsigned", "UserOffset", ",", "<BUGE>", "unsigned", "TrialOffset", ",", "unsigned", "MaxDisp", ",", "bool", "NegativeOK", ")", "{", "<BUGS>", "<BUGE>", "if", "(", "isThumb", "&&", "UserOffset", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")" ]

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

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

[ "}" ]

[ "bool", "hasStandardEncoding", "(", ")", "const", "{", "return", "!", "InMips16Mode", "&&", "!", "InMicroMipsMode", ";" ]

[ "<STR_LIT>", ";" ]

[ "def", "SwitchRhuAsmOperand", ":", "AsmOperandClass", "{", "let", "Name", "=", "<STR_LIT>", ";", "let", "ParserMethod", "=" ]

[ ";" ]

[ "case", "Hexagon", "::", "A2_sxtw", ":", "Signed", "=", "true", ";", "break", ";", "}", "Register", "DefR", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "unsigned", "BW", "=", "getRegBitWidth", "(", "DefR", ".", "Reg", ")", ";", "LatticeCell", "RC", "=", "Outputs", ".", "get", "(", "DefR", ".", "Reg", ")", ";", "bool", "Eval", "=", "Signed", "?", "evaluateSEXTr", "(", "R1", ",", "BW", ",", "Bits", ",", "Inputs", ",", "RC", ")", ":", "evaluateZEXTr", "(", "R1", ",", "BW", ",", "Bits", ",", "Inputs", ",", "RC", ")", ";", "if", "(", "!", "Eval", ")", "return", "false" ]

[ "a", ",", "_", "_", "b", ")", ";" ]

[ "return", "_", "_", "builtin_mve_vmaxq_uv4si", "(", "_", "_" ]

[ "void", "TPCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "int", "StoreOpCode", "=", "<NUM_LIT>", ";", "uint8_t", "StackID", "=", "<NUM_LIT>", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "getTargetMachine", "(", ")", ".", "Options", ".", "LongIRF", ")", "report_fatal_error", "(", "<STR_LIT>", "IRF registers are not spillable if -long-irf is specified", "<STR_LIT>", ")", ";", "StoreOpCode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "StackID", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "else", "{", "report_fatal_error", "(", "<STR_LIT>", "Unsupported register class in StoreToStack", "<STR_LIT>", ")", ";", "}", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "StackID", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "StoreOpCode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "explicit", "VEMachineFunctionInfo", "(", "MachineFunction", "&", "MF", ")", ":", "VarArgsFrameOffset", "(", "<NUM_LIT>", ")", ",", "IsLeafProc", "(", "false", ")", "{" ]

[ "VEMachineFunctionInfo", "(", "const", "Function", "&", "F", ",", "const", "TargetSubtargetInfo", "*", "STI", ")", ":", "VarArgsFrameOffset", "(", "<NUM_LIT>", ")", ",", "IsLeafProc", "(", "false", ")", "{", "}" ]

[ "OutStreamer", "->", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";" ]

[ "if", "(", "CurrentFnSym", "->", "isDefined", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "'", "<STR_LIT>", "+", "Twine", "(", "CurrentFnSym", "->", "getName", "(", ")", ")", "+", "<STR_LIT>", "' label emitted multiple times to assembly file", "<STR_LIT>", ")", ";", "OS", "<<", "<STR_LIT>", "(func ", "<STR_LIT>", "<<", "toSymbol", "(", "CurrentFnSym", "->", "getName", "(", ")", ")", ";" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rtt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rss32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rss32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rdd32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rdd32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Pe4", ";" ]

[ ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "if", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isFI", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "FrameIndex", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "<NUM_LIT>" ]

[ "Rt32", ";" ]

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

[ "_", "_", "imm", ")", ";" ]

[ "_", "_", "arm_vidupq_n_u16", "(", "uint32_t", "_", "_", "a", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "_", "_", "builtin_mve_vidupq_n_uv8hi", "(", "_", "_", "a", "," ]

[ ")", "(", "match_dup", "<NUM_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "SI", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "T_REG", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "ior", ":", "SI", "(", "ashift", ":", "SI", "(", "match_dup", "<NUM_LIT>" ]

[ "}" ]

[ "vsliq_n_s8", "(", "int8x16_t", "_", "_", "a", ",", "int8x16_t", "_", "_", "b", ",", "const", "int", "_", "_", "c", ")", "{", "return", "(", "int8x16_t", ")", "_", "_", "builtin_neon_vsli_nv16qi", "(", "_", "_", "a", ",", "_", "_", "b", ",", "_", "_", "c", ")", ";" ]

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

[ "(", "match_operand", ":", "<", "tointvec", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_VEC_SRAB", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "<STR_LIT>", ")" ]

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

[ "(", "eq", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "cond", "[", "(", "eq", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_string", "<STR_LIT>", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "smin", ":", "V4SI", "(", "match_operand", ":", "V4SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "gcc_assert", "(", "val_in", "!=", "<NUM_LIT>", ")", ";", "return", "(", "(", "HOST_WIDE_INT_UC", "(", "<NUM_LIT>", ")", "<<", "highest_bit_set", ")", "-", "(", "HOST_WIDE_INT_1U", "<<", "lowest_bit_set", ")", ")", ";" ]

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

[ "[", "(", "set", "(", "reg", "CC_REGNUM", ")", "(", "compare", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

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

[ "def", "FeatureLPM", ":", "SubtargetFeature", "<", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_mask_fcmul_pch", "(", "_", "_", "m128h", "_", "_", "A", ",", "_", "_", "mmask8", "_", "_", "B", ",", "_", "_", "m128h", "_", "_", "C", ",", "_", "_", "m128h", "_", "_", "D", ")", "{", "return", "(", "_", "_", "m128h", ")", "_", "_", "builtin_ia32_vfcmulcph128_mask", "(", "(", "_", "_", "v8hf", ")", "_", "_", "C", ",", "(", "_", "_", "v8hf", ")", "_", "_", "D", ",", "(", "_", "_", "v8hf", ")", "_", "_", "A", ",", "_", "_", "B", ")", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_BITREV", ")", ")", "]", "<STR_LIT>" ]

[ "genMuxInBlock", "(", "I", ")", ";" ]

[ "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "HRI", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "I", ":", "MF", ")", "Changed", "|=" ]

[ "stackSize", ",", "returnReg", ")", ";" ]

[ "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "getTargetStreamer", "(", ")", ".", "emitFrame", "(", "stackReg", "," ]

[ "(", "OpSrc", ")", ";" ]

[ "static", "bool", "isVectorShiftRight", "(", "ShuffleVectorSDNode", "*", "SVOp", ",", "SelectionDAG", "&", "DAG", ",", "bool", "&", "isLeft", ",", "SDValue", "&", "ShVal", ",", "unsigned", "&", "ShAmt", ")", "{", "unsigned", "NumElems", "=", "SVOp", "->", "getValueType", "(", "<NUM_LIT>", ")", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "NumZeros", "=", "getNumOfConsecutiveZeros", "(", "SVOp", ",", "NumElems", ",", "false", ",", "DAG", ")", ";", "unsigned", "OpSrc", ";", "if", "(", "!", "NumZeros", ")", "return", "false", ";", "if", "(", "!", "isShuffleMaskConsecutive", "(", "SVOp", ",", "<NUM_LIT>", ",", "NumElems", "-", "NumZeros", ",", "NumZeros", ",", "NumElems", ",", "OpSrc", ")", ")", "return", "false", ";", "isLeft", "=", "false", ";", "ShAmt", "=", "NumZeros", ";", "ShVal", "=", "SVOp", "->", "getOperand" ]

[ ",", "PPC", "::", "F7", ",", "PPC", "::", "F8", "}", ";" ]

[ "break", ";", "case", "MVT", "::", "v4f32", ":", "RC", "=", "Subtarget", ".", "hasQPX", "(", ")", "?", "&", "PPC", "::", "QSRCRegClass", ":", "&", "PPC", "::", "VRRCRegClass", ";", "break", ";", "case", "MVT", "::", "v2f64", ":", "case", "MVT", "::", "v2i64", ":", "RC", "=", "&", "PPC", "::", "VSHRCRegClass", ";", "break", ";", "case", "MVT", "::", "v4f64", ":", "RC", "=", "&", "PPC", "::", "QFRCRegClass", ";", "break", ";", "case", "MVT", "::", "v4i1", ":", "RC", "=", "&", "PPC", "::", "QBRCRegClass", ";", "break", ";", "}", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "RC", ")", ";", "SDValue", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "ValVT", "==", "MVT", "::", "i1", "?", "MVT", "::", "i32", ":", "ValVT", ")", ";", "if", "(", "ValVT", "==", "MVT", "::", "i1", ")", "ArgValue", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "dl", ",", "MVT", "::", "i1", ",", "ArgValue", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "else", "{", "assert", "(", "VA", ".", "isMemLoc", "(", ")", ")", ";", "unsigned", "ArgSize", "=", "VA", ".", "getLocVT", "(", ")", ".", "getStoreSize", "(", ")", ";", "int", "FI", "=", "MFI", "->", "CreateFixedObject", "(", "ArgSize", ",", "VA", ".", "getLocMemOffset", "(", ")", ",", "isImmutable", ")", ";", "SDValue", "FIN", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "PtrVT", ")", ";", "InVals", ".", "push_back", "(", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIN", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "ByValArgLocs", ";", "CCState", "CCByValInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ByValArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCByValInfo", ".", "AllocateStack", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ",", "PtrByteSize", ")", ";", "CCByValInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_PPC32_SVR4_ByVal", ")", ";", "unsigned", "MinReservedArea", "=", "CCByValInfo", ".", "getNextStackOffset", "(", ")", ";", "MinReservedArea", "=", "std", "::", "max", "(", "MinReservedArea", ",", "LinkageSize", ")", ";", "MinReservedArea", "=", "EnsureStackAlignment", "(", "Subtarget", ".", "getFrameLowering", "(", ")", ",", "MinReservedArea", ")", ";", "FuncInfo", "->", "setMinReservedArea", "(", "MinReservedArea", ")", ";", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "MemOps", ";", "if", "(", "isVarArg", ")", "{", "static", "const", "MCPhysReg", "GPArgRegs", "[", "]", "=", "{", "PPC", "::", "R3", ",", "PPC", "::", "R4", ",", "PPC", "::", "R5", ",", "PPC", "::", "R6", ",", "PPC", "::", "R7", ",", "PPC", "::", "R8", ",", "PPC", "::", "R9", ",", "PPC", "::", "R10", ",", "}", ";", "const", "unsigned", "NumGPArgRegs", "=", "array_lengthof", "(", "GPArgRegs", ")", ";", "static", "const", "MCPhysReg", "FPArgRegs", "[", "]", "=", "{", "PPC", "::", "F1", ",", "PPC", "::", "F2", ",", "PPC", "::", "F3", ",", "PPC", "::", "F4", ",", "PPC", "::", "F5", ",", "PPC", "::", "F6" ]

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

[ "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>", ";" ]

[ ">", "<NUM_LIT>", ")", "{" ]

[ "uint64_t", "d", ";", "}", "new", "_", "val", ";", "bool", "to_replace", "=", "false", ";", "SDLoc", "DL", "(", "Node", ")", ";", "const", "LoadSDNode", "*", "LD", "=", "cast", "<", "LoadSDNode", ">", "(", "Node", ")", ";", "uint64_t", "size", "=", "LD", "->", "getMemOperand", "(", ")", "->", "getSize", "(", ")", ";", "if", "(", "!", "size", "||", "size", ">", "<NUM_LIT>", "||", "(", "size", "&", "(", "size", "-", "<NUM_LIT>", ")", ")", ")", "return", ";", "SDNode", "*", "LDAddrNode", "=", "LD", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "unsigned", "opcode", "=", "LDAddrNode", "->", "getOpcode", "(", ")", ";", "if", "(", "opcode", "==", "ISD", "::", "ADD", ")", "{", "SDValue", "OP1", "=", "LDAddrNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "OP2", "=", "LDAddrNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDNode", "*", "OP1N", "=", "OP1", ".", "getNode", "(", ")", ";", "if", "(", "OP1N", "->", "getOpcode", "(", ")", "<=", "ISD", "::", "BUILTIN_OP_END", "||", "OP1N", "->", "getNumOperands", "(", ")", "==", "<NUM_LIT>", ")", "return", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Check candidate load: ", "<STR_LIT>", ";", "LD", "->", "dump", "(", ")", ";", "dbgs", "(", ")", "<<", "'", "\\n", "'", ")", ";", "const", "GlobalAddressSDNode", "*", "GADN", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "OP1N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", ";", "const", "ConstantSDNode", "*", "CDN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "OP2", ".", "getNode", "(", ")", ")", ";", "if", "(", "GADN", "&&", "CDN", ")", "to_replace", "=", "getConstantFieldValue", "(", "GADN", ",", "CDN", "->", "getZExtValue", "(", ")", ",", "size", ",", "new", "_", "val", ".", "c", ")", ";", "}", "else", "if", "(", "LDAddrNode", "->", "getOpcode", "(", ")", ">", "ISD", "::", "BUILTIN_OP_END", "&&", "LDAddrNode", "->", "getNumOperands", "(", ")" ]

[ "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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";" ]

[ "Error", "=", "SHUFFLE_ERROR_SLOTS", ";" ]

[ "}", "ISJ", "->", "Core", ".", "setUnits", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "&", "slotJump", ")", ";", "slotJump", ">>=", "<NUM_LIT>", ";", "}", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "*", "ID", ")", ".", "mayLoad", "(", ")", ")", "{", "if", "(", "loads", "==", "<NUM_LIT>", "&&", "loads", "==", "memory", ")", "ISJ", "->", "Core", ".", "setUnits", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "&", "slotSingleLoad", ")", ";", "}", "if", "(", "HexagonMCInstrInfo", "::", "getDesc", "(", "MCII", ",", "*", "ID", ")", ".", "mayStore", "(", ")", ")", "{", "if", "(", "!", "store0", ")", "{", "if", "(", "stores", "==", "<NUM_LIT>", ")", "ISJ", "->", "Core", ".", "setUnits", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "&", "slotSingleStore", ")", ";", "else", "if", "(", "stores", ">", "<NUM_LIT>", ")", "{", "if", "(", "slotLoadStore", "<", "slotLastLoadStore", ")", "{", "Error", "=", "SHUFFLE_ERROR_STORES", ";", "return", "false", ";", "}", "ISJ", "->", "Core", ".", "setUnits", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "&", "slotLoadStore", ")", ";", "slotLoadStore", ">>=", "<NUM_LIT>", ";", "}", "}", "if", "(", "store1", "&&", "stores", ">", "<NUM_LIT>", ")", "{", "Error", "=", "SHUFFLE_ERROR_STORES", ";", "return", "false", ";", "}", "}", "if", "(", "ISJ", "->", "Core", ".", "getUnits", "(", ")", "==", "slotThree", ")", "bOnlySlot3", "=", "true", ";", "if", "(", "!", "ISJ", "->", "Core", ".", "getUnits", "(", ")", ")", "{", "Error", "=", "SHUFFLE_ERROR_NOSLOTS", ";", "return", "false", ";", "}", "}", "bool", "validateSlots", "=", "true", ";", "if", "(", "bOnlySlot3", "==", "false", "&&", "pSlot3Cnt", "==", "<NUM_LIT>", "&&", "slot3ISJ", "!=", "end", "(", ")", ")", "{", "unsigned", "saveUnits", "=", "slot3ISJ", "->", "Core", ".", "getUnits", "(", ")", ";", "slot3ISJ", "->", "Core", ".", "setUnits", "(", "saveUnits", "&", "slotThree", ")", ";", "HexagonUnitAuction", "AuctionCore", ";", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "bool", "bFail", "=", "false", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", "&&", "bFail", "!=", "true", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "bFail", "=", "true", ";", "if", "(", "!", "bFail", ")", "validateSlots", "=", "false", ";", "else", "for", "(", "iterator", "ISJ", "=", "begin", "(", ")", ";", "ISJ", "!=", "end", "(", ")", ";", "++", "ISJ", ")", "{", "MCInst", "const", "*", "ID", "=", "ISJ", "->", "getDesc", "(", ")", ";", "if", "(", "HexagonMCInstrInfo", "::", "prefersSlot3", "(", "MCII", ",", "*", "ID", ")", ")", "ISJ", "->", "Core", ".", "setUnits", "(", "saveUnits", ")", ";", "}", "}", "if", "(", "validateSlots", ")", "{", "HexagonUnitAuction", "AuctionCore", ";", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", ";", "++", "I", ")", "if", "(", "!", "AuctionCore", ".", "bid", "(", "I", "->", "Core", ".", "getUnits", "(", ")", ")", ")", "{", "Error", "=", "SHUFFLE_ERROR_SLOTS", ";", "return", "false", ";", "}", "}", "{", "HexagonUnitAuction", "AuctionCVI", ";", "std", "::", "sort", "(", "begin", "(", ")", ",", "end", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "for", "(", "iterator", "I", "=", "begin", "(", ")", ";", "I", "!=", "end", "(", ")", ";", "++", "I", ")", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "I", "->", "CVI", ".", "getLanes", "(", ")", ";", "++", "i", ")", "if", "(", "!", "AuctionCVI", ".", "bid", "(", "I", "->", "CVI", ".", "getUnits", "(", ")", "<<", "i", ")", ")", "{" ]

[ "bool", "isX32", "=", "T", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "GNUX32", ";" ]

[ "X86ELFMCAsmInfo", "::", "X86ELFMCAsmInfo", "(", "const", "Triple", "&", "T", ")", "{", "bool", "is64Bit", "=", "T", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ";" ]

[ ",", "ZPR32", ",", "simm8", ">", ";" ]

[ "def", "_S", ":", "sve_int_arith_imm", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "asm" ]

[ "}" ]

[ "case", "CallingConv", "::", "X86_64_SysV", ":", "case", "CallingConv", "::", "X86_ThisCall", ":", "case", "CallingConv", "::", "X86_StdCall", ":", "case", "CallingConv", "::", "X86_VectorCall", ":", "case", "CallingConv", "::", "X86_FastCall", ":", "case", "CallingConv", "::", "Swift", ":", "return", "true", ";", "default", ":", "return", "canGuaranteeTCO", "(", "CC", ")", ";" ]

[ "}" ]

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

[ "virtual", "MachineInstr", "*", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "MachineInstr", "*", "LoadMI", ")", "const", "{", "return", "<NUM_LIT>", ";", "}" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

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

[ "dag", "OutOperandList", "=", "(", "outs", "ROWD", ":", "$", "wd", ")", ";", "dag", "InOperandList", "=", "(", "ins", "ROWS", ":", "$", "ws", ",", "uimm6", ":", "$", "m", ")", ";", "string", "AsmString", "=", "!", "strconcat", "(", "instr_asm" ]

[ "<FIXS>", "emitByte", "(", "modRMByte", "(", "<NUM_LIT>", ",", "RegOpcodeField", ",", "BaseRegNo", ")", ",", "OS", ")", ";", "<FIXE>" ]

[ "if", "(", "BaseRegNo", "!=", "N86", "::", "EBP", ")", "{", "if", "(", "Disp", ".", "isImm", "(", ")", "&&", "Disp", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", "{", "<BUGS>", "emitByte", "(", "modRMByte", "(", "<NUM_LIT>", ",", "RegOpcodeField", ",", "BaseRegNo", ")", ",", "CurByte", ",", "OS", ")", ";", "<BUGE>", "return", ";", "}" ]

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

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

[ "<FIXS>", "return", "<STR_LIT>", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "return", "output_387_reg_move", "(", "insn", ",", "operands", ")", "case", "<NUM_LIT>", ":", "<BUGS>", "return", "<STR_LIT>", "<BUGE>", "default", ":", "gcc_unreachable", "(", ")", "}", "}", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float_extend", ":", "DF", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_insn", "<STR_LIT>" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ "static", "bool", "isConstant", "(", "const", "MachineOperand", "&", "MO", ",", "int64_t", "&", "C", ")", "{", "const", "MachineFunction", "*", "MF", "=", "MO", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "MachineInstr", "*", "Def", "=", "MRI", ".", "getVRegDef", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "Def", ")", "return", "false", ";", "if", "(", "Def", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "G_CONSTANT", ")", "{", "C", "=", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getCImm", "(", ")", "->", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "if", "(", "Def", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "COPY", ")", "return", "isConstant", "(", "Def", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "C", ")", ";", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "we", "know", "the", "value", "of", "all", "bits", "." ]