Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "*", "this", ")", ";" ]

[ "for", "(", "auto", "P", ":", "BA", ".", "Addr", "->", "members_if", "(", "IsPhi", ",", "*", "this", ")", ")", "PhiQ", ".", "insert", "(", "P", ".", "Id", ")", ";", "}", "static", "auto", "HasUsedDef", "=", "[", "]", "(", "NodeList", "&", "Ms", ")", "->", "bool", "{", "for", "(", "auto", "M", ":", "Ms", ")", "{", "if", "(", "M", ".", "Addr", "->", "getKind", "(", ")", "!=", "NodeAttrs", "::", "Def", ")", "continue", ";", "NodeAddr", "<", "DefNode", "*", ">", "DA", "=", "M", ";", "if", "(", "DA", ".", "Addr", "->", "getReachedDef", "(", ")", "!=", "<NUM_LIT>", "||", "DA", ".", "Addr", "->", "getReachedUse", "(", ")", "!=", "<NUM_LIT>", ")", "return", "true", ";", "}", "return", "false", ";", "}", ";", "while", "(", "!", "PhiQ", ".", "empty", "(", ")", ")", "{", "auto", "PA", "=", "addr", "<", "PhiNode", "*", ">", "(", "PhiQ", "[", "<NUM_LIT>", "]", ")", ";", "PhiQ", ".", "remove", "(", "PA", ".", "Id", ")", ";", "NodeList", "Refs", "=", "PA", ".", "Addr", "->", "members", "(", "*", "this", ")", ";", "if", "(", "HasUsedDef", "(", "Refs", ")", ")", "continue", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "Refs", ")", "{", "if", "(", "NodeId", "RD", "=", "RA", ".", "Addr", "->", "getReachingDef", "(", ")", ")", "{", "auto", "RDA", "=", "addr", "<", "DefNode", "*", ">", "(", "RD", ")", ";", "NodeAddr", "<", "InstrNode", "*", ">", "OA", "=", "RDA", ".", "Addr", "->", "getOwner", "(", "*", "this", ")", ";", "if", "(", "IsPhi", "(", "OA", ")", ")", "PhiQ", ".", "insert", "(", "OA", ".", "Id", ")", ";", "}", "if", "(", "RA", ".", "Addr", "->", "isDef", "(", ")", ")", "unlinkDef", "(", "RA", ")", ";", "else", "unlinkUse", "(", "RA", ")", ";", "}", "NodeAddr", "<", "BlockNode", "*", ">", "BA", "=", "PA", ".", "Addr", "->", "getOwner", "(", "*", "this", ")", ";", "BA", ".", "Addr", "->", "removeMember", "(", "PA", "," ]

[ "int", "standard_80387_constant_p", "(", "rtx", "x", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "REAL_VALUE_TYPE", "r", ";", "if", "(", "!", "(", "X87_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", ")", ")", "return", "-", "<NUM_LIT>", ";", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "x", "==", "CONST1_RTX", "(", "mode", ")", ")", "return", "<NUM_LIT>", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "mode", "==", "XFmode", "&&", "(", "optimize_function_for_size_p", "(", "cfun", ")", "||", "TARGET_EXT_80387_CONSTANTS", ")", ")", "{", "int", "i", ";", "if", "(", "!", "ext_80387_constants_init", ")", "init_ext_80387_constants", "(", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "real_identical", "(", "&", "r", ",", "&", "ext_80387_constants_table", "[", "i", "]", ")", ")", "return", "i", "+", "<NUM_LIT>", ";", "}", "if", "(", "real_isnegzero", "(", "&", "r", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "real_identical", "(", "&", "r", ",", "&", "dconstm1", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "true", "if", "the", "constant", "is", "something", "that", "can", "be", "loaded", "with", "a", "special", "instruction", "." ]

[ "const", "{" ]

[ "void", "AArch64BranchTargets", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")" ]

[ "HasHazard", "|=", "RegDU", ".", "update", "(", "Candidate", ",", "<NUM_LIT>", ",", "Candidate", ".", "getNumOperands", "(", ")", ")", ";" ]

[ "HasHazard", "|=", "SawStore", ";", "SawLoad", "=", "true", ";", "}", "assert", "(", "(", "!", "Candidate", ".", "isCall", "(", ")", "&&", "!", "Candidate", ".", "isReturn", "(", ")", ")", "&&", "<STR_LIT>", "Cannot put calls or returns in delay slot.", "<STR_LIT>", ")", ";" ]

[ "mmask16", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_unpckhps512_mask", "(", "(", "_", "_", "v16sf", ")", "_", "_", "A", ",", "(", "_", "_", "v16sf", ")", "_", "_", "B", ",", "(", "_", "_", "v16sf", ")", "_", "_", "W", ",", "(", "_", "_" ]

[ "S", ";" ]

[ "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rm", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "align", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "<NUM_LIT>", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "<NUM_LIT>", "<<", "align", ")", ")", ";", "return" ]

[ "}" ]

[ "}", "if", "(", "HexagonMCInstrInfo", "::", "isImmext", "(", "*", "Inst", ")", ")", "{", "BExtended", "=", "true", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "J,B: ", "<STR_LIT>", "<<", "JumpInst", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", ",", "<STR_LIT>", "<<", "Inst", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "if", "(", "isOrderedCompoundPair", "(", "*", "Inst", ",", "BExtended", ",", "*", "JumpInst", ",", "JExtended", ")", ")", "{", "MCInst", "*", "CompoundInsn", "=", "getCompoundInsn", "(", "Context", ",", "*", "Inst", ",", "*", "JumpInst", ")", ";", "if", "(", "CompoundInsn", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "B: ", "<STR_LIT>", "<<", "Inst", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", ",", "<STR_LIT>", "<<", "JumpInst", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", " Compounds to ", "<STR_LIT>", "<<", "CompoundInsn", "->", "getOpcode", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "J", "->", "setInst", "(", "CompoundInsn", ")", ";", "MCI", ".", "erase", "(", "B", ")", ";", "return", "true", ";", "}", "}", "BExtended", "=", "false", ";", "}", "}", "JExtended", "=", "false", ";", "}", "return", "false", ";" ]

[ "}" ]

[ "XCoreFTAOElim", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", "{", "}", "XCoreFTAOElim", "(", ")", ":", "MachineFunctionPass", "(", "ID", ")", "{" ]

[ "<FIXS>", "#", "ifdef", "SDB_OUTPUT_SOURCE_LINE", "<FIXE>", "<FIXS>", "SDB_OUTPUT_SOURCE_LINE", "(", "file", ",", "DECL_SOURCE_LINE", "(", "current_function_decl", ")", ")", ";", "<FIXE>" ]

[ "ASM_OUTPUT_SOURCE_FILENAME", "(", "file", ",", "DECL_SOURCE_FILE", "(", "current_function_decl", ")", ")", ";", "#", "endif", "<BUGS>", "#", "ifdef", "ASM_OUTPUT_SOURCE_LINE", "<BUGE>", "if", "(", "debug_info_level", "!=", "DINFO_LEVEL_TERSE", ")", "<BUGS>", "ASM_OUTPUT_SOURCE_LINE", "(", "file", ",", "DECL_SOURCE_LINE", "(", "current_function_decl", ")", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "#", "endif", "}" ]

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

[ "static", "int", "avr_signal_function_p", "(", "tree", "func", ")", "{", "return", "avr_lookup_function_attribute1", "(", "func", ",", "<STR_LIT>" ]

[ "return", "<STR_LIT>" ]

[ "VLDRWGSOQ", ")", ")", "]", "<STR_LIT>", "{", "rtx", "ops", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "ops", "[", "<NUM_LIT>", "]", "=", "operands", "[", "<NUM_LIT>", "]", "output_asm_insn", "(", "<STR_LIT>", ",", "ops", ")" ]

[ "::", "arm_neon_vshifts", ":" ]

[ "break", ";", "case", "Intrinsic", "::", "arm_neon_vshifts", ":", "case", "Intrinsic", "::", "arm_neon_vshiftu", ":", "case", "Intrinsic", "::", "arm_neon_vshiftls", ":", "case", "Intrinsic", "::", "arm_neon_vshiftlu", ":", "case", "Intrinsic", "::", "arm_neon_vshiftn", ":", "case", "Intrinsic", "::", "arm_neon_vrshifts", ":", "case", "Intrinsic", "::", "arm_neon_vrshiftu", ":", "case", "Intrinsic", "::", "arm_neon_vrshiftn", ":", "case", "Intrinsic", "::", "arm_neon_vqshifts", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftu", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftsu", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftns", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftnu", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftnsu", ":", "case", "Intrinsic", "::", "arm_neon_vqrshiftns", ":", "case", "Intrinsic", "::", "arm_neon_vqrshiftnu", ":", "case", "Intrinsic", "::", "arm_neon_vqrshiftnsu", ":", "{", "EVT", "VT", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getValueType", "(", ")", ";", "int64_t", "Cnt", ";", "unsigned", "VShiftOpc", "=", "<NUM_LIT>", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "arm_neon_vshifts", ":", "case", "Intrinsic", "::", "arm_neon_vshiftu", ":", "if", "(", "isVShiftLImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "false", ",", "Cnt", ")", ")", "{", "VShiftOpc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "break", ";", "}", "if", "(", "isVShiftRImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "false", ",", "true", ",", "Cnt", ")", ")", "{", "VShiftOpc", "=", "(", "IntNo", "==", "Intrinsic", "::", "arm_neon_vshifts", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "break", ";", "}", "return", "SDValue", "(", ")", ";", "case", "Intrinsic", "::", "arm_neon_vshiftls", ":", "case", "Intrinsic", "::", "arm_neon_vshiftlu", ":", "if", "(", "isVShiftLImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "true", ",", "Cnt", ")", ")", "break", ";", "llvm_unreachable", "(", "<STR_LIT>", "invalid shift count for vshll intrinsic", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "arm_neon_vrshifts", ":", "case", "Intrinsic", "::", "arm_neon_vrshiftu", ":", "if", "(", "isVShiftRImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "false", ",", "true", ",", "Cnt", ")", ")", "break", ";", "return", "SDValue", "(", ")", ";", "case", "Intrinsic", "::", "arm_neon_vqshifts", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftu", ":", "if", "(", "isVShiftLImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "false", ",", "Cnt", ")", ")", "break", ";", "return", "SDValue", "(", ")", ";", "case", "Intrinsic", "::", "arm_neon_vqshiftsu", ":", "if", "(", "isVShiftLImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "false", ",", "Cnt", ")", ")", "break", ";", "llvm_unreachable", "(", "<STR_LIT>", "invalid shift count for vqshlu intrinsic", "<STR_LIT>", ")", ";", "case", "Intrinsic", "::", "arm_neon_vshiftn", ":", "case", "Intrinsic", "::", "arm_neon_vrshiftn", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftns", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftnu", ":", "case", "Intrinsic", "::", "arm_neon_vqshiftnsu", ":", "case", "Intrinsic", "::", "arm_neon_vqrshiftns", ":", "case", "Intrinsic", "::", "arm_neon_vqrshiftnu", ":", "case", "Intrinsic", "::", "arm_neon_vqrshiftnsu", ":", "if", "(", "isVShiftRImm", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VT", ",", "true", ",", "true", ",", "Cnt", ")", ")", "break", ";", "llvm_unreachable", "(", "<STR_LIT>", "invalid shift count for narrowing vector shift ", "<STR_LIT>", "<STR_LIT>", "intrinsic", "<STR_LIT>", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unhandled vector shift", "<STR_LIT>", ")", ";", "}", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic" ]

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

[ "if", "(", "MI", "&&", "MI", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "G_FNEG", "&&", "MRI", ".", "getType", "(", "Src", ")", "==", "LLT", "::", "fixed_vector", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "Mods", "^=", "(", "<STR_LIT>", "::", "<STR_LIT>", "|", "<STR_LIT>", "::" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "VI4F_256", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "vec_concat", ":", "VI4F_256", "(", "vec_select", ":", "<", "ssehalfvecmode", ">", "(", "match_operand", ":", "VI4F_256", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", "(", "match_operand", ":", "<", "ssehalfvecmode", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "TARGET_AVX512VL", ")", "return", "<STR_LIT>", "else", "return", "<STR_LIT>", "}", "[", "(", "set_attr" ]

[ "return", "NULL", ";" ]

[ "static", "tree", "alpha_fold_builtin_cttz", "(", "unsigned", "HOST_WIDE_INT", "opint", "[", "]", ",", "long", "op_const", ")", "{", "unsigned", "HOST_WIDE_INT", "temp", ";", "if", "(", "op_const", "==", "<NUM_LIT>", ")" ]

[ ")" ]

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "def", "ARMpic_add", ":", "SDNode", "<" ]

[ ")", ";" ]

[ "return", "_", "_", "builtin_loongson_pshufh_s", "(", "s", ",", "or", "der" ]

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

[ "class", "BaseAddSubImm", "<", "bit", "isSub", ",", "bit", "setFlags", ",", "RegisterClass", "dstRegtype", ",", "string", "asm_inst", ",", "string", "asm_ops", ",", "dag", "inputs", ",", "dag", "pattern", ">", ":", "I", "<", "(", "outs", "dstRegtype", ":", "$", "Rd", ")", ",", "inputs", ",", "asm_inst", ",", "asm_ops", ",", "<STR_LIT>", ",", "[", "pattern", "]", ">", ",", "Sched", "<", "[", "WriteI", ",", "ReadI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "setFlags", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "void", "final_prescan_insn", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "opvec", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_DUMPISIZE", ")", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\n! at %04x\\n", "<STR_LIT>", ",", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "TARGET_RELAX", ")", "{", "if", "(", "rtx", "not", "e", "=", "find_reg_note", "(", "insn", ",", "REG_LABEL_OPERAND", ",", "NULL_RTX", ")", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "PARALLEL", ")", "pattern", "=", "XVECEXP", "(", "pattern", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "switch", "(", "GET_CODE", "(", "pattern", ")", ")", "{", "case", "SET", ":", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "CALL", "&&", "get_attr_type", "(", "insn", ")", "!=", "TYPE_SFUNC", ")", "{", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "<STR_LIT>", "L", "<STR_LIT>", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "not", "e", ",", "<NUM_LIT>", ")", ")", ")", ";", "break", ";", "}", "case", "CALL", ":", "asm_fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.uses %LL%d\\n", "<STR_LIT>", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "not", "e", ",", "<NUM_LIT>", ")", ")", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "}" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "<NUM_LIT>", ";" ]

[ "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "HalfWordAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=" ]

[ "C", ".", "CCMask", ")", ";" ]

[ "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "lowerVectorSETCC", "(", "DAG", ",", "DL", ",", "VT", ",", "CC", ",", "CmpOp0", ",", "CmpOp1", ")", ";", "Comparison", "C", "(", "getCmp", "(", "DAG", ",", "CmpOp0", ",", "CmpOp1", ",", "CC", ",", "DL", ")", ")", ";", "SDValue", "CCReg", "=", "emitCmp", "(", "DAG", ",", "DL", ",", "C", ")", ";", "return", "emitSETCC", "(", "DAG", ",", "DL", ",", "CCReg", ",", "C", ".", "CCValid", "," ]

[ "static", "rtx", "mips_unspec_call", "(", "rtx", "reg", ",", "rtx", "symbol", ")", "{", "rtvec", "vec", ";", "vec", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "reg", ",", "symbol", ",", "gen_rtx_REG", "(", "SImode", ",", "GOT_VERSION_REGNUM", ")", ")", ";", "return", "gen_rtx_UNSPEC", "(", "Pmode", ",", "vec", ",", "UNSPEC_LOAD_CALL", ")", ";", "}" ]

[ "Return", "the", "RHS", "of", "a", "load_call", "<", "mode", ">", "insn", "." ]

[ "register_pass", "(", "&", "insert_pass_visium_reorg", ")", ";" ]

[ "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "align_loops", "=", "<NUM_LIT>", ";", "else", "{", "align_loops", "=", "<NUM_LIT>", ";", "align_loops_max_skip", "=", "<NUM_LIT>", ";", "}", "}", "if", "(", "align_jumps", "==", "<NUM_LIT>", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR6", ")", "align_jumps", "=", "<NUM_LIT>", ";", "else", "align_jumps", "=", "<NUM_LIT>", ";", "}", "opt_pass", "*", "visium_reorg_pass", "=", "make_pass_visium_reorg", "(", "g", ")", ";", "struct", "register_pass_info", "insert_pass_visium_reorg", "=", "{", "visium_reorg_pass", ",", "<STR_LIT>", "dbr", "<STR_LIT>", ",", "<NUM_LIT>", ",", "PASS_POS_INSERT_AFTER", "}", ";" ]

[ "&&", "<STR_LIT>", "Post increment operand has be to a register.", "<STR_LIT>", ")", ";" ]

[ "if", "(", "MI", "->", "mayLoad", "(", ")", ")", "{", "const", "MachineOperand", "&", "Op1", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "Op1", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Post increment operand has be to a register.", "<STR_LIT>", ")", ";", "return", "Op1", ";", "}", "if", "(", "MI", "->", "getDesc", "(", ")", ".", "mayStore", "(", ")", ")", "{", "const", "MachineOperand", "&", "Op0", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "Op0", ".", "isReg", "(", ")" ]

[ "}" ]

[ "if", "(", "TARGET_R8C", "||", "TARGET_M16C", ")", "return", "n", ";", "return", "(", "n", "+", "<NUM_LIT>", ")", "&", "~", "<NUM_LIT>", ";" ]

[ "::", "Other", ")", ";" ]

[ "}", "bool", "ConstSplatVal", "=", "(", "Ld", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "Ld", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ConstantFP", ")", ";", "bool", "IsLoad", "=", "ISD", "::", "isNormalLoad", "(", "Ld", ".", "getNode", "(", ")", ")", ";", "if", "(", "!", "ConstSplatVal", "&&", "!", "IsLoad", "&&", "!", "BVOp", "->", "isOnlyUserOf", "(", "Ld", ".", "getNode", "(", ")", ")", ")", "return", "SDValue", "(", ")", ";", "unsigned", "ScalarSize", "=", "Ld", ".", "getValueSizeInBits", "(", ")", ";", "bool", "IsGE256", "=", "(", "VT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", ";", "bool", "OptForSize", "=", "DAG", ".", "shouldOptForSize", "(", ")", ";", "if", "(", "ConstSplatVal", "&&", "(", "Subtarget", ".", "hasAVX2", "(", ")", "||", "OptForSize", ")", ")", "{", "EVT", "CVT", "=", "Ld", ".", "getValueType", "(", ")", ";", "assert", "(", "!", "CVT", ".", "isVector", "(", ")", "&&", "<STR_LIT>", "Must not broadcast a vector type", "<STR_LIT>", ")", ";", "if", "(", "ScalarSize", "==", "<NUM_LIT>", "||", "(", "IsGE256", "&&", "ScalarSize", "==", "<NUM_LIT>", ")", "||", "(", "OptForSize", "&&", "(", "ScalarSize", "==", "<NUM_LIT>", "||", "Subtarget", ".", "hasAVX2", "(", ")", ")", ")", ")", "{", "const", "Constant", "*", "C", "=", "nullptr", ";", "if", "(", "ConstantSDNode", "*", "CI", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Ld", ")", ")", "C", "=", "CI", "->", "getConstantIntValue", "(", ")", ";", "else", "if", "(", "ConstantFPSDNode", "*", "CF", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Ld", ")", ")", "C", "=", "CF", "->", "getConstantFPValue", "(", ")", ";", "assert", "(", "C", "&&", "<STR_LIT>", "Invalid constant type", "<STR_LIT>", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "SDValue", "CP", "=", "DAG", ".", "getConstantPool", "(", "C", ",", "TLI", ".", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ")", ";", "MaybeAlign", "Alignment", "(", "cast", "<", "ConstantPoolSDNode", ">", "(", "CP", ")", "->", "getAlignment", "(", ")", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "DAG", ".", "getEntryNode", "(", ")", ",", "CP", "}", ";", "MachinePointerInfo", "MPI", "=", "MachinePointerInfo", "::", "getConstantPool", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ";", "return", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "CVT", ",", "MPI", ",", "Alignment", ",", "MachineMemOperand", "::", "MOLoad", ")", ";", "}", "}", "if", "(", "!", "IsLoad", "&&", "Subtarget", ".", "hasInt256", "(", ")", "&&", "(", "ScalarSize", "==", "<NUM_LIT>", "||", "(", "IsGE256", "&&", "ScalarSize", "==", "<NUM_LIT>", ")", ")", ")", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "VT", ",", "Ld", ")", ";", "if", "(", "!", "IsLoad", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "Ld", "->", "hasNUsesOfValue", "(", "NumElts", "-", "NumUndefElts", ",", "<NUM_LIT>", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "ScalarSize", "==", "<NUM_LIT>", "||", "(", "IsGE256", "&&", "ScalarSize", "==", "<NUM_LIT>", ")", "||", "(", "Subtarget", ".", "hasVLX", "(", ")", "&&", "ScalarSize", "==", "<NUM_LIT>", ")", ")", "{", "auto", "*", "LN", "=", "cast", "<", "LoadSDNode", ">", "(", "Ld", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT", "::", "Other", ")", ";", "SDValue", "Ops", "[", "]", "=", "{", "LN", "->", "getChain", "(", ")", ",", "LN", "->", "getBasePtr", "(", ")", "}", ";", "SDValue", "BCast", "=", "DAG", ".", "getMemIntrinsicNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "Tys", ",", "Ops", ",", "LN", "->", "getMemoryVT", "(", ")", ",", "LN", "->", "getMemOperand", "(", ")", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "LN", ",", "<NUM_LIT>", ")", ",", "BCast", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "return", "BCast", ";", "}", "if", "(", "Subtarget", ".", "hasInt256", "(", ")", "&&", "Ld", ".", "getValueType", "(", ")", ".", "isInteger", "(", ")", "&&", "(", "ScalarSize", "==", "<NUM_LIT>", "||", "ScalarSize", "==", "<NUM_LIT>", "||", "ScalarSize", "==", "<NUM_LIT>", ")", ")", "{", "auto", "*", "LN", "=", "cast", "<", "LoadSDNode", ">", "(", "Ld", ")", ";", "SDVTList", "Tys", "=", "DAG", ".", "getVTList", "(", "VT", ",", "MVT" ]

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

[ "unsigned", "ARMFastISel", "::", "fastEmitInst_r", "(", "unsigned", "MachineInstOpcode", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Op0", ",", "bool", "Op0IsKill", ")", "{", "Register", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "const", "MCInstrDesc", "&", "II", "=", "TII", ".", "get", "(", "MachineInstOpcode", ")", ";", "Op0", "=", "constrainOperandRegClass", "(", "II", ",", "Op0", ",", "<NUM_LIT>", ")", ";", "if", "(", "II", ".", "getNumDefs", "(", ")", ">=", "<NUM_LIT>", ")", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ",", "ResultReg", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ")", ";", "}", "else", "{", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "II", ")", ".", "addReg", "(", "Op0", ",", "Op0IsKill", "*", "RegState", "::", "Kill", ")", ")", ";" ]

[ ")", "a1", ",", "(", "vector", "signed", "int", ")", "a2", ")", ";" ]

[ "return", "(", "vector", "unsigned", "int", ")", "_", "_", "builtin_altivec_vavguw", "(", "(", "vector", "signed", "int" ]

[ "<NUM_LIT>", ";" ]

[ "return", "RestoreBasePointerOffset", "!=" ]

[ "Rt2", ";" ]

[ "class", "BaseLoadStorePairPostIdx", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bit", "V", ",", "bit", "L", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "asm", ">", ":", "I", "<", "oops", ",", "iops", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m256d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_fmadd_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m256d", "_", "_", "A", ",", "_", "_", "m256d", "_", "_", "B", ",", "_", "_", "m256d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m256d", ")", "_", "_", "builtin_ia32_vfmaddpd256_maskz", "(", "(", "_", "_", "v4df", ")", "_", "_", "A", ",", "(", "_", "_", "v4df", ")", "_", "_", "B", ",", "(", "_", "_", "v4df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ ")", "return", "nullptr", ";" ]

[ "Register", "Reg", "=", "Op", "->", "getReg", "(", ")", ";", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "Reg", ")" ]

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

[ "_", "_", "arm_vqshlq_r_s16", "(", "int16x8_t", "_", "_", "a", ",", "int32_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_mve_vqshlq_r_sv8hi", "(", "_", "_", "a", "," ]

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

[ "case", "LTU", ":", "pos", "=", "<STR_LIT>", "blo", "<STR_LIT>", ",", "neg", "=", "<STR_LIT>", "bhis", "<STR_LIT>", ";", "break", ";", "case", "GE", ":", "pos", "=", "<STR_LIT>", "bge", "<STR_LIT>", ",", "neg", "=", "<STR_LIT>", "blt", "<STR_LIT>", ";", "break", ";", "case", "GEU", ":", "pos", "=", "<STR_LIT>", "bhis", "<STR_LIT>", ",", "neg", "=", "<STR_LIT>", "blo", "<STR_LIT>", ";", "break", ";", "case", "LE", ":", "pos", "=", "<STR_LIT>", "ble", "<STR_LIT>", ",", "neg", "=", "<STR_LIT>", "bgt", "<STR_LIT>", ";", "break", ";", "case", "LEU", ":", "pos", "=", "<STR_LIT>", "blos", "<STR_LIT>", ",", "neg", "=", "<STR_LIT>", "bhi", "<STR_LIT>", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "switch", "(", "length", ")", "{", "case", "<NUM_LIT>", ":", "sprintf", "(", "buf", ",", "<STR_LIT>", "%s\\t%%l1", "<STR_LIT>", ",", "pos", ")", ";", "return", "buf", ";", "case", "<NUM_LIT>", ":", "tmpop", "[", "<NUM_LIT>", "]", "=", "gen_label_rtx", "(", ")", ";", "sprintf", "(", "buf", ",", "<STR_LIT>", "%s\\t%%l0", "<STR_LIT>", ",", "neg", ")", ";", "output_asm_insn", "(", "buf", "," ]

[ "call", "[", "<NUM_LIT>", "]", "=", "gen_rtx_CALL", "(", "VOIDmode", ",", "gen_rtx_MEM", "(", "SImode", ",", "func_addr", ")", ",", "tlsarg", ")", ";" ]

[ "void", "rs6000_sibcall_aix", "(", "rtx", "value", ",", "rtx", "func_desc", ",", "rtx", "tlsarg", ",", "rtx", "cookie", ")", "{", "rtx", "call", "[", "<NUM_LIT>", "]", ";", "rtx", "insn", ";", "rtx", "r12", "=", "NULL_RTX", ";", "rtx", "func_addr", "=", "func_desc", ";", "if", "(", "global_tlsarg", ")", "tlsarg", "=", "global_tlsarg", ";", "if", "(", "INTVAL", "(", "cookie", ")", "&", "CALL_LONG", "&&", "SYMBOL_REF_P", "(", "func_desc", ")", ")", "{", "gcc_assert", "(", "rs6000_pcrel_p", "(", ")", ")", ";", "func_desc", "=", "rs6000_longcall_ref", "(", "func_desc", ",", "tlsarg", ")", ";", "}", "else", "gcc_assert", "(", "INTVAL", "(", "cookie", ")", "==", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "func_desc", ")", "!=", "SYMBOL_REF", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "r12", "=", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ";", "emit_move_insn", "(", "r12", ",", "func_desc", ")", ";", "func_addr", "=", "gen_rtx_REG", "(", "Pmode", ",", "CTR_REGNO", ")", ";", "emit_move_insn", "(", "func_addr", ",", "r12", ")", ";", "}" ]

[ "<STR_LIT>", ")" ]

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

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

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

[ "addReg", "(", "DestReg", ")", ".", "addReg", "(", "SrcReg", ")", ";" ]

[ "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "SrcReg", ")", "&&", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "DestReg", ")", ")", "opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "else", "opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "opc", ")", ")", "." ]

[ "<FIXS>", "let", "DestructiveInstType", "=", "DestructiveOther", ";", "<FIXE>" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Zda", ";", "let", "Constraints", "=", "<STR_LIT>", ";", "<BUGS>", "let", "DestructiveInstType", "=", "Destructive", ";", "<BUGE>", "}", "multiclass", "sve_intx_dot_by_indexed_elem", "bit", "opc", ",", "string", "asm", "," ]

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

[ "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_LSHRREV_B32_e64", ")", ",", "ResultReg", ")", ".", "addImm", "(", "ST", ".", "getWavefrontSizeLog2", "(", ")", ")", ".", "addReg", "(", "FrameReg", ")", ";", "}", "else", "{", "if", "(", "auto", "MIB", "=", "TII", "->", "getAddNoCarry", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "ResultReg", ",", "*", "RS", ")", ")", "{", "Register", "ScaledReg", "=", "ResultReg", ";", "BuildMI", "(", "*", "MBB", ",", "*", "MIB", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_LSHRREV_B32_e64", ")", ",", "ScaledReg", ")", ".", "addImm", "(", "ST", ".", "getWavefrontSizeLog2", "(", ")", ")", ".", "addReg", "(", "FrameReg", ")", ";", "const", "bool", "IsVOP2", "=", "MIB", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_ADD_U32_e32", ";", "if", "(", "IsVOP2", "||", "AMDGPU", "::", "isInlinableLiteral32", "(", "Offset", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ")", "{", "MIB", ".", "addImm", "(", "Offset", ")", ";", "MIB", ".", "addReg", "(", "ScaledReg", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "!", "IsVOP2", ")", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "assert", "(", "MIB", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "V_ADD_CO_U32_e64", "&&", "<STR_LIT>", "Need to reuse carry out register", "<STR_LIT>", ")", ";", "Register", "ConstOffsetReg", ";", "if", "(", "!", "isWave32", ")", "ConstOffsetReg", "=", "getSubReg", "(", "MIB", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "AMDGPU", "::", "sub0", ")", ";", "else", "ConstOffsetReg", "=", "MIB", ".", "getReg", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "*", "MBB", ",", "*", "MIB", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "ConstOffsetReg", ")", ".", "addImm", "(", "Offset", ")", ";", "MIB", ".", "addReg", "(", "ConstOffsetReg", ",", "RegState", "::", "Kill", ")", ";", "MIB", ".", "addReg", "(", "ScaledReg", ",", "RegState", "::", "Kill", ")", ";", "MIB", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "}", "else", "{", "Register", "TmpScaledReg", "=", "RS", "->", "scavengeRegister", "(", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ",", "MI", ",", "<NUM_LIT>", ",", "false", ")", ";", "Register", "ScaledReg", "=", "TmpScaledReg", ".", "isValid", "(", ")", "?", "TmpScaledReg", ":", "FrameReg", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_LSHR_B32", ")", ",", "ScaledReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "ST", ".", "getWavefrontSizeLog2", "(", ")", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_ADD_U32", ")", ",", "ScaledReg", ")", ".", "addReg", "(", "ScaledReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "COPY", ")", ",", "ResultReg", ")", ".", "addReg", "(", "ScaledReg", ",", "RegState", "::", "Kill", ")", ";", "if", "(", "!", "TmpScaledReg", ".", "isValid", "(", ")", ")", "{", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_SUB_U32", ")", ",", "ScaledReg", ")", ".", "addReg", "(", "ScaledReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "Offset", ")", ";", "BuildMI", "(", "*", "MBB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_LSHL_B32", ")", ",", "ScaledReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "ST", ".", "getWavefrontSizeLog2", "(", ")", ")", ";", "}", "}", "}", "if", "(", "IsCopy", ")", "MI", "->", "eraseFromParent", "(", ")", ";", "else", "FIOp", ".", "ChangeToRegister", "(", "ResultReg", ",", "false", ",", "false", ",", "true", ")", ";", "return", ";", "}", "if", "(", "IsMUBUF", ")", "{", "assert", "(", "static_cast", "<", "int", ">", "(", "FIOperandNum", ")", "==", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ")", ";", "auto", "&", "SOffset", "=", "*", "TII", "->", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", ";", "assert", "(", "(", "SOffset", ".", "isReg", "(", ")", "&&", "SOffset", ".", "getReg", "(", ")", "==", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", "||", "(", "SOffset", ".", "isImm", "(", ")", "&&", "SOffset", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", ")", ";", "if", "(", "SOffset", ".", "isReg", "(", ")", ")", "{", "if", "(", "FrameReg", "==", "AMDGPU", "::", "NoRegister", ")", "{", "SOffset", ".", "ChangeToImmediate", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "SOffset", ".", "setReg", "(", "FrameReg", ")", ";", "}", "}", "else", "if", "(", "SOffset", ".", "isImm", "(", ")", "&&", "FrameReg", "!=", "AMDGPU", "::", "NoRegister", ")", "{", "SOffset", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "}", "int64_t", "Offset", "=", "FrameInfo", ".", "getObjectOffset", "(" ]

[ ")", "{" ]

[ "if", "(", "Mnemonic", "==", "<STR_LIT>", "bkpt", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "cbnz", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "setend", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "cps", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "it", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "cbz", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "trap", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "setend", "<STR_LIT>", "||", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "cps", "<STR_LIT>", ")", "||", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "vsel", "<STR_LIT>", ")", "||", "Mnemonic", "==", "<STR_LIT>", "vmaxnm", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vminnm", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vcvta", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vcvtn", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vcvtp", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vcvtm", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vrinta", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vrintn", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vrintp", "<STR_LIT>", "||", "Mnemonic", "==", "<STR_LIT>", "vrintm", "<STR_LIT>", ")", "{", "CanAcceptPredicationCode", "=", "false", ";", "}", "else", "if", "(", "!", "isThumb", "(", ")", ")", "{", "CanAcceptPredicationCode", "=", "Mnemonic", "!=", "<STR_LIT>", "cdp2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "clrex", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "mcr2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "mcrr2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "mrc2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "mrrc2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "dmb", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "dsb", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "isb", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "pld", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "pli", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "pldw", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "ldc2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "ldc2l", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "stc2", "<STR_LIT>", "&&", "Mnemonic", "!=", "<STR_LIT>", "stc2l", "<STR_LIT>", "&&", "!", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "rfe", "<STR_LIT>", ")", "&&", "!", "Mnemonic", ".", "startswith", "(", "<STR_LIT>", "srs", "<STR_LIT>", ")", ";", "}", "else", "if", "(", "isThumbOne", "(", ")" ]

[ ")", ",", "Disp", ".", "getImm", "(", ")", ")", ",", "++", "MOI", ")", ";" ]

[ "const", "MachineOperand", "&", "Disp", "=", "*", "(", "++", "MOI", ")", ";", "const", "MachineOperand", "&", "ZeroReg", "=", "*", "(", "++", "MOI", ")", ";", "assert", "(", "Base", ".", "isReg", "(", ")", "&&", "Scale", ".", "isImm", "(", ")", "&&", "Scale", ".", "getImm", "(", ")", "==", "<NUM_LIT>", "&&", "Index", ".", "isReg", "(", ")", "&&", "Index", ".", "getReg", "(", ")", "==", "<NUM_LIT>", "&&", "Disp", ".", "isImm", "(", ")", "&&", "ZeroReg", ".", "isReg", "(", ")", "&&", "(", "ZeroReg", ".", "getReg", "(", ")", "==", "<NUM_LIT>", ")", "&&", "<STR_LIT>", "Unsupported x86 memory operand sequence.", "<STR_LIT>", ")", ";", "(", "void", ")", "Scale", ";", "(", "void", ")", "Index", ";", "(", "void", ")", "ZeroReg", ";", "return", "std", "::", "make_pair", "(", "Location", "(", "LocTy", ",", "Base", ".", "getReg", "(" ]

[ "}" ]

[ "def", "vsplat_uimm6", ":", "Operand", "<", "vAny", ">", "{", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

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

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

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float", ":", "SFDF", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SFDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "float", ":", "SFDF", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "DI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "\t", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "SI", "[", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "void", "AGCMCELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "bool", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "int64_t", "ImmOp", "=", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "StringRef", "SectionName", "=", "ImmOp", "==", "<NUM_LIT>", "?", "<STR_LIT>", "BLOCK0", "<STR_LIT>", ":", "(", "<STR_LIT>", "BANK", "<STR_LIT>", "+", "itostr", "(", "ImmOp", ")", ")", ";", "MCSection", "*", "Section", "=", "(", "(", "MCSection", "*", ")", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ")", ";", "SwitchSection", "(", "Section", ",", "nullptr", ")", ";", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "StringRef", "SectionName", "=", "<STR_LIT>", "BANK", "<STR_LIT>", "+", "itostr", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "MCSection", "*", "Section", "=", "(", "(", "MCSection", "*", ")", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ")", ";", "SwitchSection", "(", "Section", ",", "nullptr", ")", ";", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "return", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "StringRef", "SectionName", "=", "<STR_LIT>", "ADDR", "<STR_LIT>", "+", "itostr", "(", "Inst", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "MCSection", "*", "Section", "=", "(", "(", "MCSection", "*", ")", "getContext", "(", ")", ".", "getELFSection", "(", "SectionName", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_EXECINSTR", "|", "ELF", "::", "SHF_ALLOC", ")", ")", ";", "SwitchSection", "(", "Section", ",", "nullptr", ")", ";", "return", ";", "}", "}", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "}" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "}" ]

[ "assert", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "<STR_LIT>", "Unexpected opcode!", "<STR_LIT>", ")", ";", "MachineOperand", "&", "CCOp", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "static_cast", "<", "<STR_LIT>", "::", "<STR_LIT>", ">", "(", "CCOp", ".", "getImm", "(", ")", ")", ";", "CCOp", ".", "setImm", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "CC", ")", ")", ";" ]

[ ")", "]" ]

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

[ "return", "MatchOperand_NoMatch", ";" ]

[ "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Index", ",", "Identifier", ",", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "S", ",", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "*", "this", ")", ")", ";", "return", "MatchOperand_Success", ";", "}", "Index", "=", "matchMSA128CtrlRegisterName", "(", "Identifier", ")", ";", "if", "(", "Index", "!=", "-", "<NUM_LIT>", ")", "{", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Index", ",", "Identifier", ",", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "S", ",", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "*", "this", ")", ")", ";", "return", "MatchOperand_Success", ";", "}", "Index", "=", "matchCheriRegisterName", "(", "Identifier", ",", "Operands", ")", ";", "if", "(", "Index", "!=", "-", "<NUM_LIT>", ")", "{", "if", "(", "Index", "==", "-", "<NUM_LIT>", ")", "return", "MatchOperand_ParseFail", ";", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Index", ",", "Identifier", ",", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "S", ",", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "*", "this", ")", ")", ";", "return", "MatchOperand_Success", ";", "}", "Index", "=", "matchCheriHWRegsRegisterName", "(", "Identifier", ")", ";", "if", "(", "Index", "!=", "-", "<NUM_LIT>", ")", "{", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Index", ",", "Identifier", ",", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "S", ",", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "*", "this", ")", ")", ";", "return", "MatchOperand_Success", ";", "}" ]

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

[ "(", "match_test", "<STR_LIT>", ")", ")", ")", "(", "define_constraint", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "(", "match_test", "<STR_LIT>", ")", ")", "<BUGE>", "(", "define_constraint", "<STR_LIT>", "<STR_LIT>" ]

[ "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "class", "Enc_88c16c", ":", "OpcodeHexagon", "{", "bits", "<", "<NUM_LIT>", ">", "Rss32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rss32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rtt32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rtt32", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rxx32", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rxx32" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "BLK", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "BLK", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPECV_FXSAVE64", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(" ]

[ "}" ]

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

[ "}" ]

[ "SelectSectionForGlobal", "(", "const", "GlobalObject", "*", "GO", ",", "SectionKind", "Kind", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "Kind", ".", "isBSS", "(", ")", "&&", "IsGlobalInSmallSection", "(", "GO", ",", "TM", ",", "Kind", ")", ")", "return", "SmallBSSSection", ";", "if", "(", "Kind", ".", "isData", "(", ")", "&&", "IsGlobalInSmallSection", "(", "GO", ",", "TM", ",", "Kind", ")", ")", "return", "SmallDataSection", ";", "if", "(", "Kind", ".", "isReadOnly", "(", ")", "&&", "IsGlobalInSmallSection", "(", "GO", ",", "TM", ",", "Kind", ")", ")", "return", "SmallDataSection", ";", "return", "TargetLoweringObjectFileELF", "::", "SelectSectionForGlobal", "(", "GO", ",", "Kind", ",", "TM", ")", ";" ]

[ "let", "Defs", "=", "[", "USR_OVF", "]", ";" ]

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

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

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

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

[ "return", "(", "_", "_", "mmask16", ")", "_", "_", "builtin_ia32_cmpw256_mask", "(", "(", "_", "_", "v16hi", ")", "_", "_", "X", ",", "(", "_", "_", "v16hi", ")", "_", "_", "Y", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask16" ]

[ "void", "MOSFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "MF", ".", "getRegInfo", "(", ")", ".", "getTargetRegisterInfo", "(", ")", ";", "MachineIRBuilder", "Builder", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ")", ";", "int64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "isISR", "(", "MF", ")", ")", "StackSize", "+=", "<NUM_LIT>", ";", "if", "(", "StackSize", ")", "offsetSP", "(", "Builder", ",", "-", "StackSize", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "return", ";", "auto", "MBBI", "=", "std", "::", "find_if_not", "(", "Builder", ".", "getInsertPt", "(", ")", ",", "MBB", ".", "end", "(", ")", ",", "[", "]", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", ")", ";", "Builder", ".", "setInsertPt", "(", "MBB", ",", "MBBI", ")", ";", "Builder", ".", "buildCopy", "(", "TRI", ".", "getFrameRegister", "(", "MF", ")", ",", "Register", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "}" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "}" ]

[ "class", "N3VQInt", "<", "bit", "op24", ",", "bit", "op23", ",", "bits", "<", "<NUM_LIT>", ">", "op21_20", ",", "bits", "<", "<NUM_LIT>", ">", "op11_8", ",", "bit", "op4", ",", "Format", "f", ",", "InstrItinClass", "itin", ",", "string", "OpcodeStr", ",", "string", "Dt", ",", "ValueType", "ResTy", ",", "ValueType", "OpTy", ",", "SDPatternOperator", "IntOp", ",", "bit", "Commutable", ">", ":", "N3V", "<", "op24", ",", "op23", ",", "op21_20", ",", "op11_8", ",", "<NUM_LIT>", ",", "op4", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "QPR", ":", "$", "Vn", ",", "QPR", ":", "$", "Vm", ")", ",", "f", ",", "itin", ",", "OpcodeStr", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "QPR", ":", "$", "Vd", ",", "(", "ResTy", "(", "IntOp", "(", "OpTy", "QPR", ":", "$", "Vn", ")", ",", "(", "OpTy", "QPR", ":", "$", "Vm", ")", ")", ")", ")", "]", ">", "{", "let", "TwoOperandAliasConstraint", "=", "<STR_LIT>", ";", "let", "isCommutable", "=", "Commutable", ";" ]

[ "[", "WriteAdr", ",", "WriteST", ",", "ReadAdrBase", "]", ">", ";" ]

[ "def", "_isel", ":", "Pseudo", "<", "(", "outs", "GPR64sp", ":", "$", "wback", ")", ",", "(", "ins", "regtype", ":", "$", "Rt", ",", "am_noindex", ":", "$", "addr", ",", "simm9", ":", "$", "idx", ")", ",", "[", "]", ",", "<STR_LIT>", ">", ",", "PseudoInstExpansion", "<", "(", "Insn", "regtype", ":", "$", "Rt", ",", "am_noindex", ":", "$", "addr", ",", "simm9", ":", "$", "idx", ")", ">", ",", "Sched", "<" ]

[ "}" ]

[ "void", "resetMaxPressure", "(", ")", "{", "MaxPressure", "=", "CurPressure", ";" ]

[ ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "isRestrictNoSlot1Store", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>" ]

[ "<FIXS>", "targetm", ".", "secondary_memory_needed", "<FIXE>" ]

[ "targetm", ".", "legitimize_address", "=", "rs6000_debug_legitimize_address", ";", "rs6000_secondary_reload_class_ptr", "=", "rs6000_debug_secondary_reload_class", ";", "<BUGS>", "rs6000_secondary_memory_needed_ptr", "<BUGE>", "rs6000_debug_secondary_memory_needed", ";", "rs6000_cannot_change_mode_class_ptr", "=", "rs6000_debug_cannot_change_mode_class", ";" ]

[ "_", "P", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_loadu_epi16", "(", "void", "const", "*", "_", "_", "P", ")", "{", "return", "(", "_", "_", "m256i", ")", "(", "*", "(", "_", "_", "v16hi_u", "*", ")", "_" ]

[ "asm", ",", "pattern", ">", ",", "Sched", "<", "[", "WriteLD", "]", ">", ";" ]

[ "def", "i", ":", "BaseLoadStoreUnscale", "<", "sz", ",", "V", ",", "opc", ",", "(", "outs", "regtype", ":", "$", "Rt", ")", ",", "(", "ins", "GPR64sp", ":", "$", "Rn", ",", "simm9", ":", "$", "offset", ")", "," ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "<", "DSPQ", ":", "dspshift_mask", ">", ")" ]

[ "(", "unspec", ":", "DSPQ", "[", "(", "match_operand", ":", "DSPQ", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_SHRA_R", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "which_alternative", "=", "=", "<NUM_LIT>", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "~", "(", "unsigned", "HOST_WIDE_INT", ")", "<", "DSPQ", ":", "dspshift_mask", ">", ")" ]

[ "case", "X86", "::", "LEA32r", ":" ]

[ "switch", "(", "LEAOpcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected LEA instruction", "<STR_LIT>", ")", ";" ]

[ "emit_insn", "(", "gen_set_got_offset_rex64", "(", "tmp_reg", ",", "label", ")", ")", ";" ]

[ "static", "void", "ix86_init_large_pic_reg", "(", "unsigned", "int", "tmp_regno", ")", "{", "rtx_code_label", "*", "label", ";", "rtx", "tmp_reg", ";", "gcc_assert", "(", "Pmode", "==", "DImode", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_PRESERVE_P", "(", "label", ")", "=", "<NUM_LIT>", ";", "tmp_reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "tmp_regno", ")", ";", "gcc_assert", "(", "REGNO", "(", "pic_offset_table_rtx", ")", "!=", "tmp_regno", ")", ";", "emit_insn", "(", "gen_set_rip_rex64", "(", "pic_offset_table_rtx", ",", "label", ")", ")", ";" ]

[ "unsigned", "int", "compute_plussi_length", "(", "rtx", "*", "operands", ",", "bool", "need_flags", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "gcc_assert", "(", "mode", "==", "SImode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", "&&", "register_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "VOIDmode", ")", ")", "{", "HOST_WIDE_INT", "intval", "=", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "<NUM_LIT>", "&&", "intval", "<=", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "TARGET_H8300SX", "&&", "(", "intval", ">=", "-", "<NUM_LIT>", "&&", "intval", "<=", "-", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "switch", "(", "(", "unsigned", "int", ")", "intval", "&", "<NUM_LIT>", ")", "{", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "if", "(", "need_flags", ")", "return", "<NUM_LIT>", ";", "else", "return", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "if", "(", "need_flags", ")", "return", "<NUM_LIT>", ";", "else", "return", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "if", "(", "!", "need_flags", ")", "return", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "case", "<NUM_LIT>", ":", "if", "(", "!", "need_flags", ")", "return", "<NUM_LIT>", ";", "}", "if", "(", "(", "intval", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "CONST_INT", "&&", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", "<", "<NUM_LIT>", ")", "return", "h8300_length_from_table", "(", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ",", "&", "addl_length_table", ")", ";", "else", "return", "h8300_length_from_table", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "&", "addl_length_table", ")", ";", "}" ]

[ "Compute", "the", "length", "of", "an", "addition", "insn", "." ]

[ "::", "i32", ",", "CopyFromLo", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "MultOpc", "=", "MultOpc", "==", "ISD", "::", "UMUL_LOHI", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "MSub", "=", "CurDAG", "->", "getNode", "(", "MultOpc", ",", "dl", ",", "MVT", "::", "Glue", ",", "MultNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MultNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "SUBCNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "SUBENode", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "SDValue", "CopyFromLo", "=", "CurDAG", "->", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Mips", "::", "LO", ",", "MVT", "::", "i32", ",", "MSub", ")", ";", "SDValue", "CopyFromHi", "=", "CurDAG", "->", "getCopyFromReg", "(", "CopyFromLo", ".", "getValue", "(", "<NUM_LIT>", ")", ",", "dl", ",", "Mips", "::", "HI", ",", "MVT" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "def", "A2_not", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_57890846", ",", "TypeALU32_2op", ">", "{", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "isPseudo", "=", "<NUM_LIT>", ";", "let", "isCodeGenOnly", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "if", "(", "!", "TM", ".", "getSubtarget", "MipsSubtarget", ">", "(", ")", ".", "hasABICall", "(", ")", ")", "<FIXE>" ]

[ "BSSSection", "=", "<STR_LIT>", "\\t.section\\t.bss", "<STR_LIT>", ";", "LCOMMDirective", "=", "<STR_LIT>", "\\t.lcomm\\t", "<STR_LIT>", ";", "<BUGS>", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "<BUGE>", "JumpTableDirective", "=", "<STR_LIT>", "\\t.word\\t", "<STR_LIT>", ";", "elseJumpTableDirective", "=", "<STR_LIT>", "\\t.gpword\\t", "<STR_LIT>", ";" ]

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

[ "class", "LoadStore64RO", "<", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "bit", "V", ",", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "regtype", ",", "string", "asm", ",", "dag", "ins", ",", "dag", "outs", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "ins", ",", "outs", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pat", ">", "{", "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "base", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "bits", "<", "<NUM_LIT>", ">", "extend", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "{", "if", "(", "get_attr_mode", "(", "insn", ")", "=", "=", "MODE_OI", ")", "return", "<STR_LIT>", "elsereturn", "<STR_LIT>", "}", "<FIXE>", "<FIXS>", "(", "set", "(", "attr", "<STR_LIT>", ")", "(", "if_then_else", "(", "match_test", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", "(", "const_string", "<STR_LIT>", ")", ")", ")", "]", ")", "<FIXE>" ]

[ "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "V16QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "parallel", "[", "(", "set", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "lshiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "CC_REG", ")", ")", "]", ")", "]", ")" ]

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

[ "RegIsGPR64", "=", "GPR64RegClass", "->", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "!", "MO", ".", "isDead", "(", ")", ")", "{", "if", "(", "RegIsGPR64", ")", "return", "true", ";", "GPR32LiveDefs", ".", "push_back", "(", "MO", ".", "getReg", "(", ")", ")", ";", "continue", ";", "}", "if", "(", "RegIsGPR64", ")", "GPR64DeadDefs", ".", "push_back", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "if", "(", "GPR32LiveDefs", ".", "empty", "(", ")" ]

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

[ "(", "define_mode_attr", "max_uint", "[", "(", "HI", "<STR_LIT>", ")", "(", "QI", "<STR_LIT>" ]

[ "}" ]

[ "SdwaSel", "getDstSel", "(", ")", "const", "{", "return", "DstSel", ";" ]

[ "UNSPEC_VQMOVN_S", "UNSPEC_VQMOVN_U", "]", ")" ]

[ "(", "define_int_iterator", "VQMOVN", "[" ]

[ "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")" ]

[ "}" ]

[ "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "MO", ".", "getExpr", "(", ")", ",", "(", "MCFixupKind", ")", "PPC", "::", "fixup_ppc_nofixup", ")", ")", ";", "return", "getDirectBrEncoding", "(", "MI", ",", "OpNo", ",", "Fixups", ",", "STI", ")", ";" ]

[ "rtx", "op1", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ "(", "match_operand", ":", "VSX_L", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VSX_L", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", ")", "]", "<STR_LIT>", "{", "rtx", "target", "=", "operands", "[", "<NUM_LIT>", "]", "rtx", "op0", "=", "operands", "[", "<NUM_LIT>", "]" ]

[ "BuildMI", "(", "*", "MBB", ",", "CI", ".", "Paired", ",", "DL", ",", "CopyDesc", ")", ".", "add", "(", "*", "Dest0", ")", ".", "addReg", "(", "DestReg", ",", "<NUM_LIT>", ",", "SubRegIdx0", ")", ";" ]

[ "MachineBasicBlock", "*", "MBB", "=", "CI", ".", "I", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "CI", ".", "I", "->", "getDebugLoc", "(", ")", ";", "const", "unsigned", "Opcode", "=", "getNewOpcode", "(", "CI", ")", ";", "const", "TargetRegisterClass", "*", "SuperRC", "=", "getTargetRegisterClass", "(", "CI", ")", ";", "Register", "DestReg", "=", "MRI", "->", "createVirtualRegister", "(", "SuperRC", ")", ";", "unsigned", "MergedOffset", "=", "std", "::", "min", "(", "CI", ".", "Offset0", ",", "CI", ".", "Offset1", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "CI", ".", "Paired", ",", "DL", ",", "TII", "->", "get", "(", "Opcode", ")", ",", "DestReg", ")", ";", "const", "unsigned", "Regs", "=", "getRegs", "(", "Opcode", ",", "*", "TII", ")", ";", "if", "(", "Regs", "&", "VADDR", ")", "MIB", ".", "add", "(", "*", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "vaddr", ")", ")", ";", "unsigned", "JoinedFormat", "=", "getBufferFormatWithCompCount", "(", "CI", ".", "Format0", ",", "CI", ".", "Width0", "+", "CI", ".", "Width1", ",", "*", "STI", ")", ";", "assert", "(", "CI", ".", "I", "->", "hasOneMemOperand", "(", ")", "&&", "CI", ".", "Paired", "->", "hasOneMemOperand", "(", ")", ")", ";", "const", "MachineMemOperand", "*", "MMOa", "=", "*", "CI", ".", "I", "->", "memoperands_begin", "(", ")", ";", "const", "MachineMemOperand", "*", "MMOb", "=", "*", "CI", ".", "Paired", "->", "memoperands_begin", "(", ")", ";", "MachineInstr", "*", "New", "=", "MIB", ".", "add", "(", "*", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "srsrc", ")", ")", ".", "add", "(", "*", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "soffset", ")", ")", ".", "addImm", "(", "MergedOffset", ")", ".", "addImm", "(", "JoinedFormat", ")", ".", "addImm", "(", "CI", ".", "GLC0", ")", ".", "addImm", "(", "CI", ".", "SLC0", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addImm", "(", "CI", ".", "DLC0", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addMemOperand", "(", "combineKnownAdjacentMMOs", "(", "*", "MBB", "->", "getParent", "(", ")", ",", "MMOa", ",", "MMOb", ")", ")", ";", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "SubRegIdx", "=", "getSubRegIdxs", "(", "CI", ")", ";", "const", "unsigned", "SubRegIdx0", "=", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "SubRegIdx", ")", ";", "const", "unsigned", "SubRegIdx1", "=", "std", "::", "get", "<", "<NUM_LIT>", ">", "(", "SubRegIdx", ")", ";", "const", "MCInstrDesc", "&", "CopyDesc", "=", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ";", "const", "auto", "*", "Dest0", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "I", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";", "const", "auto", "*", "Dest1", "=", "TII", "->", "getNamedOperand", "(", "*", "CI", ".", "Paired", ",", "AMDGPU", "::", "OpName", "::", "vdata", ")", ";" ]

[ "if", "(", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";" ]

[ "static", "bool", "loongarch_in_small_data_p", "(", "const_tree", "decl", ")", "{", "int", "size", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "STRING_CST", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "false", ";", "if", "(", "VAR_P", "(", "decl", ")", "&&", "DECL_SECTION_NAME", "(", "decl", ")", "!=", "<NUM_LIT>", ")", "{", "const", "char", "*", "name", ";", "name", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "strcmp", "(", "name", ",", "<STR_LIT>", ".sdata", "<STR_LIT>", ")", "!=", "<NUM_LIT>", "&&", "strcmp", "(", "name", ",", "<STR_LIT>", ".sbss", "<STR_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";" ]

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

[ "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";", "}", "]", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "void", "XCoreFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineModuleInfo", "*", "MMI", "=", "&", "MF", ".", "getMMI", "(", ")", ";", "const", "XCoreRegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "XCoreRegisterInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "XCoreFunctionInfo", "*", "XFI", "=", "MF", ".", "getInfo", "<", "XCoreFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "bool", "Nested", "=", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "Nest", ")", ";", "if", "(", "Nested", ")", "{", "loadFromStack", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", ",", "dl", ",", "TII", ")", ";", "}", "int", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "assert", "(", "FrameSize", "%", "<NUM_LIT>", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Misaligned frame size", "<STR_LIT>", ")", ";", "FrameSize", "/", "=", "<NUM_LIT>", ";", "bool", "isU6", "=", "isImmU6", "(", "FrameSize", ")", ";", "if", "(", "!", "isU6", "&&", "!", "isImmU16", "(", "FrameSize", ")", ")", "{", "report_fatal_error", "(", "<STR_LIT>", "emitPrologue Frame size too big: ", "<STR_LIT>", "+", "Twine", "(", "FrameSize", ")", ")", ";", "}", "bool", "emitFrameMoves", "=", "RegInfo", "->", "needsFrameMoves", "(", "MF", ")", ";", "if", "(", "FrameSize", ")", "{", "bool", "saveLR", "=", "XFI", "->", "getUsesLR", "(", ")", ";", "bool", "LRSavedOnEntry", "=", "false", ";", "int", "Opcode", ";", "if", "(", "saveLR", "&&", "(", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", "==", "<NUM_LIT>", ")", ")", "{", "Opcode", "=", "(", "isU6", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "MBB", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "saveLR", "=", "false", ";", "LRSavedOnEntry", "=", "true", ";", "}", "else", "{", "Opcode", "=", "(", "isU6", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Opcode", ")", ")", ".", "addImm", "(", "FrameSize", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "std", "::", "vector", "<", "MachineMove", ">", "&", "Moves", "=", "MMI", "->", "getFrameMoves", "(", ")", ";", "MCSymbol", "*", "FrameLabel", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "FrameLabel", ")", ";", "MachineLocation", "SPDst", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "MachineLocation", "SPSrc", "(", "MachineLocation", "::", "VirtualFP", ",", "-", "FrameSize", "*", "<NUM_LIT>", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "FrameLabel", ",", "SPDst", ",", "SPSrc", ")", ")", ";", "if", "(", "LRSavedOnEntry", ")", "{", "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "<NUM_LIT>", ")", ";", "MachineLocation", "CSSrc", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "FrameLabel", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}", "}", "if", "(", "saveLR", ")", "{", "int", "LRSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getLRSpillSlot", "(", ")", ")", ";", "storeToStack", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "LRSpillOffset", "+", "FrameSize", "*", "<NUM_LIT>", ",", "dl", ",", "TII", ")", ";", "MBB", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "SaveLRLabel", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "SaveLRLabel", ")", ";", "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "LRSpillOffset", ")", ";", "MachineLocation", "CSSrc", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MMI", "->", "getFrameMoves", "(", ")", ".", "push_back", "(", "MachineMove", "(", "SaveLRLabel", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}", "}", "}", "if", "(", "FP", ")", "{", "int", "FPSpillOffset", "=", "MFI", "->", "getObjectOffset", "(", "XFI", "->", "getFPSpillSlot", "(", ")", ")", ";", "storeToStack", "(", "MBB", ",", "MBBI", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "FPSpillOffset", "+", "FrameSize", "*", "<NUM_LIT>", ",", "dl", ",", "TII", ")", ";", "MBB", ".", "addLiveIn", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "SaveR10Label", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "SaveR10Label", ")", ";", "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "FPSpillOffset", ")", ";", "MachineLocation", "CSSrc", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "MMI", "->", "getFrameMoves", "(", ")", ".", "push_back", "(", "MachineMove", "(", "SaveR10Label", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}", "unsigned", "FramePtr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "FramePtr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "emitFrameMoves", ")", "{", "MCSymbol", "*", "FrameLabel", "=", "MMI", "->", "getContext", "(", ")", ".", "CreateTempSymbol", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addSym", "(", "FrameLabel", ")", ";", "MachineLocation", "SPDst", "(", "FramePtr", ")", ";", "MachineLocation", "SPSrc", "(", "MachineLocation", "::", "VirtualFP", ")", ";", "MMI", "->", "getFrameMoves", "(", ")", ".", "push_back", "(", "MachineMove", "(", "FrameLabel", ",", "SPDst", ",", "SPSrc", ")", ")", ";", "}", "}", "if", "(", "emitFrameMoves", ")", "{", "std", "::", "vector", "<", "MachineMove", ">", "&", "Moves", "=", "MMI", "->", "getFrameMoves", "(", ")", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "MCSymbol", "*", ",", "CalleeSavedInfo", ">", ">", "&", "SpillLabels", "=", "XFI", "->", "getSpillLabels", "(", ")", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "SpillLabels", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MCSymbol", "*", "SpillLabel", "=", "SpillLabels", "[", "I", "]", ".", "first", ";", "CalleeSavedInfo", "&", "CSI", "=", "SpillLabels", "[", "I", "]", ".", "second", ";", "int", "Offset", "=", "MFI", "->", "getObjectOffset", "(", "CSI", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", ".", "getReg", "(", ")", ";", "MachineLocation", "CSDst", "(", "MachineLocation", "::", "VirtualFP", ",", "Offset", ")", ";", "MachineLocation", "CSSrc", "(", "Reg", ")", ";", "Moves", ".", "push_back", "(", "MachineMove", "(", "SpillLabel", ",", "CSDst", ",", "CSSrc", ")", ")", ";", "}", "}", "}" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "(", "clobber", "(", "reg", ":", "SI", "TILEPRO_NETORDER_REG", ")", ")" ]

[ "UNSPEC_NETWORK_RECEIVE", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "reg", ":", "SI", "TILEPRO_NETORDER_REG", ")", "]", "UNSPEC_NETWORK_SEND", ")" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "size", "{", "<NUM_LIT>", "}", ";", "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", ";" ]

[ "bool", "ARMBaseInstrInfo", "::", "hasLowDefLatency", "(", "const", "TargetSchedModel", "&", "SchedModel", ",", "const", "MachineInstr", "&", "DefMI", ",", "unsigned", "DefIdx", ")", "const", "{", "const", "InstrItineraryData", "*", "ItinData", "=", "SchedModel", ".", "getInstrItineraries", "(", ")", ";", "if", "(", "!", "ItinData", "||", "ItinData", "->", "isEmpty", "(", ")", ")", "return", "false", ";", "unsigned", "DDomain", "=", "DefMI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "DDomain", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "DefClass", "=", "DefMI", ".", "getDesc", "(", ")", ".", "getSchedClass", "(", ")", ";", "std", "::", "optional", "<", "unsigned", ">", "DefCycle", "=", "ItinData", "->", "getOperandCycle", "(", "DefClass", ",", "DefIdx", ")", ";", "return", "DefCycle", "&&", "DefCycle", "<=", "<NUM_LIT>", "U", ";", "}", "return", "false", ";", "}" ]

[ "Compute", "operand", "latency", "of", "a", "def", "of", "'Reg", "'", "." ]

[ "if", "(", "RelaxAll", ")", "S", "->", "getAssembler", "(", ")", ".", "setRelaxAll", "(", "true", ")", ";" ]

[ "MCELFStreamer", "*", "createAArch64ELFStreamer", "(", "MCContext", "&", "Context", ",", "MCAsmBackend", "&", "TAB", ",", "raw_ostream", "&", "OS", ",", "MCCodeEmitter", "*", "Emitter", ",", "bool", "RelaxAll", ",", "bool", "NoExecStack", ")", "{", "AArch64ELFStreamer", "*", "S", "=", "new", "AArch64ELFStreamer", "(", "Context", ",", "TAB", ",", "OS", ",", "Emitter", ")", ";" ]

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

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

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

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

[ "<STR_LIT>" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lo_sum", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]" ]

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

[ "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "EmitBranchToAt", "(", "(", "intptr_t", ")", "Addr", ",", "(", "intptr_t", ")", "Fn", ",", "false", ",", "is64Bit", ")", ";", "sys", "::", "Memory", "::", "InvalidateInstructionCache", "(", "Addr", ",", "<NUM_LIT>", "*", "<NUM_LIT>", ")", ";", "return", "Addr", ";", "}", "void", "*", "Addr", "=", "(", "void", "*", ")", "JCE", ".", "getCurrentPCValue", "(", ")", ";", "if", "(", "is64Bit", ")", "{", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "{", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "}", "intptr_t", "BranchAddr", "=", "(", "intptr_t", ")", "JCE", ".", "getCurrentPCValue", "(", ")", ";", "JCE", ".", "emitWordBE", "(", "<NUM_LIT>", ")", ";", "JCE", ".", "emitWordBE" ]

[ "}" ]

[ "machine_mode", "mode", ";", "int", "unsigned_p", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "valtype", ")", ";", "mode", "=", "promote_function_mode", "(", "valtype", ",", "mode", ",", "&", "unsigned_p", ",", "fn_decl_or_type", ",", "<NUM_LIT>", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "<NUM_LIT>", ")", ";" ]

[ "<FIXS>", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "<FIXE>" ]

[ "setOperationAction", "(", "ISD", "::", "UNDEF", ",", "VT", ",", "Legal", ")", ";", "setOperationAction", "(", "ISD", "::", "INSERT_VECTOR_ELT", ",", "VT", ",", "Custom", ")", ";", "<BUGS>", "setOperationAction", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "VT", ",", "Legal", ")", ";", "<BUGE>", "setOperationAction", "(", "ISD", "::", "BUILD_VECTOR", ",", "VT", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SETCC", ",", "VT", ",", "Legal", ")", ";" ]