Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "return", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "VT", ",", "V", ")", ";" ]

[ "if", "(", "Size", "==", "<NUM_LIT>", ")", "{", "V", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v4f32", ",", "V", ")", ";", "int", "SplatMask", "[", "<NUM_LIT>", "]", "=", "{", "EltNo", ",", "EltNo", ",", "EltNo", ",", "EltNo", "}", ";", "V", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v4f32", ",", "dl", ",", "V", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v4f32", ")", ",", "&", "SplatMask", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "if", "(", "Size", "==", "<NUM_LIT>", ")", "{", "int", "SplatMask", "[", "<NUM_LIT>", "]", "=", "{", "EltNo", ",", "EltNo", ",", "EltNo", ",", "EltNo", ",", "EltNo", "+", "<NUM_LIT>", ",", "EltNo", "+", "<NUM_LIT>", ",", "EltNo", "+", "<NUM_LIT>", ",", "EltNo", "+", "<NUM_LIT>", "}", ";", "V", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "dl", ",", "MVT", "::", "v8f32", ",", "V", ")", ";", "V", "=", "DAG", ".", "getVectorShuffle", "(", "MVT", "::", "v8f32", ",", "dl", ",", "V", ",", "DAG", ".", "getUNDEF", "(", "MVT", "::", "v8f32", ")", ",", "&", "SplatMask", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "Vector size not supported", "<STR_LIT>", ")", ";" ]

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

[ "rtx", "comparison_rtx", "(", "void", ")", "const", "{", "return", "setcc", ".", "set_src" ]

[ "}" ]

[ "SDVTList", "ResList", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "BufferLoad", "=", "DAG", ".", "getMemIntrinsicNode", "(", "Opc", ",", "DL", ",", "ResList", ",", "Ops", ",", "IntVT", ",", "MMO", ")", ";", "SDValue", "LoadVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "IntVT", ",", "BufferLoad", ")", ";", "LoadVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "LoadVT", ",", "LoadVal", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "{", "LoadVal", ",", "BufferLoad", ".", "getValue", "(", "<NUM_LIT>", ")", "}", ",", "DL", ")", ";" ]

[ "(", "NewDestSubRC", ")", ";" ]

[ "MachineOperand", "&", "Dest", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "MachineOperand", "&", "Src0", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "DebugLoc", "DL", "=", "Inst", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "Inst", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "get", "(", "Opcode", ")", ";", "const", "TargetRegisterClass", "*", "Src0RC", "=", "Src0", ".", "isReg", "(", ")", "?", "MRI", ".", "getRegClass", "(", "Src0", ".", "getReg", "(", ")", ")", ":", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "const", "TargetRegisterClass", "*", "Src0SubRC", "=", "RI", ".", "getSubRegisterClass", "(", "Src0RC", ",", "AMDGPU", "::", "sub0", ")", ";", "MachineOperand", "SrcReg0Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub0", ",", "Src0SubRC", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "Dest", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "NewDestRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "DestRC", ")", ";", "const", "TargetRegisterClass", "*", "NewDestSubRC", "=", "RI", ".", "getSubRegisterClass", "(", "NewDestRC", ",", "AMDGPU", "::", "sub0", ")", ";", "Register", "DestSub0", "=", "MRI", ".", "createVirtualRegister" ]

[ "unsigned", "LEGInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "if", "(", "MBB", ".", "empty", "(", ")", ")", "return", "<NUM_LIT>", ";", "unsigned", "NumRemoved", "=", "<NUM_LIT>", ";", "auto", "I", "=", "MBB", ".", "end", "(", ")", ";", "do", "{", "--", "I", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "Opc", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", "{", "auto", "ToDelete", "=", "I", ";", "++", "I", ";", "MBB", ".", "erase", "(", "ToDelete", ")", ";", "NumRemoved", "++", ";", "}", "}", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", ";", "return", "NumRemoved", ";", "}" ]

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

[ ")", ",", "(", "<NUM_LIT>", "<<", "(", "rx_max_constant_size", "*", "<NUM_LIT>", ")", ")", ")", ";" ]

[ "if", "(", "rx_max_constant_size", "==", "<NUM_LIT>", "||", "rx_max_constant_size", "==", "<NUM_LIT>", ")", "return", "true", ";", "return", "IN_RANGE", "(", "val", ",", "(", "-", "<NUM_LIT>", "<<", "(", "rx_max_constant_size", "*", "<NUM_LIT>", ")" ]

[ "}" ]

[ "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "CUVal64", ")", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CUVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "J", "'", ":", "if", "(", "CVal64", "<", "-", "<NUM_LIT>", "||", "CVal64", ">", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "K", "'", ":", "if", "(", "CUVal64", "!=", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CUVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "L", "'", ":", "if", "(", "CUVal64", "!=", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CUVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "M", "'", ":", "if", "(", "!", "isUInt", "<", "<NUM_LIT>", ">", "(", "CUVal64", ")", ")", "return", ";", "if", "(", "Ty", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i8", ")", "{", "Ty", "=", "MVT", "::", "i16", ";", "}", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CUVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "N", "'", ":", "if", "(", "CVal64", "!=", "-", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "O", "'", ":", "if", "(", "CUVal64", "!=", "<NUM_LIT>", "&&", "CUVal64", "!=", "<NUM_LIT>", "&&", "CUVal64", "!=", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CUVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "P", "'", ":", "if", "(", "CUVal64", "!=", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CUVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "case", "'", "R", "'", ":", "if", "(", "CVal64", "<", "-", "<NUM_LIT>", "||", "CVal64", ">", "<NUM_LIT>", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "CVal64", ",", "DL", ",", "Ty", ")", ";", "break", ";", "}", "break", ";", "}", "case", "'", "G", "'", ":", "const", "ConstantFPSDNode", "*", "FC", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ")", ";", "if", "(", "!", "FC", "||", "!", "FC", "->", "isZero", "(", ")", ")", "return", ";", "Result", "=", "DAG", ".", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i8", ")", ";", "break", ";" ]

[ "<FIXS>", "(", "float", ":", "DF", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "float", ":", "DF", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "LOADgot", "texternalsym", ":", "$", "addr", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "ARM64LOADgot", "texternalsym", ":", "$", "addr", ")", ",", "(" ]

[ "}" ]

[ "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "MemoryIndexed8Operand", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPR64sp", ":", "$", "base", ",", "i64imm", ":", "$", "offset", ")", ";" ]

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

[ "vcageq_f64", "(", "float64x2_t", "_", "_", "a", ",", "float64x2_t", "_", "_", "b", ")", "{", "return", "vabsq_f64", "(", "_", "_", "a", ")", ">=", "vabsq_f64" ]

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

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

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

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

[ "for", "(", "const", "auto", "Element", ":", "Elements", ")", "{" ]

[ "auto", "TypeEntry", "=", "llvm", "::", "make_unique", "<", "BTFTypeFuncProto", ">", "(", "STy", ",", "VLen", ",", "FuncArgNames", ")", ";", "if", "(", "ForSubprog", ")", "TypeId", "=", "addType", "(", "std", "::", "move", "(", "TypeEntry", ")", ")", ";", "else", "addType", "(", "std", "::", "move", "(", "TypeEntry", ")", ",", "STy", ")", ";" ]

[ ";" ]

[ "case", "Hexagon", "::", "RESTORE_DEALLOC_BEFORE_TAILCALL_V4", ":", "case", "Hexagon", "::", "RESTORE_DEALLOC_BEFORE_TAILCALL_V4_PIC", ":", "return", "true", ";", "}", "return", "false" ]

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

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

[ "}", ")" ]

[ "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "not", ":", "HSI", "(", "match_operand", ":", "HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "plus", ":", "HSI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_operand", ":", "HSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "{", "operands", "[", "<NUM_LIT>", "]", "=", "gen_reg_rtx", "(", "<", "MODE", ">", "mode", ")" ]

[ "}" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "SysCRAsmOperand", ";" ]

[ "<STR_LIT>", ")" ]

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

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

[ "bits", "<", "<NUM_LIT>", ">", "src1", ";", "bits", "<", "<NUM_LIT>", ">", "src2", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "offsetBits", ";", "string", "ImmOpStr", "=", "!", "cast", "<", "string", ">", "(", "ImmOp", ")", ";", "let", "offsetBits", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "offset", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ")", ")", ")", ";", "let", "isNVStorable", "=", "!", "if", "(", "!", "eq", "(", "ImmOpStr", ",", "<STR_LIT>", ")", ",", "<NUM_LIT>", ",", "!", "if", "(", "isHalf", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ";", "let", "IClass", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "_", "_", "crc32ch", "(", "uint32_t", "_", "_", "a", ",", "uint16_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_aarch64_crc32ch", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "static", "tree", "rs6000_handle_altivec_attribute", "(", "tree", "*", "node", ",", "tree", "name", "ATTRIBUTE_UNUSED", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "type", "=", "*", "node", ",", "result", "=", "NULL_TREE", ";", "enum", "machine_mode", "mode", ";", "int", "unsigned_p", ";", "char", "altivec_type", "=", "(", "(", "args", "&&", "TREE_CODE", "(", "args", ")", "==", "TREE_LIST", "&&", "TREE_VALUE", "(", "args", ")", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "IDENTIFIER_NODE", ")", "?", "*", "IDENTIFIER_POINTER", "(", "TREE_VALUE", "(", "args", ")", ")", ":", "'", "?", "'", ")", ";", "while", "(", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "type", "==", "long_unsigned_type_node", "||", "type", "==", "long_integer_type_node", ")", "{", "if", "(", "TARGET_64BIT", ")", "error", "(", "<STR_LIT>", "use of %<long%> in AltiVec types is invalid for 64-bit code", "<STR_LIT>", ")", ";", "else", "if", "(", "rs6000_warn_altivec_long", ")", "warning", "(", "<NUM_LIT>", ",", "<STR_LIT>", "use of %<long%> in AltiVec types is deprecated; use %<int%>", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "type", "==", "long_long_unsigned_type_node", "||", "type", "==", "long_long_integer_type_node", ")", "error", "(", "<STR_LIT>", "use of %<long long%> in AltiVec types is invalid", "<STR_LIT>", ")", ";", "else", "if", "(", "type", "==", "double_type_node", ")", "error", "(", "<STR_LIT>", "use of %<double%> in AltiVec types is invalid", "<STR_LIT>", ")", ";", "else", "if", "(", "type", "==", "long_double_type_node", ")", "error", "(", "<STR_LIT>", "use of %<long double%> in AltiVec types is invalid", "<STR_LIT>", ")", ";", "else", "if", "(", "type", "==", "boolean_type_node", ")", "error", "(", "<STR_LIT>", "use of boolean types in AltiVec types is invalid", "<STR_LIT>", ")", ";", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "error", "(", "<STR_LIT>", "use of %<complex%> in AltiVec types is invalid", "<STR_LIT>", ")", ";", "switch", "(", "altivec_type", ")", "{", "case", "'", "v", "'", ":", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V4SI_type_node", ":", "V4SI_type_node", ")", ";", "break", ";", "case", "HImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V8HI_type_node", ":", "V8HI_type_node", ")", ";", "break", ";", "case", "QImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V16QI_type_node", ":", "V16QI_type_node", ")", ";", "break", ";", "case", "SFmode", ":", "result", "=", "V4SF_type_node", ";", "break", ";", "case", "V4SImode", ":", "case", "V8HImode", ":", "case", "V16QImode", ":", "case", "V4SFmode", ":", "result", "=", "type", ";", "default", ":", "break", ";", "}", "break", ";", "case", "'", "b", "'", ":", "switch", "(", "mode", ")", "{", "case", "SImode", ":", "case", "V4SImode", ":", "result", "=", "bool_V4SI_type_node", ";", "break", ";", "case", "HImode", ":", "case", "V8HImode", ":", "result", "=", "bool_V8HI_type_node", ";", "break", ";", "case", "QImode", ":", "case", "V16QImode", ":", "result", "=", "bool_V16QI_type_node", ";", "default", ":", "break", ";", "}", "break", ";", "case", "'", "p", "'", ":", "switch", "(", "mode", ")", "{", "case", "V8HImode", ":", "result", "=", "pixel_V8HI_type_node", ";", "default", ":", "break", ";", "}", "default", ":", "break", ";", "}", "if", "(", "result", "&&", "result", "!=", "type", "&&", "TYPE_READONLY", "(", "type", ")", ")", "result", "=", "build_qualified_type", "(", "result", ",", "TYPE_QUAL_CONST", ")", ";", "*", "no_add_attrs", "=", "true", ";", "if", "(", "result", ")", "*", "node", "=", "reconstruct_complex_type", "(", "*", "node", ",", "result", ")", ";", "return", "NULL_TREE", ";", "}" ]

[ "Handle", "the", "``", "altivec", "''", "attribute", ".", "The", "attribute", "may", "have", "arguments", "as", "follows", ":", "__attribute__", "(", "(", "altivec", "(", "vector__", ")", ")", ")", "__attribute__", "(", "(", "altivec", "(", "pixel__", ")", ")", ")", "(", "always", "followed", "by", "'unsigned", "short", "'", ")", "__attribute__", "(", "(", "altivec", "(", "bool__", ")", ")", ")", "(", "always", "followed", "by", "'unsigned", "'", ")", "and", "may", "appear", "more", "than", "once", "(", "e.g.", ",", "'vector", "bool", "char", "'", ")", "in", "a", "given", "declaration", "." ]

[ "assert", "(", "MCE", "&&", "<STR_LIT>", "Invalid constant immediate operand!", "<STR_LIT>", ")", ";" ]

[ "void", "addImm1_31Operands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Invalid number of operands!", "<STR_LIT>", ")", ";", "const", "MCConstantExpr", "*", "MCE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";" ]

[ "VUNSPEC_MCR", "VUNSPEC_MCR2", "]", ")" ]

[ "(", "define_int_iterator", "MCRI", "[" ]

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

[ "def", ":", "InstAlias", "<", "<STR_LIT>", ",", "(", "MOVKXi", "GPR64", ":", "$", "Rd", ",", "movk_symbol_g2", ":", "$", "sym", "," ]

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

[ "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

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

[ "return", "target", ";" ]

[ "op1", "=", "GEN_INT", "(", "truncated_selector", ")", ";", "}", "tmode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ")", ";", "mode0", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "arg0", ")", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "mode0", ")", ")", ";", "op0", "=", "force_reg", "(", "mode0", ",", "op0", ")", ";", "if", "(", "optimize", "||", "!", "target", "||", "!", "register_operand", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";", "rs6000_expand_vector_extract", "(", "target", ",", "op0", ",", "op1", ")", ";" ]

[ "let", "VectorPred", "=", "!", "eq", "(", "!", "cast", "<", "string", ">", "(", "Pred", ")", ",", "<STR_LIT>", ")", ";" ]

[ "let", "isReMaterializable", "=", "<NUM_LIT>", ";", "let", "isAsCheapAsAMove", "=", "<NUM_LIT>", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "optype", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dest", ";", "let", "SrcA", "=", "src", ";", "let", "OperandType", "=", "optype", ";", "let", "Switches", "=", "sw", ";" ]

[ "MachinePointerInfo", "(", ")", ")", ";" ]

[ "SDLoc", "dl", "(", "Op", ")", ";", "unsigned", "Depth", "=", "Op", ".", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "SDValue", "FrameAddr", "=", "DAG", ".", "getCopyFromReg", "(", "DAG", ".", "getEntryNode", "(", ")", ",", "dl", ",", "HRI", ".", "getFrameRegister", "(", ")", ",", "VT", ")", ";", "while", "(", "Depth", "--", ")", "FrameAddr", "=", "DAG", ".", "getLoad", "(", "VT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "FrameAddr", "," ]

[ "}" ]

[ "bool", "MipsFastISel", "::", "finishCall", "(", "CallLoweringInfo", "&", "CLI", ",", "MVT", "RetVT", ",", "unsigned", "NumBytes", ")", "{", "CallingConv", "::", "ID", "CC", "=", "CLI", ".", "CallConv", ";", "emitInst", "(", "Mips", "::", "ADJCALLSTACKUP", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "RetVT", "!=", "MVT", "::", "isVoid", ")", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "MipsCCState", "CCInfo", "(", "CC", ",", "false", ",", "*", "FuncInfo", ".", "MF", ",", "RVLocs", ",", "*", "Context", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "CLI", ".", "Ins", ",", "RetCC_Mips", ",", "CLI", ".", "RetTy", ",", "CLI", ".", "Symbol", "?", "CLI", ".", "Symbol", "->", "getName", "(", ")", ".", "data", "(", ")", ":", "nullptr", ")", ";", "if", "(", "RVLocs", ".", "size", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "MVT", "CopyVT", "=", "RVLocs", "[", "<NUM_LIT>", "]", ".", "getValVT", "(", ")", ";", "if", "(", "RetVT", "==", "MVT", "::", "i1", "||", "RetVT", "==", "MVT", "::", "i8", "||", "RetVT", "==", "MVT", "::", "i16", ")", "CopyVT", "=", "MVT", "::", "i32", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "CopyVT", ")", ")", ";", "if", "(", "!", "ResultReg", ")", "return", "false", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "RVLocs", "[", "<NUM_LIT>", "]", ".", "getLocReg", "(", ")", ")", ";", "CLI", ".", "InRegs", ".", "push_back", "(", "RVLocs", "[", "<NUM_LIT>", "]", ".", "getLocReg", "(", ")", ")", ";", "CLI", ".", "ResultReg", "=", "ResultReg", ";", "CLI", ".", "NumResultRegs", "=", "<NUM_LIT>", ";" ]

[ "SDValue", "CWD1", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "dl", ",", "MVT", "::", "i32", ",", "CWD", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";" ]

[ "SDValue", "Chain", "=", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "MFFS", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "{", "MVT", "::", "f64", ",", "MVT", "::", "Other", "}", ",", "Chain", ")", ";", "Chain", "=", "MFFS", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "int", "SSFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "false", ")", ";", "SDValue", "StackSlot", "=", "DAG", ".", "getFrameIndex", "(", "SSFI", ",", "PtrVT", ")", ";", "Chain", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "MFFS", ",", "StackSlot", ",", "MachinePointerInfo", "(", ")", ")", ";", "SDValue", "Four", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "PtrVT", ")", ";", "SDValue", "Addr", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "StackSlot", ",", "Four", ")", ";", "SDValue", "CWD", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "i32", ",", "dl", ",", "Chain", ",", "Addr", ",", "MachinePointerInfo", "(", ")", ")", ";", "Chain", "=", "CWD", ".", "getValue", "(", "<NUM_LIT>", ")", ";" ]

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

[ "(", "V8SI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V8SF", "<STR_LIT>", ")", "(", "V4DF" ]

[ "SDValue", "R600TargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "FP_ROUND", ":", "{", "SDValue", "Arg", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Arg", ".", "getOpcode", "(", ")", "==", "ISD", "::", "UINT_TO_FP", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", ")", "{", "return", "DAG", ".", "getNode", "(", "ISD", "::", "UINT_TO_FP", ",", "N", "->", "getDebugLoc", "(", ")", ",", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ",", "Arg", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "}", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

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

[ "class", "CLT_S_D_ENC", ":", "MSA_3R_FMT", "<", "<NUM_LIT>", ",", "<NUM_LIT>" ]

[ "N", ")", ";" ]

[ "void", "addu7_0ImmOperands", "(", "MCInst", "&", "Inst", ",", "unsigned", "N", ")", "const", "{", "addImmOperands", "(", "Inst", "," ]

[ "}" ]

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

[ "}" ]

[ "addPass", "(", "createF2003fISelDag", "(", "getF2003fTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";" ]

[ "}", "=", "crn", ";" ]

[ "class", "SysReg", "<", "string", "name", ",", "bits", "<", "<NUM_LIT>", ">", "op0", ",", "bits", "<", "<NUM_LIT>", ">", "op1", ",", "bits", "<", "<NUM_LIT>", ">", "crn", ",", "bits", "<", "<NUM_LIT>", ">", "crm", ",", "bits", "<", "<NUM_LIT>", ">", "op2", ">", ":", "SearchableTable", "{", "let", "SearchableFields", "=", "[", "<STR_LIT>", ",", "<STR_LIT>", "]", ";", "let", "EnumValueField", "=", "<STR_LIT>", ";", "string", "Name", "=", "name", ";", "bits", "<", "<NUM_LIT>", ">", "Encoding", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op0", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op1", ";", "let", "Encoding", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ ")", ";" ]

[ "return", "_", "_", "builtin_neon_vcvthssi", "(", "_", "_", "a" ]

[ "}" ]

[ "const", "MCExpr", "*", "ARMElfTargetObjectFile", "::", "getDebugThreadLocalSymbol", "(", "const", "MCSymbol", "*", "Sym", ")", "const", "{", "return", "MCSymbolRefExpr", "::", "Create", "(", "Sym", ",", "MCSymbolRefExpr", "::", "VK_ARM_TLSLDO", ",", "getContext", "(", ")", ")", ";" ]

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

[ "def", "tMOVSr", ":", "T1I", "<", "(", "outs", "tGPR", ":", "$", "Rd", ")", ",", "(", "ins", "tGPR", ":", "$", "Rm", ")", ",", "IIC_iMOVr", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Encoding16", ",", "Sched", "<", "[", "WriteALU", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";" ]

[ "sact", ".", "sa_sigaction", "=", "segv_handler", ";" ]

[ "sigstk", ".", "ss_size", "=", "SIGSTKSZ", ";", "sigstk", ".", "ss_flags", "=", "<NUM_LIT>", ";", "if", "(", "sigaltstack", "(", "&", "sigstk", ",", "NULL", ")", "<", "<NUM_LIT>", ")", "fatal_error", "(", "<STR_LIT>", "While setting up signal stack: %m", "<STR_LIT>", ")", ";", "sigemptyset", "(", "&", "sact", ".", "sa_mask", ")", ";", "sact", ".", "sa_flags", "=", "SA_ONSTACK", "|", "SA_SIGINFO", ";" ]

[ "FPR32", ":", "$", "Rm", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v1i64", "(", "opnode", "(", "v1i64", "FPR64", ":", "$", "Src", ")", ",", "(", "v1i32", "FPR32", ":", "$", "Rn", ")", ",", "(", "v1i32", "FPR32", ":", "$", "Rm", ")", ")", ")", ",", "(", "INSTS", "FPR64", ":", "$", "Src", ",", "FPR32", ":", "$", "Rn", "," ]

[ ")", ")" ]

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

[ "=", "false", ";" ]

[ "const", "LanaiSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "LanaiSubtarget", ">", "(", ")", ";", "TII", "=", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed" ]

[ "}" ]

[ "EVT", "MemVT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "if", "(", "ISD", "::", "isNON_EXTLoad", "(", "N", ")", ")", "{", "for", "(", "iter", "=", "<NUM_LIT>", ";", "iter", "<", "NumLoads", ";", "++", "iter", ")", "{", "Offset", "=", "DAG", ".", "getConstant", "(", "iter", "+", "LoadOffset", ",", "MVT", "::", "i8", ")", ";", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i8", ",", "MVT", "::", "Other", ")", ";", "Load", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Chain", ",", "PtrLo", ",", "PtrHi", ",", "Offset", ")", ";", "PICLoads", ".", "push_back", "(", "Load", ")", ";", "}", "}", "else", "{", "EVT", "MemVT", "=", "LD", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBytes", "=", "MemVT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "if", "(", "MemBytes", "==", "<NUM_LIT>", ")", "MemBytes", "=", "<NUM_LIT>", ";", "unsigned", "ExtdBytes", "=", "VT", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "Offset", "=", "DAG", ".", "getConstant", "(", "LoadOffset", ",", "MVT", "::", "i8", ")", ";", "Tys", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i8", ",", "MVT", "::", "Other", ")", ";", "for", "(", "iter", "=", "<NUM_LIT>", ";", "iter", "<", "MemBytes", ";", "++", "iter", ")", "{", "Offset", "=", "DAG", ".", "getConstant", "(", "iter", "+", "LoadOffset", ",", "MVT", "::", "i8", ")", ";", "Load", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Chain", ",", "PtrLo", ",", "PtrHi", ",", "Offset", ")", ";", "PICLoads", ".", "push_back", "(", "Load", ")", ";", "}", "if", "(", "ISD", "::", "isSEXTLoad", "(", "N", ")", ")", "{", "SDValue", "SRA", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRA", ",", "dl", ",", "MVT", "::", "i8", ",", "Load", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ")", ";", "for", "(", "iter", "=", "MemBytes", ";", "iter", "<", "ExtdBytes", ";", "++", "iter", ")", "{", "PICLoads", ".", "push_back", "(", "SRA", ")", ";", "}", "}", "else", "if", "(", "ISD", "::", "isZEXTLoad", "(", "N", ")", "||", "ISD", "::", "isEXTLoad", "(", "N", ")", ")", "{", "SDValue", "ConstZero", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i8", ")", ";", "for", "(", "iter", "=", "MemBytes", ";", "iter", "<", "ExtdBytes", ";", "++", "iter", ")", "{", "PICLoads", ".", "push_back", "(", "ConstZero", ")", ";" ]

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

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

[ ")", ";" ]

[ "enum", "machine_mode", "mode", ";", "rtx", "*", "regs", ";", "if", "(", "MEM_ALIGN", "(", "src", ")", "==", "BITS_PER_WORD", "/", "<NUM_LIT>", "&&", "MEM_ALIGN", "(", "dest", ")", "==", "BITS_PER_WORD", "/", "<NUM_LIT>", ")", "bits", "=", "BITS_PER_WORD", "/", "<NUM_LIT>", ";", "else", "bits", "=", "BITS_PER_WORD", ";", "mode", "=", "mode_for_size", "(", "bits", ",", "MODE_INT", ",", "<NUM_LIT>", ")", ";", "delta", "=", "bits", "/", "BITS_PER_UNIT", ";", "regs", "=", "alloca", "(", "sizeof", "(", "rtx", ")", "*", "length", "/", "delta", ")", ";", "for", "(", "offset", "=", "<NUM_LIT>", ",", "i", "=", "<NUM_LIT>", ";", "offset", "+", "delta", "<=", "length", ";", "offset", "+=", "delta", ",", "i", "++", ")", "{", "regs", "[", "i", "]", "=", "gen_reg_rtx", "(", "mode" ]

[ "<FIXS>", "if", "(", "arg0", "==", "error_mark_node", "||", "arg1", "==", "error_mark_node", "||", "arg2", "==", "error_mark_node", ")", "return", "target", ";", "if", "(", "target", "!=", "<NUM_LIT>", "<FIXE>" ]

[ "enum", "machine_mode", "mode1", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "enum", "machine_mode", "mode2", "=", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "mode", ";", "<BUGS>", "if", "(", "!", "target", "<BUGE>", "||", "GET_MODE", "(", "target", ")", "!=", "tmode", "||", "!", "(", "*", "insn_data", "[", "icode", "]", ".", "operand", "[", "<NUM_LIT>", "]", ".", "predicate", ")", "(", "target", ",", "tmode", ")", ")", "target", "=", "gen_reg_rtx", "(", "tmode", ")", ";" ]

[ "REG_CFA_OFFSET", ",", "real", ")", ";" ]

[ "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ";", "rtx", "mov", "=", "gen_movsi", "(", "mem", ",", "reg", ")", ";", "rtx", "reg_note", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno_note", ")", ";", "rtx", "cfa_relative_addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "cfa", ",", "gen_int_si", "(", "cfa_offset", ")", ")", ";", "rtx", "cfa_relative_mem", "=", "gen_frame_mem", "(", "Pmode", ",", "cfa_relative_addr", ")", ";", "rtx", "real", "=", "gen_rtx_SET", "(", "cfa_relative_mem", ",", "reg_note", ")", ";", "add_reg_note", "(", "mov", "," ]

[ ";" ]

[ "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>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>" ]

[ ";" ]

[ "if", "(", "GET_CODE", "(", "ref", ")", "!=", "MEM", ")", "return", ";", "if", "(", "!", "MEM_VOLATILE_P", "(", "ref", ")", "&&", "!", "MEM_IN_STRUCT_P", "(", "ref", ")", "&&", "!", "MEM_SCALAR_P", "(", "ref", ")", "&&", "!", "MEM_NOTRAP_P", "(", "ref", ")", "&&", "!", "MEM_READONLY_P", "(", "ref", ")", ")", "return", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "base_ptr", "=", "&", "PATTERN", "(", "insn", ")", ";", "else", "base_ptr", "=", "&", "insn" ]

[ ";" ]

[ "bool", "getUsesRedZone", "(", ")", "const", "{", "return", "UsesRedZone" ]

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

[ "(", "shiftop", ":", "V_INT_noHI", "(", "match_operand", ":", "V_INT_noHI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_duplicate", ":", "<", "VnSI", ">", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

[ "static", "void", "frv_split_iacc_move", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "machine_mode", "inner", ";", "int", "i", ";", "inner", "=", "GET_MODE", "(", "dest", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "GET_MODE_SIZE", "(", "inner", ")", ";", "i", "+=", "GET_MODE_SIZE", "(", "SImode", ")", ")", "emit_move_insn", "(", "simplify_gen_subreg", "(", "SImode", ",", "dest", ",", "inner", ",", "i", ")", ",", "simplify_gen_subreg", "(", "SImode", ",", "src", ",", "inner", ",", "i", ")", ")", ";", "}" ]

[ "Emit", "a", "move", "from", "SRC", "to", "DEST", "in", "SImode", "chunks", ".", "This", "can", "be", "used", "to", "move", "DImode", "values", "into", "and", "out", "of", "IACC0", "." ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ctz", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

[ "]", ">", ";" ]

[ "def", "SDTX86caspair", ":", "SDTypeProfile", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "[", "SDTCisPtrTy", "<", "<NUM_LIT>", ">" ]

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

[ "<STR_LIT>", ",", "[", "]", ">", ";", "def", "MTC1", ":", "FFR", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "FGR32", ":", "$", "fs", ")", ",", "(", "ins", "CPURegs", ":", "$", "rt", ")", ",", "<BUGS>", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "def", "MFC1A", ":", "FFR", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "CPURegs", ":", "$", "rt", ")", ",", "(", "ins", "AFGR32", ":", "$", "fs", ")", ",", "<STR_LIT>", ",", "[", "]", ">", ";", "def", "MTC1A", ":", "FFR", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "AFGR32", ":", "$", "fs", ")", ",", "(", "ins", "CPURegs", ":", "$", "rt", ")", ",", "<BUGS>", "<STR_LIT>", ",", "[", "]", ">", ";", "<BUGE>", "}" ]

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

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">", "(", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", "#" ]

[ "if", "(", "(", "CALL_P", "(", "insn", ")", "||", "JUMP_P", "(", "insn", ")", ")", "&&", "SCHED_ON_EVEN_P", "(", "insn", ")", ")", "new", "_", "insn", "=", "emit_insn_after", "(", "gen_lnop", "(", ")", ",", "insn", ")", ";" ]

[ "static", "void", "emit_nop_for_insn", "(", "rtx_insn", "*", "insn", ")", "{", "int", "p", ";", "rtx_insn", "*", "new", "_", "insn", ";", "if", "(", "JUMP_TABLE_DATA_P", "(", "insn", ")", ")", "{", "new", "_", "insn", "=", "emit_insn_after", "(", "gen_lnop", "(", ")", ",", "insn", ")", ";", "recog_memoized", "(", "new", "_", "insn", ")", ";", "INSN_LOCATION", "(", "new", "_", "insn", ")", "=", "UNKNOWN_LOCATION", ";", "return", ";", "}", "p", "=", "get_pipe", "(", "insn", ")", ";" ]

[ "<FIXS>", "case", "E_V2SImode", ":", "<FIXE>", "<FIXS>", "case", "E_V4HImode", ":", "<FIXE>" ]

[ "gcc_assert", "(", "ok", ")", ";", "break", ";", "<BUGS>", "case", "V2SImode", ":", "<BUGE>", "emit_insn", "(", "gen_loongson_punpckhwd", "(", "fold", ",", "last", ",", "last", ")", ")", ";", "break", ";", "<BUGS>", "case", "V4HImode", ":", "<BUGE>", "emit_insn", "(", "gen_loongson_punpckhwd_hi", "(", "fold", ",", "last", ",", "last", ")", ")", ";" ]

[ ")", ";" ]

[ "const", "Triple", "&", "TheTriple", "=", "STI", ".", "getTargetTriple", "(", ")", ";", "uint8_t", "OSABI", "=", "MCELFObjectTargetWriter", "::", "getOSABI", "(", "TheTriple", ".", "getOS", "(", ")", ")", ";", "return", "new", "M680x0ELFAsmBackend", "(", "T", ",", "OSABI" ]

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

[ "static", "bool", "CC_X86_Intr", "(", "unsigned", "&", "ValNo", ",", "MVT", "&", "ValVT", ",", "MVT", "&", "LocVT", ",", "CCValAssign", "::", "LocInfo", "&", "LocInfo", ",", "ISD", "::", "ArgFlagsTy", "&", "ArgFlags", ",", "CCState", "&", "State", ")", "{", "const", "MachineFunction", "&", "MF", "=", "State", ".", "getMachineFunction", "(", ")", ";", "size_t", "ArgCount", "=", "State", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ".", "arg_size", "(", ")", ";", "bool", "Is64Bit", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ";", "unsigned", "SlotSize", "=", "Is64Bit", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "unsigned", "Offset", ";", "if", "(", "ArgCount", "==", "<NUM_LIT>", "&&", "ValNo", "==", "<NUM_LIT>", ")", "{", "Offset", "=", "State", ".", "AllocateStack", "(", "<NUM_LIT>", "*", "SlotSize", ",", "Align" ]

[ "case", "Intrinsic", "::", "memcpy", ":" ]

[ "updateValueMap", "(", "II", ",", "DestReg", ")", ";", "return", "true", ";", "}", "else", "{", "unsigned", "TempReg", "[", "<NUM_LIT>", "]", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "TempReg", "[", "i", "]", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "if", "(", "TempReg", "[", "i", "]", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "emitInst", "(", "Mips", "::", "SLL", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "SRL", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "OR", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ";", "emitInst", "(", "Mips", "::", "ANDi", ",", "DestReg", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "updateValueMap", "(", "II", ",", "DestReg", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "VT", "==", "MVT", "::", "i32", ")", "{", "if", "(", "Subtarget", "->", "hasMips32r2", "(", ")", ")", "{", "unsigned", "TempReg", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "emitInst", "(", "Mips", "::", "WSBH", ",", "TempReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "emitInst", "(", "Mips", "::", "ROTR", ",", "DestReg", ")", ".", "addReg", "(", "TempReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "updateValueMap", "(", "II", ",", "DestReg", ")", ";", "return", "true", ";", "}", "else", "{", "unsigned", "TempReg", "[", "<NUM_LIT>", "]", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "TempReg", "[", "i", "]", "=", "createResultReg", "(", "&", "Mips", "::", "GPR32RegClass", ")", ";", "if", "(", "TempReg", "[", "i", "]", "==", "<NUM_LIT>", ")", "return", "false", ";", "}", "emitInst", "(", "Mips", "::", "SRL", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "SRL", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "ANDi", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "OR", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ";", "emitInst", "(", "Mips", "::", "ANDi", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "SLL", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "SLL", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "emitInst", "(", "Mips", "::", "OR", ",", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ";", "emitInst", "(", "Mips", "::", "OR", ",", "DestReg", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ".", "addReg", "(", "TempReg", "[", "<NUM_LIT>", "]", ")", ";", "updateValueMap", "(", "II", ",", "DestReg", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "<NUM_LIT>", ")", "=", "=", "<NUM_LIT>", ")", ";", "}", "]", ">", "{" ]

[ "def", "uimm6s16", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "Imm", ">", "=", "<NUM_LIT>", "&", "&", "Imm", "<", "(", "<NUM_LIT>", "*", "<NUM_LIT>", ")", "&", "&", "(", "(", "Imm", "%" ]

[ "all", "(", ")", ";" ]

[ "const", "DataLayout", "*", "DL", "=", "&", "F", ".", "getDataLayout", "(", ")", ";", "DomTreeUpdater", "DTU", "(", "&", "AM", ".", "getResult", "<", "DominatorTreeAnalysis", ">", "(", "F", ")", ",", "DomTreeUpdater", "::", "UpdateStrategy", "::", "Lazy", ")", ";", "const", "GCNSubtarget", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", "F", ")", ";", "bool", "IsPixelShader", "=", "F", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AMDGPU_PS", ";", "bool", "IsChanged", "=", "AMDGPUAtomicOptimizerImpl", "(", "UA", ",", "DL", ",", "DTU", ",", "ST", ",", "IsPixelShader", ",", "ScanImpl", ")", ".", "run", "(", "F", ")", ";", "if", "(", "!", "IsChanged", ")", "{", "return", "PreservedAnalyses", "::" ]

[ "<FIXS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Running SPScheduler on function '", "<STR_LIT>", "<<", "mf", ".", "getName", "(", ")", "<<", "<STR_LIT>", "'\\n", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "MBB: [", "<STR_LIT>", "<<", "mbb", "<<", "<STR_LIT>", "]: #", "<STR_LIT>", "<<", "mbb", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "return", "false", ";", "}", "<BUGS>", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Running SPScheduler on function '", "<STR_LIT>", "<<", "mf", ".", "getName", "(", ")", "<<", "<STR_LIT>", "'\\n", "<STR_LIT>", ")", ";", "<BUGE>", "auto", "reduceAnalysis", "=", "&", "getAnalysis", "PatmosSPReduce", ">", "(", ")", ";", "auto", "rootScope", "=", "reduceAnalysis", "->", "RootScope", ";", "for", "(", "auto", "mbbIter", "=", "mf", ".", "begin", "(", ")", ",", "mbbEnd", "=", "mf", ".", "end", "(", ")", ";", "mbbIter", "!=", "mbbEnd", ";", "mbbIter", "++", ")", "{", "auto", "mbb", "=", "&", "(", "*", "mbbIter", ")", ";", "<BUGS>", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "MBB: [", "<STR_LIT>", "<<", "mbb", "<<", "<STR_LIT>", "]: #", "<STR_LIT>", "<<", "mbb", "->", "getNumber", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "<BUGE>", "for", "(", "auto", "instrIter", "=", "mbb", "->", "begin", "(", ")", ",", "instrEnd", "=", "mbb", "->", "end", "(", ")", ";", "instrIter", "!=", "instrEnd", ";", "instrIter", "++", ")", "{" ]

[ "case", "X86", "::", "COND_A", ":", "case", "X86", "::", "COND_AE", ":" ]

[ "}", "CmpInstr", "->", "setDesc", "(", "get", "(", "NewOpcode", ")", ")", ";", "CmpInstr", "->", "RemoveOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "NewOpcode", "==", "X86", "::", "CMP64rm", "||", "NewOpcode", "==", "X86", "::", "CMP32rm", "||", "NewOpcode", "==", "X86", "::", "CMP16rm", "||", "NewOpcode", "==", "X86", "::", "CMP8rm", ")", "return", "false", ";", "}", "}", "MachineInstr", "*", "MI", "=", "MRI", "->", "getUniqueVRegDef", "(", "SrcReg", ")", ";", "if", "(", "!", "MI", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "CmpInstr", ",", "Def", "=", "MI", ";", "bool", "IsCmpZero", "=", "(", "SrcReg2", "==", "<NUM_LIT>", "&&", "CmpValue", "==", "<NUM_LIT>", ")", ";", "if", "(", "IsCmpZero", "&&", "(", "MI", "->", "getParent", "(", ")", "!=", "CmpInstr", "->", "getParent", "(", ")", "||", "!", "isDefConvertible", "(", "MI", ")", ")", ")", "return", "false", ";", "MachineInstr", "*", "Sub", "=", "NULL", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "&", "getRegisterInfo", "(", ")", ";", "MachineBasicBlock", "::", "reverse_iterator", "RI", "=", "MachineBasicBlock", "::", "reverse_iterator", "(", "I", ")", ",", "RE", "=", "CmpInstr", "->", "getParent", "(", ")", "==", "MI", "->", "getParent", "(", ")", "?", "MachineBasicBlock", "::", "reverse_iterator", "(", "++", "Def", ")", ":", "CmpInstr", "->", "getParent", "(", ")", "->", "rend", "(", ")", ";", "MachineInstr", "*", "Movr0Inst", "=", "<NUM_LIT>", ";", "for", "(", ";", "RI", "!=", "RE", ";", "++", "RI", ")", "{", "MachineInstr", "*", "Instr", "=", "&", "*", "RI", ";", "if", "(", "!", "IsCmpZero", "&&", "isRedundantFlagInstr", "(", "CmpInstr", ",", "SrcReg", ",", "SrcReg2", ",", "CmpValue", ",", "Instr", ")", ")", "{", "Sub", "=", "Instr", ";", "break", ";", "}", "if", "(", "Instr", "->", "modifiesRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", "||", "Instr", "->", "readsRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ")", "{", "if", "(", "!", "Movr0Inst", "&&", "(", "Instr", "->", "getOpcode", "(", ")", "==", "X86", "::", "MOV8r0", "||", "Instr", "->", "getOpcode", "(", ")", "==", "X86", "::", "MOV16r0", "||", "Instr", "->", "getOpcode", "(", ")", "==", "X86", "::", "MOV32r0", "||", "Instr", "->", "getOpcode", "(", ")", "==", "X86", "::", "MOV64r0", ")", "&&", "Instr", "->", "registerDefIsDead", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ")", "{", "Movr0Inst", "=", "Instr", ";", "continue", ";", "}", "return", "false", ";", "}", "}", "if", "(", "!", "IsCmpZero", "&&", "!", "Sub", ")", "return", "false", ";", "bool", "IsSwapped", "=", "(", "SrcReg2", "!=", "<NUM_LIT>", "&&", "Sub", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "SrcReg2", "&&", "Sub", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "SrcReg", ")", ";", "bool", "IsSafe", "=", "false", ";", "SmallVector", "<", "std", "::", "pair", "<", "MachineInstr", "*", ",", "unsigned", ">", ",", "<NUM_LIT>", ">", "OpsToUpdate", ";", "MachineBasicBlock", "::", "iterator", "E", "=", "CmpInstr", "->", "getParent", "(", ")", "->", "end", "(", ")", ";", "for", "(", "++", "I", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineInstr", "&", "Instr", "=", "*", "I", ";", "bool", "ModifyEFLAGS", "=", "Instr", ".", "modifiesRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ";", "bool", "UseEFLAGS", "=", "Instr", ".", "readsRegister", "(", "X86", "::", "EFLAGS", ",", "TRI", ")", ";", "if", "(", "!", "UseEFLAGS", "&&", "ModifyEFLAGS", ")", "{", "IsSafe", "=", "true", ";", "break", ";", "}", "if", "(", "!", "UseEFLAGS", "&&", "!", "ModifyEFLAGS", ")", "continue", ";", "X86", "::", "CondCode", "OldCC", ";", "bool", "OpcIsSET", "=", "false", ";", "if", "(", "IsCmpZero", "||", "IsSwapped", ")", "{", "if", "(", "Instr", ".", "isBranch", "(", ")", ")", "OldCC", "=", "getCondFromBranchOpc", "(", "Instr", ".", "getOpcode", "(", ")", ")", ";", "else", "{", "OldCC", "=", "getCondFromSETOpc", "(", "Instr", ".", "getOpcode", "(", ")", ")", ";", "if", "(", "OldCC", "!=", "X86", "::", "COND_INVALID", ")", "OpcIsSET", "=", "true", ";", "else", "OldCC", "=", "X86", "::", "getCondFromCMovOpc", "(", "Instr", ".", "getOpcode", "(", ")", ")", ";", "}", "if", "(", "OldCC", "==", "X86", "::", "COND_INVALID", ")", "return", "false", ";", "}", "if", "(", "IsCmpZero", ")", "{", "switch", "(", "OldCC", ")", "{", "default", ":", "break", ";" ]

[ "::", "KADDBrr", ")", ";" ]

[ "void", "X86DomainReassignment", "::", "initConverters", "(", ")", "{", "Converters", "[", "{", "MaskDomain", ",", "TargetOpcode", "::", "PHI", "}", "]", "=", "std", "::", "make_unique", "<", "InstrIgnore", ">", "(", "TargetOpcode", "::", "PHI", ")", ";", "Converters", "[", "{", "MaskDomain", ",", "TargetOpcode", "::", "IMPLICIT_DEF", "}", "]", "=", "std", "::", "make_unique", "<", "InstrIgnore", ">", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ")", ";", "Converters", "[", "{", "MaskDomain", ",", "TargetOpcode", "::", "INSERT_SUBREG", "}", "]", "=", "std", "::", "make_unique", "<", "InstrReplaceWithCopy", ">", "(", "TargetOpcode", "::", "INSERT_SUBREG", ",", "<NUM_LIT>", ")", ";", "Converters", "[", "{", "MaskDomain", ",", "TargetOpcode", "::", "COPY", "}", "]", "=", "std", "::", "make_unique", "<", "InstrCOPYReplacer", ">", "(", "TargetOpcode", "::", "COPY", ",", "MaskDomain", ",", "TargetOpcode", "::", "COPY", ")", ";", "auto", "createReplacerDstCOPY", "=", "[", "&", "]", "(", "unsigned", "From", ",", "unsigned", "To", ")", "{", "Converters", "[", "{", "MaskDomain", ",", "From", "}", "]", "=", "std", "::", "make_unique", "<", "InstrReplacerDstCOPY", ">", "(", "From", ",", "To", ")", ";", "}", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX32rm16", ",", "X86", "::", "KMOVWkm", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX64rm16", ",", "X86", "::", "KMOVWkm", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX32rr16", ",", "X86", "::", "KMOVWkk", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX64rr16", ",", "X86", "::", "KMOVWkk", ")", ";", "if", "(", "STI", "->", "hasDQI", "(", ")", ")", "{", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX16rm8", ",", "X86", "::", "KMOVBkm", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX32rm8", ",", "X86", "::", "KMOVBkm", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX64rm8", ",", "X86", "::", "KMOVBkm", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX16rr8", ",", "X86", "::", "KMOVBkk", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX32rr8", ",", "X86", "::", "KMOVBkk", ")", ";", "createReplacerDstCOPY", "(", "X86", "::", "MOVZX64rr8", ",", "X86", "::", "KMOVBkk", ")", ";", "}", "auto", "createReplacer", "=", "[", "&", "]", "(", "unsigned", "From", ",", "unsigned", "To", ")", "{", "Converters", "[", "{", "MaskDomain", ",", "From", "}", "]", "=", "std", "::", "make_unique", "<", "InstrReplacer", ">", "(", "From", ",", "To", ")", ";", "}", ";", "createReplacer", "(", "X86", "::", "MOV16rm", ",", "X86", "::", "KMOVWkm", ")", ";", "createReplacer", "(", "X86", "::", "MOV16mr", ",", "X86", "::", "KMOVWmk", ")", ";", "createReplacer", "(", "X86", "::", "MOV16rr", ",", "X86", "::", "KMOVWkk", ")", ";", "createReplacer", "(", "X86", "::", "SHR16ri", ",", "X86", "::", "KSHIFTRWri", ")", ";", "createReplacer", "(", "X86", "::", "SHL16ri", ",", "X86", "::", "KSHIFTLWri", ")", ";", "createReplacer", "(", "X86", "::", "NOT16r", ",", "X86", "::", "KNOTWrr", ")", ";", "createReplacer", "(", "X86", "::", "OR16rr", ",", "X86", "::", "KORWrr", ")", ";", "createReplacer", "(", "X86", "::", "AND16rr", ",", "X86", "::", "KANDWrr", ")", ";", "createReplacer", "(", "X86", "::", "XOR16rr", ",", "X86", "::", "KXORWrr", ")", ";", "if", "(", "STI", "->", "hasBWI", "(", ")", ")", "{", "createReplacer", "(", "X86", "::", "MOV32rm", ",", "X86", "::", "KMOVDkm", ")", ";", "createReplacer", "(", "X86", "::", "MOV64rm", ",", "X86", "::", "KMOVQkm", ")", ";", "createReplacer", "(", "X86", "::", "MOV32mr", ",", "X86", "::", "KMOVDmk", ")", ";", "createReplacer", "(", "X86", "::", "MOV64mr", ",", "X86", "::", "KMOVQmk", ")", ";", "createReplacer", "(", "X86", "::", "MOV32rr", ",", "X86", "::", "KMOVDkk", ")", ";", "createReplacer", "(", "X86", "::", "MOV64rr", ",", "X86", "::", "KMOVQkk", ")", ";", "createReplacer", "(", "X86", "::", "SHR32ri", ",", "X86", "::", "KSHIFTRDri", ")", ";", "createReplacer", "(", "X86", "::", "SHR64ri", ",", "X86", "::", "KSHIFTRQri", ")", ";", "createReplacer", "(", "X86", "::", "SHL32ri", ",", "X86", "::", "KSHIFTLDri", ")", ";", "createReplacer", "(", "X86", "::", "SHL64ri", ",", "X86", "::", "KSHIFTLQri", ")", ";", "createReplacer", "(", "X86", "::", "ADD32rr", ",", "X86", "::", "KADDDrr", ")", ";", "createReplacer", "(", "X86", "::", "ADD64rr", ",", "X86", "::", "KADDQrr", ")", ";", "createReplacer", "(", "X86", "::", "NOT32r", ",", "X86", "::", "KNOTDrr", ")", ";", "createReplacer", "(", "X86", "::", "NOT64r", ",", "X86", "::", "KNOTQrr", ")", ";", "createReplacer", "(", "X86", "::", "OR32rr", ",", "X86", "::", "KORDrr", ")", ";", "createReplacer", "(", "X86", "::", "OR64rr", ",", "X86", "::", "KORQrr", ")", ";", "createReplacer", "(", "X86", "::", "AND32rr", ",", "X86", "::", "KANDDrr", ")", ";", "createReplacer", "(", "X86", "::", "AND64rr", ",", "X86", "::", "KANDQrr", ")", ";", "createReplacer", "(", "X86", "::", "ANDN32rr", ",", "X86", "::", "KANDNDrr", ")", ";", "createReplacer", "(", "X86", "::", "ANDN64rr", ",", "X86", "::", "KANDNQrr", ")", ";", "createReplacer", "(", "X86", "::", "XOR32rr", ",", "X86", "::", "KXORDrr", ")", ";", "createReplacer", "(", "X86", "::", "XOR64rr", ",", "X86", "::", "KXORQrr", ")", ";", "}", "if", "(", "STI", "->", "hasDQI", "(", ")", ")", "{", "createReplacer", "(", "X86", "::", "ADD8rr", ",", "X86" ]

[ "}" ]

[ "vreinterpretq_p16_s16", "(", "int16x8_t", "_", "_", "a", ")", "{", "return", "(", "poly16x8_t", ")", "_", "_", "a", ";" ]

[ "for", "(", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "Result", ".", "push_back", "(", "DummyPair", ")", ";" ]

[ "}", "if", "(", "PV", ".", "contains", "(", "Reg", ")", ")", "{", "Result", ".", "push_back", "(", "std", "::", "pair", "(", "<NUM_LIT>", ",", "<NUM_LIT>", "U", ")", ")", ";", "continue", ";", "}", "if", "(", "Index", ">", "<NUM_LIT>", ")", "{", "ConstCount", "++", ";", "Result", ".", "push_back", "(", "DummyPair", ")", ";", "continue", ";", "}", "unsigned", "Chan", "=", "RI", ".", "getHWRegChan", "(", "Reg", ")", ";", "Result", ".", "push_back", "(", "std", "::", "pair", "(", "Index", ",", "Chan", ")", ")", ";", "}" ]

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

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

[ "<FIXS>", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ",", "Defs", "=", "[", "CPSR", "]", "in", "{", "<FIXE>" ]

[ "}", "<BUGS>", "let", "hasPostISelHook", "=", "<NUM_LIT>", ",", "isCodeGenOnly", "=", "<NUM_LIT>", ",", "Defs", "=", "[", "CPSR", "]", "in", "{", "<BUGE>", "multiclass", "AsI1_rbin_s_is", "bits", "<NUM_LIT>", ">", "opcod", ",", "string", "opc", ",", "InstrItinClass", "iii", ",", "InstrItinClass", "iir", ",", "InstrItinClass", "iis", ",", "PatFrag", "opnode", ",", "bit", "Commutable", "=", "<NUM_LIT>", ">", "{" ]

[ "w0", ",", "uint16_t", "w1", ")", "{" ]

[ "static", "void", "sh_emit_storehi", "(", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ",", "uint16_t" ]

[ "}" ]

[ "assert", "(", "!", "isPICBase", "&&", "<STR_LIT>", "More than one PIC base?", "<STR_LIT>", ")", ";", "isPICBase", "=", "true", ";", "}", "return", "isPICBase", ";", "}", "return", "false", ";", "}", "case", "X86", "::", "LEA32r", ":", "case", "X86", "::", "LEA64r", ":", "{", "if", "(", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<NUM_LIT>", "&&", "!", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "{", "if", "(", "!", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "unsigned", "BaseReg", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "BaseReg", "==", "<NUM_LIT>", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "regIsPICBase", "(", "BaseReg", ",", "MRI", ")", ";" ]

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

[ "def", "A4_paslhfnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_1ae57e39", ",", "TypeALU32_2op", ">", ",", "Enc_fb6577", ",", "PredNewRel", "{", "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", "isPredicated", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ "<FIXS>", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " making successor ", "<STR_LIT>", "<<", "dst", "->", "getName", "(", ")", "<FIXE>" ]

[ "makeReady", "(", "ready", ",", "dst", ")", ";", "#", "ifdef", "PATMOS_TRACE_VISITS", "<BUGS>", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " making successor ", "<STR_LIT>", "<<", "dst", "->", "getName", "(", ")", "<BUGE>", "<<", "<STR_LIT>", " ready\\n", "<STR_LIT>", ")", ";", "#", "endif", "}" ]

[ "I", ")", "InVals", ".", "push_back", "(", "DAG", ".", "getUNDEF", "(", "CLI", ".", "Ins", "[", "I", "]", ".", "VT", ")", ")", ";" ]

[ "DiagnosticInfoUnsupported", "NoCalls", "(", "Fn", ",", "Reason", "+", "FuncName", ",", "CLI", ".", "DL", ".", "getDebugLoc", "(", ")", ")", ";", "DAG", ".", "getContext", "(", ")", "->", "diagnose", "(", "NoCalls", ")", ";", "if", "(", "!", "CLI", ".", "IsTailCall", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "CLI", ".", "Ins", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++" ]

[ "<FIXS>", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "<FIXE>" ]

[ "static", "intft32_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "<BUGS>", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "<BUGE>", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes_left", ",", "size", ";" ]

[ "}" ]

[ "const", "DenseMap", "<", "unsigned", "*", ",", "unsigned", ">", "*", "OpcodeTablePtr", "=", "NULL", ";", "if", "(", "isTwoAddr", "&&", "NumOps", ">=", "<NUM_LIT>", "&&", "OpNum", "<", "<NUM_LIT>", ")", "{", "OpcodeTablePtr", "=", "&", "RegOp2MemOpTable2Addr", ";", "}", "else", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "switch", "(", "Opc", ")", "{", "case", "X86", "::", "MOV16r0", ":", "case", "X86", "::", "MOV32r0", ":", "case", "X86", "::", "MOV64r0", ":", "case", "X86", "::", "MOV8r0", ":", "return", "true", ";", "default", ":", "break", ";", "}", "OpcodeTablePtr", "=", "&", "RegOp2MemOpTable0", ";", "}", "else", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "OpcodeTablePtr", "=", "&", "RegOp2MemOpTable1", ";", "}", "else", "if", "(", "OpNum", "==", "<NUM_LIT>", ")", "{", "OpcodeTablePtr", "=", "&", "RegOp2MemOpTable2", ";", "}", "if", "(", "OpcodeTablePtr", ")", "{", "DenseMap", "<", "unsigned", "*", ",", "unsigned", ">", "::", "iterator", "I", "=", "OpcodeTablePtr", "->", "find", "(", "(", "unsigned", "*", ")", "Opc", ")", ";", "if", "(", "I", "!=", "OpcodeTablePtr", "->", "end", "(", ")", ")", "return", "true", ";", "}", "return", "false", ";" ]

[ "}" ]

[ "setAvailableFeatures", "(", "ComputeAvailableFeatures", "(", "STI", ".", "ToggleFeature", "(", "FeatureString", ")", ")", ")", ";", "}" ]

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

[ "if", "(", "Slot", "==", "-", "<NUM_LIT>", ")", "{", "Error", "(", "S", ",", "<STR_LIT>", "invalid interpolation slot", "<STR_LIT>", ")", ";", "return", "MatchOperand_ParseFail", ";", "}", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateImm", "(", "this", ",", "Slot", ",", "S", ",", "AMDGPUOperand", "::", "ImmTyInterpSlot" ]

[ "int", "crx_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "crx_compute_save_regs", "(", ")", ";", "crx_compute_frame", "(", ")", ";", "if", "(", "(", "from", ")", "==", "FRAME_POINTER_REGNUM", "&&", "(", "to", ")", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "current_function_outgoing_args_size", ":", "<NUM_LIT>", ")", ";", "else", "if", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", "&&", "(", "to", ")", "==", "FRAME_POINTER_REGNUM", ")", "return", "(", "sum_regs", "+", "local_vars_size", ")", ";", "else", "if", "(", "(", "from", ")", "==", "ARG_POINTER_REGNUM", "&&", "(", "to", ")", "==", "STACK_POINTER_REGNUM", ")", "return", "(", "sum_regs", "+", "local_vars_size", "+", "(", "ACCUMULATE_OUTGOING_ARGS", "?", "current_function_outgoing_args_size", ":", "<NUM_LIT>", ")", ")", ";", "else", "abort", "(", ")", ";", "}" ]

[ "Implements", "the", "macro", "INITIAL_ELIMINATION_OFFSET", ",", "return", "the", "OFFSET", "." ]

[ "assert", "(", "ResTy", ".", "getVectorNumElements", "(", ")", "==", "ByteMask", ".", "size", "(", ")", ")", ";" ]

[ "MVT", "ElemTy", "=", "OpTy", ".", "getVectorElementType", "(", ")", ";", "if", "(", "ElemTy", "==", "MVT", "::", "i8", ")", "return", "DAG", ".", "getVectorShuffle", "(", "OpTy", ",", "dl", ",", "Op0", ",", "Op1", ",", "Mask", ")", ";", "assert", "(", "ElemTy", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", ";", "MVT", "ResTy", "=", "tyVector", "(", "OpTy", ",", "MVT", "::", "i8", ")", ";", "unsigned", "ElemSize", "=", "ElemTy", ".", "getSizeInBits", "(", ")", "/", "<NUM_LIT>", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ByteMask", ";", "for", "(", "int", "M", ":", "Mask", ")", "{", "if", "(", "M", "<", "<NUM_LIT>", ")", "{", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "!=", "ElemSize", ";", "++", "I", ")", "ByteMask", ".", "push_back", "(", "-", "<NUM_LIT>", ")", ";", "}", "else", "{", "int", "NewM", "=", "M", "*", "ElemSize", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "!=", "ElemSize", ";", "++", "I", ")", "ByteMask", ".", "push_back", "(", "NewM", "+", "I", ")", ";", "}", "}" ]

[ "}" ]

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

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

[ "(", "const_int", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "DI", "(", "and", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "const_int", "<NUM_LIT>", ")", ")", "<BUGE>", "(", "minus", ":", "DI", "(", "const_int", "<NUM_LIT>", ")", "(", "ashift", ":", "DI", "(", "and", ":", "DI" ]

[ "Relocator", "::", "Address", "GOT_OFF", "=", "file_format", "->", "getGOT", "(", ")", ".", "addr", "(", ")", "+", "got_entry1", "->", "getOffset", "(", ")", "-", "file_format", "->", "getGOTPLT", "(", ")", ".", "addr", "(", ")", ";" ]

[ "if", "(", "!", "(", "rsym", "->", "reserved", "(", ")", "&", "X86Relocator", "::", "ReserveGOT", ")", ")", "return", "Relocator", "::", "BadReloc", ";", "ELFFileFormat", "*", "file_format", "=", "pParent", ".", "getTarget", "(", ")", ".", "getOutputFormat", "(", ")", ";", "X86_32GOTEntry", "*", "got_entry1", "=", "pParent", ".", "getSymGOTMap", "(", ")", ".", "lookUpFirstEntry", "(", "*", "rsym", ")", ";", "if", "(", "rsym", "->", "isLocal", "(", ")", ")", "pParent", ".", "getSymGOTMap", "(", ")", ".", "lookUpSecondEntry", "(", "*", "rsym", ")", "->", "setValue", "(", "pReloc", ".", "symValue", "(", ")", ")", ";", "Relocator", "::", "DWord", "A", "=", "pReloc", ".", "target", "(", ")", "+", "pReloc", ".", "addend", "(", ")", ";" ]

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

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

[ "return", "false", ";" ]

[ "case", "CONST_DOUBLE", ":", "if", "(", "TARGET_VIS", "&&", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "const_zero_operand", "(", "x", ",", "mode", ")", "||", "const_all_ones_operand", "(", "x", ",", "mode", ")", ")", ")", "return", "true", ";" ]

[ "popSaved", "(", ")", ",", "<STR_LIT>", "<STR_LIT>", ",", "Term", ")", ";" ]

[ "if", "(", "isUniform", "(", "Term", ")", ")", "{", "return", "false", ";", "}", "Value", "*", "Ret", "=", "CallInst", "::", "Create", "(", "Else", "," ]

[ "int", "regno", "=", "true_regnum", "(", "x", ")", ";" ]

[ "static", "reg_class_t", "sparc_secondary_reload", "(", "bool", "in_p", ",", "rtx", "x", ",", "reg_class_t", "rclass_i", ",", "machine_mode", "mode", ",", "secondary_reload_info", "*", "sri", ")", "{", "enum", "reg_class", "rclass", "=", "(", "enum", "reg_class", ")", "rclass_i", ";", "sri", "->", "icode", "=", "CODE_FOR_nothing", ";", "sri", "->", "extra_cost", "=", "<NUM_LIT>", ";", "if", "(", "FP_REG_CLASS_P", "(", "rclass", ")", "&&", "(", "mode", "==", "HImode", "||", "mode", "==", "QImode", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "||", "(", "(", "GET_CODE", "(", "x", ")", "==", "REG", "||", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "&&", "true_regnum", "(", "x", ")", "==", "-", "<NUM_LIT>", ")", ")", ")", "return", "GENERAL_REGS", ";", "if", "(", "TARGET_ARCH32", "&&", "rclass", "==", "EXTRA_FP_REGS", "&&", "mode", "==", "DFmode", "&&", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "!", "mem_min_alignment", "(", "x", ",", "<NUM_LIT>", ")", ")", "return", "FP_REGS", ";", "if", "(", "(", "(", "TARGET_CM_MEDANY", "&&", "symbolic_operand", "(", "x", ",", "mode", ")", ")", "||", "(", "TARGET_CM_EMBMEDANY", "&&", "text_segment_operand", "(", "x", ",", "mode", ")", ")", ")", "&&", "!", "flag_pic", ")", "{", "if", "(", "in_p", ")", "sri", "->", "icode", "=", "direct_optab_handler", "(", "reload_in_optab", ",", "mode", ")", ";", "else", "sri", "->", "icode", "=", "direct_optab_handler", "(", "reload_out_optab", ",", "mode", ")", ";", "return", "NO_REGS", ";", "}", "if", "(", "TARGET_VIS3", "&&", "TARGET_ARCH32", ")", "{" ]

[ "<", "GPR32", ">", ";" ]

[ "def", "LDRBBpre_isel", ":", "LoadPreIdxPseudo" ]

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

[ "(", "define_mode_iterator", "VI1_AVX512VL_F", "[", "V32QI", "(", "V16QI", "<STR_LIT>", ")" ]

[ "}" ]

[ "def", "uimm_exact3", ":", "Operand", "<", "i32", ">", ",", "ImmLeaf", "<", "i32", ",", "[", "{", "return", "Imm", "=", "=", "<NUM_LIT>", ";", "}", "]", ">", "{", "let", "ParserMatchClass", "=", "exact3_asmoperand", ";" ]

[ ",", "GEN_INT", "(", "addend", ")", ")", ";" ]

[ "emit_insn_before", "(", "EM", "(", "gen_movqi_to_es", "(", "A", ")", ")", ",", "before", ")", ";", "}", "record_content", "(", "A", ",", "NULL_RTX", ")", ";", "new", "_", "m", "=", "gen_rtx_MEM", "(", "GET_MODE", "(", "m", ")", ",", "rl78_lo16", "(", "XEXP", "(", "m", ",", "<NUM_LIT>", ")", ")", ")", ";", "MEM_COPY_ATTRIBUTES", "(", "new", "_", "m", ",", "m", ")", ";", "m", "=", "new", "_", "m", ";", "need_es", "=", "<NUM_LIT>", ";", "}", "characterize_address", "(", "XEXP", "(", "m", ",", "<NUM_LIT>", ")", ",", "&", "base", ",", "&", "index", ",", "&", "addendr", ")", ";", "gcc_assert", "(", "index", "==", "NULL_RTX", ")", ";", "if", "(", "base", "==", "NULL_RTX", ")", "return", "m", ";", "if", "(", "addendr", "&&", "GET_CODE", "(", "addendr", ")", "==", "CONST_INT", ")", "addend", "=", "INTVAL", "(", "addendr", ")", ";", "gcc_assert", "(", "REG_P", "(", "base", ")", ")", ";", "gcc_assert", "(", "REG_P", "(", "new", "base", ")", ")", ";", "int", "limit", "=", "<NUM_LIT>", "-", "GET_MODE_SIZE", "(", "GET_MODE", "(", "m", ")", ")", ";", "if", "(", "REGNO", "(", "base", ")", "==", "SP_REG", ")", "{", "if", "(", "addend", ">=", "<NUM_LIT>", "&&", "addend", "<=", "limit", ")", "return", "m", ";", "}", "if", "(", "addend", "<", "<NUM_LIT>", "||", "(", "addend", ">", "limit", "&&", "REGNO", "(", "new", "base", ")", "!=", "BC_REG", ")", "||", "(", "addendr", "&&", "(", "GET_CODE", "(", "addendr", ")", "!=", "CONST_INT", ")", "&&", "(", "(", "REGNO", "(", "new", "base", ")", "!=", "BC_REG", ")", ")", ")", ")", "{", "EM", "(", "emit_insn_before", "(", "gen_movhi", "(", "AX", ",", "base", ")", ",", "before", ")", ")", ";", "EM", "(", "emit_insn_before", "(", "gen_addhi3", "(", "AX", ",", "AX", ",", "addendr", ")", ",", "before", ")", ")", ";", "EM", "(", "emit_insn_before", "(", "gen_movhi", "(", "new", "base", ",", "AX", ")", ",", "before", ")", ")", ";", "record_content", "(", "AX", ",", "NULL_RTX", ")", ";", "record_content", "(", "new", "base", ",", "NULL_RTX", ")", ";", "base", "=", "new", "base", ";", "addend", "=", "<NUM_LIT>", ";", "addendr", "=", "<NUM_LIT>", ";", "}", "else", "{", "base", "=", "gen_and_emit_move", "(", "new", "base", ",", "base", ",", "before", ",", "true", ")", ";", "}", "if", "(", "addend", ")", "{", "record_content", "(", "base", ",", "NULL_RTX", ")", ";", "base", "=", "gen_rtx_PLUS", "(", "HImode", ",", "base" ]

[ "}" ]

[ "let", "DiagnosticType", "=", "<STR_LIT>", ";", "let", "PredicateMethod", "=", "<STR_LIT>", "#", "N", "#", "<STR_LIT>", ";" ]

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

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

[ "]", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "MVE_2", "[", "(", "match_operand", ":", "MVE_2", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "<", "V_elem", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "MVE_INT_N_BINARY", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "symbol_ref", "<STR_LIT>", ")", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]