Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "mode", ";" ]

[ "if", "(", "mode", "==", "VOIDmode", ")", "return", "choose_hard_reg_mode", "(", "regno", ",", "nregs", ",", "NULL", ")", ";", "else", "return" ]

[ "<STR_LIT>" ]

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

[ "}" ]

[ "J", ".", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "true", ",", "true", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "break", ";", "}", "if", "(", "J", ".", "modifiesRegister", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "TRI", ")", ")", "break", ";", "bool", "ClobbersNZ", "=", "true", ";", "if", "(", "J", ".", "isBranch", "(", ")", "||", "J", ".", "mayStore", "(", ")", ")", "ClobbersNZ", "=", "false", ";", "else", "switch", "(", "J", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "ClobbersNZ", "=", "false", ";", "break", ";", "}", "if", "(", "ClobbersNZ", ")", "break", ";", "}", "if", "(", "Changed", ")", "continue", ";", "Changed", "=", "true", ";", "lowerCMPTermZ", "(", "MI", ")", ";" ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_aslh", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_57890846", ",", "TypeALU32_2op", ">", ",", "Enc_5e2823", ",", "PredNewRel", "{", "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", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=" ]

[ "bool", "AArch64CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "auto", "&", "Args", "=", "F", ".", "getArgumentList", "(", ")", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "&", "DL", "=", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "SplitArgs", ";", "unsigned", "i", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "Args", ")", "{", "ArgInfo", "OrigArg", "{", "VRegs", "[", "i", "]", ",", "Arg", ".", "getType", "(", ")", "}", ";", "setArgFlags", "(", "OrigArg", ",", "i", "+", "<NUM_LIT>", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "unsigned", ">", "Regs", ",", "ArrayRef", "<", "uint64_t", ">", "Offsets", ")", "{", "MIRBuilder", ".", "buildSequence", "(", "VRegs", "[", "i", "]", ",", "Regs", ",", "Offsets", ")", ";", "}", ")", ";", "++", "i", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "AssignFn", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "{", "return", "false", ";", "}", "uint64_t", "StackOffset", "=", "alignTo", "(", "Handler", ".", "StackUsed", ",", "<NUM_LIT>", ")", ";", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "AArch64FunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "FuncInfo", "->", "setVarArgsStackIndex", "(", "MFI", ".", "CreateFixedObject", "(", "<NUM_LIT>", ",", "StackOffset", ",", "true", ")", ")", ";", "}", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "<STR_LIT>", ")" ]

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

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

[ "if", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", "!=", "-", "<NUM_LIT>", ")", "{", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addImm", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "}", "else", "{", "const", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "Cond", "[", "<NUM_LIT>", "]", ".", "getImm", "(", ")", ")", ")", ".", "add", "(", "Cond", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "Cond", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "MIB", ".", "addImm", "(", "Cond", "[" ]

[ "bool", "BPFAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "unsigned", "RegNo", "=", "MatchRegisterName", "(", "Name", ")", ";", "if", "(", "RegNo", "!=", "<NUM_LIT>", ")", "{", "SMLoc", "E", "=", "SMLoc", "::", "getFromPointer", "(", "NameLoc", ".", "getPointer", "(", ")", "-", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "RegNo", ",", "NameLoc", ",", "E", ")", ")", ";", "}", "else", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Name", ")", ")", "Operands", ".", "push_back", "(", "<STR_LIT>", "::", "<STR_LIT>", "(", "Name", ",", "NameLoc", ")", ")", ";", "else", "return", "true", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "parseOperandAsOperator", "(", "Operands", ")", "==", "MatchOperand_Success", ")", "continue", ";", "if", "(", "parseRegister", "(", "Operands", ")", "==", "MatchOperand_Success", ")", "continue", ";", "if", "(", "parseImmediate", "(", "Operands", ")", "!=", "MatchOperand_Success", ")", "return", "true", ";", "}", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLexer", "(", ")", ".", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "<STR_LIT>", "unexpected token", "<STR_LIT>", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "return", "MCRegister", "(", ")", ";" ]

[ "MCRegister", "SIRegisterInfo", "::", "findUnusedRegister", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "for", "(", "MCRegister", "Reg", ":", "*", "RC", ")", "if", "(", "MRI", ".", "isAllocatable", "(", "Reg", ")", "&&", "!", "MRI", ".", "isPhysRegUsed", "(", "Reg", ")", ")", "return", "Reg", ";" ]

[ "static", "void", "c6x_initialize_trampoline", "(", "rtx", "tramp", ",", "tree", "fndecl", ",", "rtx", "cxt", ")", "{", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "<NUM_LIT>", ")", ";", "rtx", "t1", "=", "copy_to_reg", "(", "fnaddr", ")", ";", "rtx", "t2", "=", "copy_to_reg", "(", "cxt", ")", ";", "rtx", "mask", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "int", "i", ";", "emit_block_move", "(", "tramp", ",", "assemble_trampoline_template", "(", ")", ",", "GEN_INT", "(", "TRAMPOLINE_SIZE", ")", ",", "BLOCK_OP_NORMAL", ")", ";", "emit_move_insn", "(", "mask", ",", "GEN_INT", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "{", "rtx", "mem", "=", "adjust_address", "(", "tramp", ",", "SImode", ",", "i", "*", "<NUM_LIT>", ")", ";", "rtx", "t", "=", "(", "i", "&", "<NUM_LIT>", ")", "?", "t2", ":", "t1", ";", "rtx", "v1", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "v2", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "emit_move_insn", "(", "v1", ",", "mem", ")", ";", "if", "(", "i", "<", "<NUM_LIT>", ")", "emit_insn", "(", "gen_ashlsi3", "(", "v2", ",", "t", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "else", "emit_insn", "(", "gen_lshrsi3", "(", "v2", ",", "t", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ")", ";", "emit_insn", "(", "gen_andsi3", "(", "v2", ",", "v2", ",", "mask", ")", ")", ";", "emit_insn", "(", "gen_iorsi3", "(", "v2", ",", "v2", ",", "v1", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "v2", ")", ";", "}", "tramp", "=", "XEXP", "(", "tramp", ",", "<NUM_LIT>", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "<STR_LIT>", "__gnu_clear_cache", "<STR_LIT>", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "<NUM_LIT>", ",", "tramp", ",", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "tramp", ",", "TRAMPOLINE_SIZE", ")", ",", "Pmode", ")", ";", "}" ]

[ "Emit", "RTL", "insns", "to", "initialize", "the", "variable", "parts", "of", "a", "trampoline", "at", "TRAMP", ".", "FNADDR", "is", "an", "RTX", "for", "the", "address", "of", "the", "function", "'s", "pure", "code", ".", "CXT", "is", "an", "RTX", "for", "the", "static", "chain", "value", "for", "the", "function", "." ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "snprintf", "(", "custom_builtin_name", "[", "builtin_code", "]", ",", "<NUM_LIT>", ",", "<STR_LIT>", "%sn%s%s", "<STR_LIT>", ",", "op", "[", "lhs", "]", ".", "c", ",", "op", "[", "rhs1", "]", ".", "c", ",", "op", "[", "rhs2", "]", ".", "c", ")", ";", "strncpy", "(", "builtin_name", "+", "n", ",", "custom_builtin_name", "[", "builtin_code", "]", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "=", "build_function_type_list", "(", "ret_type", ",", "integer_type_node", ",", "op", "[", "rhs1", "]", ".", "type", ",", "op", "[", "rhs2", "]", ".", "type", ",", "NULL_TREE", ")", ";", "<BUGS>", "snprintf", "(", "builtin_name", "+", "n", ",", "<NUM_LIT>", "-", "n", ",", "<STR_LIT>", "%sn%s%s", "<STR_LIT>", ",", "op", "[", "lhs", "]", ".", "c", ",", "op", "[", "rhs1", "]", ".", "c", ",", "op", "[", "rhs2", "]", ".", "c", ")", ";", "<BUGE>", "<BUGS>", "strncpy", "(", "custom_builtin_name", "[", "builtin_code", "]", ",", "builtin_name", "+", "n", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "fndecl", "=", "add_builtin_function", "(", "builtin_name", ",", "builtin_ftype", ",", "start_code", "+", "builtin_code", "," ]

[ "}" ]

[ "bool", "is64Bit", "(", ")", "const", "{", "return", "false", ";" ]

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

[ "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "addPass", "(", "createSIModeRegisterPass", "(", ")", ")", ";", "addPass", "(", "&", "PostRAHazardRecognizerID", ")", ";", "addPass", "(", "&", "SIInsertSkipsPassID", ")", ";", "addPass", "(", "&" ]

[ "}" ]

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

[ "}" ]

[ "assert", "(", "GPRCount", "&&", "<STR_LIT>", "GPRCount cannot be 0", "<STR_LIT>", ")", ";", "return", "<NUM_LIT>", "/", "GPRCount", ";" ]

[ ")", ";" ]

[ "case", "E_VOIDmode", ":", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "case", "E_DImode", ":", "case", "E_TImode", ":", "regbase", "=", "GP_ARG_FIRST", ";", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "arg", ".", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "case", "E_BLKmode", ":", "regbase", "=", "GP_ARG_FIRST", ";", "break", ";", "}", "if", "(", "*", "arg_words", ">=", "MAX_ARGS_IN_REGISTERS", ")", "ret", "=", "<NUM_LIT>", ";", "else", "{", "gcc_assert", "(", "regbase", "!=", "-", "<NUM_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_min_round_sd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m128d", ")", "_", "_", "builtin_ia32_minsd_mask_round", "(", "(", "_", "_", "v2df", ")", "_", "_", "A", ",", "(", "_", "_", "v2df", ")", "_", "_", "B", ",", "(", "_", "_", "v2df", ")", "_", "mm_setzero_pd", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ ")", ";" ]

[ "return", "new", "AArch64ConditionalCompares", "(" ]

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

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

[ "switch_to_section", "(", "data_section", ")", ";" ]

[ "if", "(", "rs6000_passes_vector", ")", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.gnu_attribute 8, %d\\n", "<STR_LIT>", ",", "(", "TARGET_ALTIVEC_ABI", "?", "<NUM_LIT>", ":", "TARGET_SPE_ABI", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ")", ";", "if", "(", "rs6000_returns_struct", ")", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\t.gnu_attribute 12, %d\\n", "<STR_LIT>", ",", "aix_struct_return", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "}", "if", "(", "TARGET_32BIT", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "file_end_indicate_exec_stack", "(", ")", ";", "if", "(", "flag_split_stack", ")", "file_end_indicate_split_stack", "(", ")", ";", "if", "(", "cpu_builtin_p", ")", "{" ]

[ "auto", "Scale0Unmerge", "=", "B", ".", "buildUnmerge", "(", "S32", ",", "DivScale0", ")", ";" ]

[ "LLT", "S1", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "auto", "One", "=", "B", ".", "buildFConstant", "(", "S64", ",", "<NUM_LIT>", ")", ";", "auto", "DivScale0", "=", "B", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_div_scale", ",", "{", "S64", ",", "S1", "}", ",", "false", ")", ".", "addUse", "(", "LHS", ")", ".", "addUse", "(", "RHS", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlags", "(", "Flags", ")", ";", "auto", "NegDivScale0", "=", "B", ".", "buildFNeg", "(", "S64", ",", "DivScale0", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "Flags", ")", ";", "auto", "Rcp", "=", "B", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_rcp", ",", "{", "S64", "}", ",", "false", ")", ".", "addUse", "(", "DivScale0", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ".", "setMIFlags", "(", "Flags", ")", ";", "auto", "Fma0", "=", "B", ".", "buildFMA", "(", "S64", ",", "NegDivScale0", ",", "Rcp", ",", "One", ",", "Flags", ")", ";", "auto", "Fma1", "=", "B", ".", "buildFMA", "(", "S64", ",", "Rcp", ",", "Fma0", ",", "Rcp", ",", "Flags", ")", ";", "auto", "Fma2", "=", "B", ".", "buildFMA", "(", "S64", ",", "NegDivScale0", ",", "Fma1", ",", "One", ",", "Flags", ")", ";", "auto", "DivScale1", "=", "B", ".", "buildIntrinsic", "(", "Intrinsic", "::", "amdgcn_div_scale", ",", "{", "S64", ",", "S1", "}", ",", "false", ")", ".", "addUse", "(", "LHS", ")", ".", "addUse", "(", "RHS", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "setMIFlags", "(", "Flags", ")", ";", "auto", "Fma3", "=", "B", ".", "buildFMA", "(", "S64", ",", "Fma1", ",", "Fma2", ",", "Fma1", ",", "Flags", ")", ";", "auto", "Mul", "=", "B", ".", "buildMul", "(", "S64", ",", "DivScale1", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "Fma3", ",", "Flags", ")", ";", "auto", "Fma4", "=", "B", ".", "buildFMA", "(", "S64", ",", "NegDivScale0", ",", "Mul", ",", "DivScale1", ".", "getReg", "(", "<NUM_LIT>", ")", ",", "Flags", ")", ";", "Register", "Scale", ";", "if", "(", "!", "ST", ".", "hasUsableDivScaleConditionOutput", "(", ")", ")", "{", "LLT", "S32", "=", "LLT", "::", "scalar", "(", "<NUM_LIT>", ")", ";", "auto", "NumUnmerge", "=", "B", ".", "buildUnmerge", "(", "S32", ",", "LHS", ")", ";", "auto", "DenUnmerge", "=", "B", ".", "buildUnmerge", "(", "S32", ",", "RHS", ")", ";" ]

[ "<FIXS>", "(", "ashift", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<FIXE>" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ior", ":", "DI", "(", "lshiftrt", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGS>", "(", "ashift", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "]", "<BUGE>", "<STR_LIT>", "{", "static", "char", "templ", "[", "<NUM_LIT>", "]" ]

[ "a", ";" ]

[ "return", "(", "uint16x8_t", ")", "_", "_" ]

[ "}" ]

[ "class", "T_XTYPE_mpy64_acc", "<", "string", "op1", ",", "string", "op2", ",", "bits", "<", "<NUM_LIT>", ">", "MajOp", ",", "bits", "<", "<NUM_LIT>", ">", "MinOp", ",", "bit", "isSat", ",", "bit", "hasShift", ",", "bit", "isConj", ">", ":", "MInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rxx", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "dst2", ",", "IntRegs", ":", "$", "Rs", ",", "IntRegs", ":", "$", "Rt", ")", ",", "<STR_LIT>", "#", "op2", "#", "<STR_LIT>", "#", "op1", "#", "<STR_LIT>", "#", "!", "if", "(", "isConj", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "!", "if", "(", "hasShift", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "!", "if", "(", "isSat", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", ",", "[", "]", ",", "<STR_LIT>", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rxx", ";", "bits", "<", "<NUM_LIT>", ">", "Rs", ";", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "let", "IClass", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MajOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "MinOp", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rxx", ";" ]

[ "return", "result", ";" ]

[ "if", "(", "!", "TARGET_GCC_ABI", ")", "align", "=", "UNITS_PER_WORD", ";", "else", "if", "(", "size", "<=", "UNITS_PER_WORD", "&&", "type", ")", "align", "=", "TYPE_ALIGN", "(", "type", ")", "/", "BITS_PER_UNIT", ";", "else", "align", "=", "size", ";", "cum", "->", "nbytes", "=", "(", "cum", "->", "nbytes", "+", "align", "-", "<NUM_LIT>", ")", "&", "~", "(", "align", "-", "<NUM_LIT>", ")", ";", "if", "(", "cum", "->", "nbytes", ">", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", "return", "NULL_RTX", ";", "if", "(", "type", "==", "NULL_TREE", "&&", "cum", "->", "nbytes", "+", "size", ">", "<NUM_LIT>", "*", "UNITS_PER_WORD", ")", "return", "NULL_RTX", ";", "switch", "(", "cum", "->", "nbytes", "/", "UNITS_PER_WORD", ")", "{", "case", "<NUM_LIT>", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "result", "=", "gen_rtx_REG", "(", "mode", ",", "<NUM_LIT>", ")", ";", "break", ";", "default", ":", "result", "=", "NULL_RTX", ";", "}" ]

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

[ "if", "(", "strcmp", "(", "name", ",", "<STR_LIT>", ".sdata", "<STR_LIT>", ")", "!=", "<NUM_LIT>", "&&", "strcmp", "(", "name", ",", "<STR_LIT>", ".sbss", "<STR_LIT>", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "mips_lo_relocs", "[", "SYMBOL_GP_RELATIVE", "]", "||", "!", "DECL_EXTERNAL", "(", "decl", ")", ")", "return", "true", ";", "}", "else", "if", "(", "TARGET_EMBEDDED_DATA", ")", "{", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TREE_SIDE_EFFECTS", "(", "decl", ")", "&&", "(", "!", "DECL_INITIAL", "(", "decl", ")", "||", "TREE_CONSTANT", "(", "DECL_INITIAL", "(", "decl", ")", ")" ]

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

[ "llvm_unreachable", "(", "<STR_LIT>", "TLS not implemented for MicroBlaze.", "<STR_LIT>", ")", ";", "return", "SDValue" ]

[ "GO", ",", "TM", ",", "Kind", ")", ")", "return", "SmallDataSection", ";" ]

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

[ "}" ]

[ "def", "VMOVv4i32", ":", "N1ModImm", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "{", "?", ",", "?", ",", "?", ",", "?", "}", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "QPR", ":", "$", "Vd", ")", ",", "(", "ins", "nImmVMOVI32", ":", "$", "SIMM", ")", ",", "IIC_VMOVImm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "(", "set", "QPR", ":", "$", "Vd", ",", "(", "v4i32", "(", "NEONvmovImm", "timm", ":", "$", "SIMM", ")", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "SIMM", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "const", "char", "*", "ARCompactTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ARCISD::CALL", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ARCISD::CMP", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ARCISD::BR_CC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ARCISD::SELECT_CC", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ARCISD::Wrapper", "<STR_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<STR_LIT>", "ARCISD::RET_FLAG", "<STR_LIT>", ";", "default", ":", "return", "<NUM_LIT>", ";", "}", "}" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "initializeSIInsertWaitcntsPass", "(", "*", "PR", ")", ";" ]

[ "PassRegistry", "*", "PR", "=", "PassRegistry", "::", "getPassRegistry", "(", ")", ";", "initializeR600ClauseMergePassPass", "(", "*", "PR", ")", ";", "initializeR600ControlFlowFinalizerPass", "(", "*", "PR", ")", ";", "initializeR600PacketizerPass", "(", "*", "PR", ")", ";", "initializeR600ExpandSpecialInstrsPassPass", "(", "*", "PR", ")", ";", "initializeR600VectorRegMergerPass", "(", "*", "PR", ")", ";", "initializeGlobalISel", "(", "*", "PR", ")", ";", "initializeAMDGPUDAGToDAGISelPass", "(", "*", "PR", ")", ";", "initializeGCNDPPCombinePass", "(", "*", "PR", ")", ";", "initializeSILowerI1CopiesPass", "(", "*", "PR", ")", ";", "initializeSIFixSGPRCopiesPass", "(", "*", "PR", ")", ";", "initializeSIFixVGPRCopiesPass", "(", "*", "PR", ")", ";", "initializeSIFixupVectorISelPass", "(", "*", "PR", ")", ";", "initializeSIFoldOperandsPass", "(", "*", "PR", ")", ";", "initializeSIPeepholeSDWAPass", "(", "*", "PR", ")", ";", "initializeSIShrinkInstructionsPass", "(", "*", "PR", ")", ";", "initializeSIOptimizeExecMaskingPreRAPass", "(", "*", "PR", ")", ";", "initializeSILoadStoreOptimizerPass", "(", "*", "PR", ")", ";", "initializeAMDGPUFixFunctionBitcastsPass", "(", "*", "PR", ")", ";", "initializeAMDGPUAlwaysInlinePass", "(", "*", "PR", ")", ";", "initializeAMDGPUAnnotateKernelFeaturesPass", "(", "*", "PR", ")", ";", "initializeAMDGPUAnnotateUniformValuesPass", "(", "*", "PR", ")", ";", "initializeAMDGPUArgumentUsageInfoPass", "(", "*", "PR", ")", ";", "initializeAMDGPUAtomicOptimizerPass", "(", "*", "PR", ")", ";", "initializeAMDGPULowerKernelArgumentsPass", "(", "*", "PR", ")", ";", "initializeAMDGPULowerKernelAttributesPass", "(", "*", "PR", ")", ";", "initializeAMDGPULowerIntrinsicsPass", "(", "*", "PR", ")", ";", "initializeAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", "*", "PR", ")", ";", "initializeAMDGPUPromoteAllocaPass", "(", "*", "PR", ")", ";", "initializeAMDGPUCodeGenPreparePass", "(", "*", "PR", ")", ";", "initializeAMDGPUPropagateAttributesEarlyPass", "(", "*", "PR", ")", ";", "initializeAMDGPUPropagateAttributesLatePass", "(", "*", "PR", ")", ";", "initializeAMDGPURewriteOutArgumentsPass", "(", "*", "PR", ")", ";", "initializeAMDGPUUnifyMetadataPass", "(", "*", "PR", ")", ";", "initializeSIAnnotateControlFlowPass", "(", "*", "PR", ")", ";" ]

[ "<FIXS>", "+", "(", "(", "(", "(", "HOST_WIDE_INT", ")", "l", "[", "<NUM_LIT>", "]", ")", "<<", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ",", "<FIXE>" ]

[ "parts", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "trunc_int_for_mode", "(", "(", "l", "[", "<NUM_LIT>", "]", "&", "(", "(", "(", "HOST_WIDE_INT", ")", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ")", ")", "<BUGS>", "+", "(", "(", "(", "(", "HOST_WIDE_INT", ")", "l", "[", "<NUM_LIT>", "]", ")", "<<", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ",", "<BUGE>", "DImode", ")", ")", ";", "elseparts", "[", "<NUM_LIT>", "]", "=", "immed_double_const", "(", "l", "[", "<NUM_LIT>", "]", ",", "l", "[", "<NUM_LIT>", "]", ",", "DImode", ")", ";" ]

[ ",", "_", "MM_MANTISSA_NORM_ENUM", "_", "_", "C", ",", "_", "MM_MANTISSA_SIGN_ENUM", "_", "_", "D", ",", "const", "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_getmant_round_sd", "(", "_", "_", "m128d", "_", "_", "A", ",", "_", "_", "m128d", "_", "_", "B" ]

[ ".", "second", ".", "size", "(", ")", ")", ";" ]

[ "if", "(", "Match", "->", "isFull", "(", ")", ")", "{", "ReadyList", ".", "push_back", "(", "std", "::", "pair", "(", "*", "I", ",", "MissPenalty", ")", ")", ";", "continue", ";", "}", "int", "TempCost", "=", "addEdges", "(", "SyncPipeline", ",", "CurrSU", ".", "first", ",", "CandSGID", ",", "AddedEdges", ")", ";", "ReadyList", ".", "push_back", "(", "std", "::", "pair", "(", "*", "I", ",", "TempCost", ")", ")", ";", "removeEdges", "(", "AddedEdges", ")", ";", "}", "else", "ReadyList", ".", "push_back", "(", "std", "::", "pair", "(", "*", "I", ",", "-", "<NUM_LIT>", ")", ")", ";", "}", "if", "(", "UseCostHeur", ")", "{", "std", "::", "sort", "(", "ReadyList", ".", "begin", "(", ")", ",", "ReadyList", ".", "end", "(", ")", ",", "[", "]", "(", "std", "::", "pair", "<", "int", ",", "int", ">", "A", ",", "std", "::", "pair", "<", "int", ",", "int", ">", "B", ")", "{", "return", "A", ".", "second", "<", "B", ".", "second", ";", "}", ")", ";", "}", "assert", "(", "ReadyList", ".", "size", "(", ")", "==", "CurrSU" ]

[ "}" ]

[ "imm_info", "imm_values", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "find_constant", "(", "insn", ",", "&", "imm_values", ")", ";", "*", "imm", "=", "imm_values", ".", "imm", ";", "*", "imm32", "=", "imm_values", ".", "imm32", ";", "*", "imm64", "=", "imm_values", ".", "imm64", ";", "return", "imm_values", ".", "imm32", "*", "<NUM_LIT>", "+", "imm_values", ".", "imm64", "*", "<NUM_LIT>", ";" ]

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

[ "def", "J4_cmpeqi_tp1_jump_nt", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "u5_0Imm", ":", "$", "II", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_14d27a", ",", "PredRel", "{", "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>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";" ]

[ ")", ")" ]

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

[ "(", "<STR_LIT>", "#", "width", ")", ";" ]

[ "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">" ]

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

[ "let", "SuperClasses", "=", "[", "ShifterOperand", "]", ";", "let", "Name", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "if", "(", "(", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "||", "(", "Flags", "&", "X86", "::", "IP_HAS_NOTRACK", ")", ")", "OS", "<<", "<STR_LIT>", "\\tnotrack\\t", "<STR_LIT>", ";", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT_NE", ")", "OS", "<<", "<STR_LIT>", "\\trepne\\t", "<STR_LIT>", ";", "else", "if", "(", "Flags", "&", "X86", "::", "IP_HAS_REPEAT", ")", "OS", "<<", "<STR_LIT>", "\\trep\\t", "<STR_LIT>", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "CALLpcrel32", "&&", "(", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode64Bit", "]", ")", ")", "{", "OS", "<<", "<STR_LIT>", "\\tcallq\\t", "<STR_LIT>", ";", "printPCRelImm", "(", "MI", ",", "<NUM_LIT>", ",", "OS", ")", ";", "}", "else", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "X86", "::", "DATA16_PREFIX", "&&", "STI", ".", "getFeatureBits", "(", ")", "[", "X86", "::", "Mode16Bit", "]", ")", "{", "OS", "<<", "<STR_LIT>", "\\tdata32", "<STR_LIT>", ";", "}", "else", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "OS", ")", ")", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";" ]

[ "}", "_", "_", "rv", ";" ]

[ "union", "{", "bfloat16x8x2_t", "_", "_", "i", ";", "_", "_", "builtin_neon_oi", "_", "_", "o", ";" ]

[ "(", "FP32Denormals", ")", "|", "FP_DENORM_MODE_DP", "(", "FP64Denormals", ")", ";" ]

[ "static", "uint32_t", "getFPMode", "(", "const", "MachineFunction", "&", "F", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "F", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "uint32_t", "FP32Denormals", "=", "ST", ".", "hasFP32Denormals", "(", ")", "?", "FP_DENORM_FLUSH_NONE", ":", "FP_DENORM_FLUSH_IN_FLUSH_OUT", ";", "uint32_t", "FP64Denormals", "=", "ST", ".", "hasFP64Denormals", "(", ")", "?", "FP_DENORM_FLUSH_NONE", ":", "FP_DENORM_FLUSH_IN_FLUSH_OUT", ";", "return", "FP_ROUND_MODE_SP", "(", "FP_ROUND_ROUND_TO_NEAREST", ")", "|", "FP_ROUND_MODE_DP", "(", "FP_ROUND_ROUND_TO_NEAREST", ")", "|", "FP_DENORM_MODE_SP" ]

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

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

[ "}" ]

[ "class", "FixedCmpBranchRIEa", "<", "CondVariant", "V", ",", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "cls", ",", "ImmOpWithPattern", "imm", ">", ":", "InstRIEa", "<", "opcode", ",", "(", "outs", ")", ",", "(", "ins", "cls", ":", "$", "R1", ",", "imm", ":", "$", "I2", ")", ",", "mnemonic", "#", "V", ".", "suffix", "#", "<STR_LIT>", ",", "[", "]", ">", "{", "let", "isAsmParserOnly", "=", "V", ".", "alternate", ";", "let", "AsmVariantName", "=", "V", ".", "asmvariant", ";", "let", "M3", "=", "V", ".", "ccmask", ";" ]

[ "}" ]

[ "def", "simdimmtype10", ":", "Operand", "<", "i32", ">", ",", "FPImmLeaf", "<", "f64", ",", "[", "{", "return", "AArch64_AM", ":", ":", "isAdvSIMDModImmType10", "(", "Imm", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ";", "}", "]", ",", "SDNodeXForm", "<", "fpimm", ",", "[", "{", "APFloat", "InVal", "=", "N", "-", ">", "getValueAPF", "(", ")", ";", "uint32_t", "enc", "=", "AArch64_AM", ":", ":", "encodeAdvSIMDModImmType10", "(", "N", "-", ">", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ")", ";", "return", "CurDAG", "-", ">", "getTargetConstant", "(", "enc", ",", "SDLoc", "(", "N", ")", ",", "MVT", ":", ":", "i32", ")", ";", "}", "]", ">", ">", "{", "let", "ParserMatchClass", "=", "SIMDImmType10Operand", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "addPass", "(", "createM680x0ISelDag", "(", "getM680x0TargetMachine", "(", ")", ")", ")", ";", "addPass", "(", "createM680x0GlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";" ]

[ "<", "[", "In32BitMode", "]", ">", ";" ]

[ "def", "EH_SjLj_LongJmp32", ":", "PPCCustomInserterPseudo", "<", "(", "outs", ")", ",", "(", "ins", "memr", ":", "$", "buf", ")", ",", "<STR_LIT>", ",", "[", "(", "PPCeh_sjlj_longjmp", "addr", ":", "$", "buf", ")", "]", ">", ",", "Requires" ]

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

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

[ "<STR_LIT>", ";" ]

[ "def", "atimm", ":", "Operand", "<", "i32", ">", "{", "let", "PrintMethod", "=" ]

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

[ "def", "L2_loadri_pcr", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ",", "IntRegs", ":", "$", "Rx32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rx32in", ",", "ModRegs", ":", "$", "Mu2", ")", ",", "<STR_LIT>", ",", "tc_44d3da28", ",", "TypeLD", ">", ",", "Enc_74d4e5", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue" ]

[ "}" ]

[ "rtx", "pat", ";", "cfun", "->", "machine", "->", "split_stack_arg_pointer", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "REG_POINTER", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ")", "=", "<NUM_LIT>", ";", "pat", "=", "gen_rtx_SET", "(", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "gen_rtx_REG", "(", "Pmode", ",", "<NUM_LIT>", ")", ")", ";", "push_topmost_sequence", "(", ")", ";", "emit_insn_after", "(", "pat", ",", "get_insns", "(", ")", ")", ";", "pop_topmost_sequence", "(", ")", ";", "}", "return", "plus_constant", "(", "Pmode", ",", "cfun", "->", "machine", "->", "split_stack_arg_pointer", ",", "FIRST_PARM_OFFSET", "(", "current_function_decl", ")", ")", ";", "}", "return", "virtual_incoming_args_rtx", ";" ]

[ "<FIXS>", "(", "eq", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "nil", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_delay", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "(", "nil", ")", "]", ")", "<FIXE>" ]

[ "(", "define_delay", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "eq", "(", "symbol_ref", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "<BUGE>", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "nil", ")", "<BUGS>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", ")", "<BUGE>", "(", "define_delay", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "[", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "setForcedEncodingSize", "(", "<NUM_LIT>", ")", ";", "if", "(", "Name", ".", "endswith", "(", "<STR_LIT>", "_e64", "<STR_LIT>", ")", ")", "setForcedEncodingSize", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "Name", ".", "endswith", "(", "<STR_LIT>", "_e32", "<STR_LIT>", ")", ")", "setForcedEncodingSize", "(", "<NUM_LIT>", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "while", "(", "!", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "Parser", ".", "Lex", "(", ")", ";", "switch", "(", "Res", ")", "{", "case", "MatchOperand_Success", ":", "break", ";", "case", "MatchOperand_ParseFail", ":", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "failed parsing operand.", "<STR_LIT>", ")", ";", "case", "MatchOperand_NoMatch", ":", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "not a valid operand.", "<STR_LIT>", ")", ";", "}", "}", "AMDGPUAsmParser", "::", "OperandMatchResultTy", "Res", ";", "while", "(", "(", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ")", ")", "!=", "MatchOperand_NoMatch", ")", "{", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "return", "Error", "(", "getLexer", "(", ")", ".", "getLoc", "(", ")", ",", "<STR_LIT>", "failed parsing operand.", "<STR_LIT>", ")", ";", "}", "return", "false", ";", "}" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

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

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

[ ")", ";" ]

[ "DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "JIT: ", "<STR_LIT>", "<<", "(", "void", "*", ")", "MCE", ".", "getCurrentPCValue", "(", ")", "<<", "<STR_LIT>", ":\\t", "<STR_LIT>", "<<", "*", "MI", ")", ";", "if", "(", "(", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "&&", "!", "expandPseudos", "(", "MI", ",", "MBB", ")", ")", "return", ";", "MCE", ".", "processDebugLoc", "(", "MI", "->", "getDebugLoc", "(", ")", ",", "true", ")", ";", "emitWord", "(", "getBinaryCodeForInstr", "(", "*", "MI", ")" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Ii", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "Rs16", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rs16", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "bits", "<", "<NUM_LIT>", ">", "n1", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "n1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "n1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "tree", "fndecl", "=", "TREE_OPERAND", "(", "CALL_EXPR_FN", "(", "exp", ")", ",", "<NUM_LIT>", ")", ";", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "arg0", "=", "CALL_EXPR_ARG", "(", "exp", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "int", "ignore", "ATTRIBUTE_UNUSED", ")", "{", "<BUGS>", "tree", "fndecl", "=", "TREE_OPERAND", "(", "TREE_OPERAND", "(", "exp", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "unsigned", "int", "fcode", "=", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "<BUGS>", "tree", "arglist", "=", "TREE_OPERAND", "(", "exp", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "tree", "arg0", ",", "arg1", ";", "rtx", "r0", ",", "r1", ";", "switch", "(", "fcode", ")", "{", "case", "C4X_BUILTIN_FIX", ":", "<BUGS>", "arg0", "=", "TREE_VALUE", "(", "arglist", ")", ";", "<BUGE>", "r0", "=", "expand_expr", "(", "arg0", ",", "NULL_RTX", ",", "QFmode", ",", "<NUM_LIT>", ")", ";", "if", "(", "!", "target", "||", "!", "register_operand", "(", "target", ",", "QImode", ")", ")", "target", "=", "gen_reg_rtx", "(", "QImode", ")", ";" ]

[ "}" ]

[ "assert", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", "||", "<STR_LIT>", "::", "<STR_LIT>", "==", "N", "->", "getOpcode", "(", ")", ")", "&&", "<STR_LIT>", "Unexpected horizontal add/sub opcode", "<STR_LIT>", ")", ";", "if", "(", "SDValue", "V", "=", "combineHorizOpWithShuffle", "(", "N", ",", "DAG", ",", "Subtarget", ")", ")", "return", "V", ";", "return", "SDValue", "(", ")", ";" ]

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

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

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

[ "extern", "_", "_", "inline", "_", "_", "m64", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_cvtt_ps2pi", "(", "_", "_", "m128", "_", "_", "A", ")", "{", "return", "_", "mm_cvttps_pi32", "(", "_", "_" ]

[ ",", "_", "_", "M", ")", ";" ]

[ "_", "_", "builtin_ia32_pmovusdw128mem_mask", "(", "(", "_", "_", "v8hi", "*", ")", "_", "_", "P", ",", "(", "_", "_", "v4si", ")", "_", "_", "A" ]

[ ")", "{" ]

[ "vreinterpretq_f16_s32", "(", "int32x4_t", "_", "_", "a" ]

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

[ "def", "CRC32CHrr", ":", "BaseCRC32", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "GPR32" ]

[ "}" ]

[ "_", "_", "m512d", "_", "_", "Y", "=", "_", "_", "Y", ";", "return", "_", "_", "Y", ";" ]

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

[ "(", "define_mode_iterator", "VI1_AVX512", "[", "(", "V64QI", "<STR_LIT>", ")", "(", "V32QI", "<STR_LIT>", ")" ]

[ "<FIXS>", "let", "Defs", "=", "[", "FPSW", "]", ",", "Uses", "=", "[", "ST0", "]", "in", "{", "<FIXE>" ]

[ "[", "(", "set", "EFLAGS", ",", "(", "X86cmp", "RFP80", ":", "$", "lhs", ",", "RFP80", ":", "$", "rhs", ")", ")", "]", ">", ";", "}", "<BUGS>", "let", "Defs", "=", "[", "EFLAGS", "]", ",", "Uses", "=", "[", "ST0", "]", "in", "{", "<BUGE>", "def", "UCOM_Fr", ":", "FPI", "<NUM_LIT>", ",", "AddRegFrm", ",", "(", "outs", ")", ",", "(", "ins", "RST", ":", "$", "reg", ")", ",", "<STR_LIT>", ">", ",", "DD", ";" ]

[ "if", "(", "Result", ".", "getNode", "(", ")", ")", "return", "Result", ";" ]

[ "if", "(", "N1", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SELECT", "&&", "N1", ".", "getNode", "(", ")", "->", "hasOneUse", "(", ")", ")", "{", "SDValue", "Result", "=", "combineSelectAndUse", "(", "N", ",", "N1", ",", "N0", ",", "DCI", ")", ";" ]

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

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

[ "RegisterBankInfo", "::", "InstructionMapping", "AArch64RegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opc", ")", ")", "{", "RegisterBankInfo", "::", "InstructionMapping", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "case", "TargetOpcode", "::", "G_GEP", ":", "case", "TargetOpcode", "::", "G_MUL", ":", "case", "TargetOpcode", "::", "G_SDIV", ":", "case", "TargetOpcode", "::", "G_UDIV", ":", "case", "TargetOpcode", "::", "G_AND", ":", "case", "TargetOpcode", "::", "G_OR", ":", "case", "TargetOpcode", "::", "G_XOR", ":", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "case", "TargetOpcode", "::", "G_FADD", ":", "case", "TargetOpcode", "::", "G_FSUB", ":", "case", "TargetOpcode", "::", "G_FMUL", ":", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "getSameKindOfOperandsMapping", "(", "MI", ")", ";", "case", "TargetOpcode", "::", "G_BITCAST", ":", "{", "LLT", "DstTy", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "LLT", "SrcTy", "=", "MRI", ".", "getType", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ";", "unsigned", "Size", "=", "DstTy", ".", "getSizeInBits", "(", ")", ";", "bool", "DstIsGPR", "=", "!", "DstTy", ".", "isVector", "(", ")", ";", "bool", "SrcIsGPR", "=", "!", "SrcTy", ".", "isVector", "(", ")", ";", "const", "RegisterBank", "&", "DstRB", "=", "DstIsGPR", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "const", "RegisterBank", "&", "SrcRB", "=", "SrcIsGPR", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ";", "return", "InstructionMapping", "{", "DefaultMappingID", ",", "copyCost", "(", "DstRB", ",", "SrcRB", ",", "Size", ")", ",", "getCopyMapping", "(", "DstRB", ".", "getID", "(", ")", ",", "SrcRB", ".", "getID", "(", ")", ",", "Size", ")", ",", "<NUM_LIT>", "}", ";", "}", "case", "TargetOpcode", "::", "G_SEQUENCE", ":", "return", "InstructionMapping", "(", ")", ";", "default", ":", "break", ";", "}", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "OpSize", "(", "NumOperands", ")", ";", "SmallVector", "<", "PartialMappingIdx", ",", "<NUM_LIT>", ">", "OpRegBankIdx", "(", "NumOperands", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "NumOperands", ";", "++", "Idx", ")", "{", "auto", "&", "MO", "=", "MI", ".", "getOperand", "(", "Idx", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "continue", ";", "LLT", "Ty", "=", "MRI", ".", "getType", "(", "MO", ".", "getReg", "(", ")", ")", ";", "OpSize", "[", "Idx", "]", "=", "Ty", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Ty", ".", "isVector", "(", ")", "||", "isPreISelGenericFloatingPointOpcode", "(", "Opc", ")", ")", "OpRegBankIdx", "[", "Idx", "]", "=", "PMI_FirstFPR", ";", "else", "OpRegBankIdx", "[", "Idx", "]", "=", "PMI_FirstGPR", ";", "}", "unsigned", "Cost", "=", "<NUM_LIT>", ";", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_SITOFP", ":", "case", "TargetOpcode", "::", "G_UITOFP", ":", "{", "OpRegBankIdx", "=", "{", "PMI_FirstFPR", ",", "PMI_FirstGPR", "}", ";", "break", ";", "}", "case", "TargetOpcode", "::", "G_FPTOSI", ":", "case", "TargetOpcode", "::", "G_FPTOUI", ":", "{", "OpRegBankIdx", "=", "{", "PMI_FirstGPR", ",", "PMI_FirstFPR", "}", ";", "break", ";", "}", "case", "TargetOpcode", "::", "G_FCMP", ":", "{", "OpRegBankIdx", "=", "{", "PMI_FirstGPR", ",", "PMI_None", ",", "PMI_FirstFPR", ",", "PMI_FirstFPR", "}", ";", "break", ";", "}", "case", "TargetOpcode", "::", "G_BITCAST", ":", "{", "if", "(", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "!=", "OpRegBankIdx", "[", "<NUM_LIT>", "]", ")", "Cost", "=", "copyCost", "(", "*", "AArch64GenRegisterBankInfo", "::", "PartMappings", "[", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "]", ".", "RegBank", ",", "*", "AArch64GenRegisterBankInfo", "::", "PartMappings", "[", "OpRegBankIdx", "[", "<NUM_LIT>", "]", "]", ".", "RegBank", ",", "OpSize", "[", "<NUM_LIT>", "]", ")", ";", "break", ";", "}", "case", "TargetOpcode", "::", "G_LOAD", ":", "{", "if", "(", "OpRegBankIdx", "[", "<NUM_LIT>", "]", ">=", "PMI_FirstFPR", ")", "Cost", "=", "<NUM_LIT>", ";", "}", "}", "RegisterBankInfo", "::", "InstructionMapping", "Mapping", "=", "InstructionMapping", "{", "DefaultMappingID", ",", "Cost", ",", "nullptr", ",", "NumOperands", "}", ";", "SmallVector", "<", "const", "ValueMapping", "*", ",", "<NUM_LIT>", ">", "OpdsMapping", "(", "NumOperands", ")", ";", "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<", "NumOperands", ";", "++", "Idx", ")", "if", "(", "MI", ".", "getOperand", "(", "Idx", ")", ".", "isReg", "(", ")", ")", "OpdsMapping", "[", "Idx", "]", "=", "getValueMapping", "(", "OpRegBankIdx", "[", "Idx", "]", ",", "OpSize", "[", "Idx", "]", ")", ";", "Mapping", ".", "setOperandsMapping", "(", "getOperandsMapping", "(", "OpdsMapping", ")", ")", ";", "return", "Mapping", ";", "}" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

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

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

[ "DAG", ".", "ComputeMaskedBits", "(", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "<NUM_LIT>", ")", ";" ]

[ "APInt", "KnownZero2", ",", "KnownOne2", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "KnownZero", ".", "getBitWidth", "(", ")", ",", "<NUM_LIT>", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "return", "num", ";" ]

[ "}", "while", "(", "bit", ")", "{", "if", "(", "num", ">=", "den", ")", "{", "num", "-=", "den", ";", "res", "|=", "bit", ";", "}", "bit", ">>=", "<NUM_LIT>", ";", "den", ">>=", "<NUM_LIT>", ";", "}", "if", "(", "modwanted", ")" ]

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

[ "return", "DecodeMem", "(", "Inst", ",", "insn", ",", "Address", ",", "Decoder", ",", "true" ]

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

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

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

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

[ "}" ]

[ "def", "VulcanWrite_6Cyc_LS01_I012_I012", ":", "SchedWriteRes", "<", "[", "VulcanLS01", ",", "VulcanI012", ",", "VulcanI012", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>" ]

[ "(", "define_insn_and_split", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "SI", "[", "(", "mem", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "UNSPEC_VOLATILE_LOAD_FUNCDESC", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "isVarArg", ",", "Ins", ",", "DAG", ")", ";" ]

[ "SelectionDAG", "&", "DAG", "=", "CLI", ".", "DAG", ";", "SDLoc", "&", "dl", "=", "CLI", ".", "DL", ";", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", "=", "CLI", ".", "Outs", ";", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", "=", "CLI", ".", "OutVals", ";", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", "=", "CLI", ".", "Ins", ";", "SDValue", "Chain", "=", "CLI", ".", "Chain", ";", "SDValue", "Callee", "=", "CLI", ".", "Callee", ";", "bool", "&", "isTailCall", "=", "CLI", ".", "IsTailCall", ";", "CallingConv", "::", "ID", "CallConv", "=", "CLI", ".", "CallConv", ";", "bool", "isVarArg", "=", "CLI", ".", "IsVarArg", ";", "bool", "isPatchPoint", "=", "CLI", ".", "IsPatchPoint", ";", "const", "CallBase", "*", "CB", "=", "CLI", ".", "CB", ";", "if", "(", "isTailCall", ")", "{", "if", "(", "Subtarget", ".", "useLongCalls", "(", ")", "&&", "!", "(", "CB", "&&", "CB", "->", "isMustTailCall", "(", ")", ")", ")", "isTailCall", "=", "false", ";", "else", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", "isTailCall", "=", "IsEligibleForTailCallOptimization_64SVR4", "(", "Callee", ",", "CallConv", ",", "CB", ",", "isVarArg", ",", "Outs", ",", "Ins", ",", "DAG", ")", ";", "else", "isTailCall", "=", "IsEligibleForTailCallOptimization", "(", "Callee", ",", "CallConv", "," ]

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

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

[ "}" ]

[ "def", "d", ":", "BaseSIMDScalarShift", "<", "U", ",", "opc", ",", "{", "<NUM_LIT>", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", ",", "?", "}", ",", "FPR64", ",", "FPR64", ",", "vecshiftL64", ",", "asm", ",", "[", "(", "set", "(", "i64", "FPR64", ":", "$", "Rd", ")", ",", "(", "OpNode", "(", "i64", "FPR64", ":", "$", "Rn", ")", ",", "(", "i32", "vecshiftL64", ":", "$", "imm", ")", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "nullptr", ";" ]

[ "if", "(", "Data", "!=", "std", "::", "end", "(", "IntrinsicsWithChain", ")", "&&", "Data", "->", "Id", "==", "IntNo", ")", "return", "Data", ";", "return" ]

[ "<<", "<STR_LIT>", "resetSubtarget\\n", "<STR_LIT>", ")", ";" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")" ]

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

[ "(", "and", "(", "eq_attr" ]

[ "}" ]

[ "return", "ARM", "::", "PredBlockMask", "::", "TTT", ";", "case", "<NUM_LIT>", ":", "return", "ARM", "::", "PredBlockMask", "::", "TTTT", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Invalid BlockSize!", "<STR_LIT>", ")", ";" ]

[ "}", "=", "base", ";" ]

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

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

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

[ "return", "getMemoryOpCost", "(", "Opcode", ",", "VecTy", ",", "Alignment", ",", "AddressSpace", ",", "nullptr", ")", ";" ]

[ "unsigned", "HexagonTTIImpl", "::", "getInterleavedMemoryOpCost", "(", "unsigned", "Opcode", ",", "Type", "*", "VecTy", ",", "unsigned", "Factor", ",", "ArrayRef", "<", "unsigned", ">", "Indices", ",", "unsigned", "Alignment", ",", "unsigned", "AddressSpace", ",", "bool", "UseMaskForCond", ",", "bool", "UseMaskForGaps", ")", "{", "if", "(", "Indices", ".", "size", "(", ")", "!=", "Factor", "||", "UseMaskForCond", "||", "UseMaskForGaps", ")", "return", "BaseT", "::", "getInterleavedMemoryOpCost", "(", "Opcode", ",", "VecTy", ",", "Factor", ",", "Indices", ",", "Alignment", ",", "AddressSpace", ",", "UseMaskForCond", ",", "UseMaskForGaps", ")", ";" ]

[ "<FIXS>", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ")", ";", "<FIXE>", "<FIXS>", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTs", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i64", ")", ",", "<FIXE>" ]

[ "SDValue", "UpperBits", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SRL", ",", "DL", ",", "MVT", "::", "i64", ",", "Mul", ",", "<BUGS>", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i64", ")", ")", ";", "<BUGE>", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i64", ",", "MVT", "::", "i32", ")", ";", "Overflow", "=", "<BUGS>", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VTs", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "MVT", "::", "i64", ")", ",", "<BUGE>", "UpperBits", ")", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "}", "break", ";" ]

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

[ "[", "(", "match_parallel", "<NUM_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "set", "(", "mem", ":", "SI", "(", "plus", ":", "SI" ]

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

[ "(", "define_predicate", "<STR_LIT>", "(", "if_then_else", "(" ]

[ "(", "Res", ",", "Sign", ")", ";" ]

[ "Value", "*", "Z", "=", "Builder", ".", "CreateFPToUI", "(", "ScaledY", ",", "I32Ty", ")", ";", "Value", "*", "NegY", "=", "Builder", ".", "CreateSub", "(", "Zero", ",", "Y", ")", ";", "Value", "*", "NegYZ", "=", "Builder", ".", "CreateMul", "(", "NegY", ",", "Z", ")", ";", "Z", "=", "Builder", ".", "CreateAdd", "(", "Z", ",", "getMulHu", "(", "Builder", ",", "Z", ",", "NegYZ", ")", ")", ";", "Value", "*", "Q", "=", "getMulHu", "(", "Builder", ",", "X", ",", "Z", ")", ";", "Value", "*", "R", "=", "Builder", ".", "CreateSub", "(", "X", ",", "Builder", ".", "CreateMul", "(", "Q", ",", "Y", ")", ")", ";", "Value", "*", "Cond", "=", "Builder", ".", "CreateICmpUGE", "(", "R", ",", "Y", ")", ";", "if", "(", "IsDiv", ")", "Q", "=", "Builder", ".", "CreateSelect", "(", "Cond", ",", "Builder", ".", "CreateAdd", "(", "Q", ",", "One", ")", ",", "Q", ")", ";", "R", "=", "Builder", ".", "CreateSelect", "(", "Cond", ",", "Builder", ".", "CreateSub", "(", "R", ",", "Y", ")", ",", "R", ")", ";", "Cond", "=", "Builder", ".", "CreateICmpUGE", "(", "R", ",", "Y", ")", ";", "Value", "*", "Res", ";", "if", "(", "IsDiv", ")", "Res", "=", "Builder", ".", "CreateSelect", "(", "Cond", ",", "Builder", ".", "CreateAdd", "(", "Q", ",", "One", ")", ",", "Q", ")", ";", "else", "Res", "=", "Builder", ".", "CreateSelect", "(", "Cond", ",", "Builder", ".", "CreateSub", "(", "R", ",", "Y", ")", ",", "R", ")", ";", "if", "(", "IsSigned", ")", "{", "Res", "=", "Builder", ".", "CreateXor", "(", "Res", ",", "Sign", ")", ";", "Res", "=", "Builder", ".", "CreateSub" ]

[ "<FIXS>", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "bcomp", ",", "loc_ref", ",", "pc_rtx", ")", ")", ")", "<FIXE>" ]

[ "loc_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "<BUGS>", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "bcomp", ",", "loc_ref", ",", "pc_rtx", ")", ")", ")", "<BUGE>", "DONE", "}", ")" ]

[ "selectVAlign", "(", "N", ")", ";" ]

[ "HvxSelector", "(", "*", "this", ",", "*", "CurDAG", ")", "." ]

[ "ReadOnlySectionLarge", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".cp.rodata.large", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ")", ";" ]

[ "BSSSection", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".dp.bss", "<STR_LIT>", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "BSSSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".dp.bss.large", "<STR_LIT>", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataSection", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".dp.data", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".dp.data.large", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataRelROSection", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".dp.rodata", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "DataRelROSectionLarge", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".dp.rodata.large", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "XCORE_SHF_DP_SECTION", ")", ";", "ReadOnlySection", "=", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".cp.rodata", "<STR_LIT>", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_ALLOC", "|", "ELF", "::", "XCORE_SHF_CP_SECTION", ")", ";" ]

[ "(", "clobber", "(", "reg", ":", "CC", "FLAGS_REG", ")", ")", "]" ]

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

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

[ "int", "ATOMICNORET", "=", "<NUM_LIT>", ";", "int", "SIGNAL", "=", "<NUM_LIT>", ";", "int", "SIGNALNORET", "=", "<NUM_LIT>", ";", "int", "MEMFENCE", "=", "<NUM_LIT>", ";", "int", "RDIMAGE", "=", "<NUM_LIT>", ";", "int", "LDIMAGE", "=", "<NUM_LIT>", ";", "int", "STIMAGE", "=", "<NUM_LIT>", ";", "int", "IMAGEFENCE", "=", "<NUM_LIT>", ";", "int", "QUERYIMAGE", "=", "<NUM_LIT>", ";", "int", "QUERYSAMPLER", "=", "<NUM_LIT>", ";", "int", "CBR", "=", "<NUM_LIT>", ";", "int", "BR", "=", "<NUM_LIT>", ";", "int", "SBR", "=", "<NUM_LIT>", ";", "int", "BARRIER", "=", "<NUM_LIT>", ";", "int", "WAVEBARRIER", "=", "<NUM_LIT>", ";", "int", "ARRIVEFBAR", "=", "<NUM_LIT>", ";", "int", "INITFBAR", "=", "<NUM_LIT>", ";", "int", "JOINFBAR", "=", "<NUM_LIT>", ";", "int", "LEAVEFBAR", "=", "<NUM_LIT>", ";", "int", "RELEASEFBAR", "=", "<NUM_LIT>", ";", "int", "WAITFBAR", "=", "<NUM_LIT>", ";", "int", "LDF", "=", "<NUM_LIT>", ";", "int", "ACTIVELANECOUNT", "=", "<NUM_LIT>", ";", "int", "ACTIVELANEID", "=", "<NUM_LIT>", ";", "int", "ACTIVELANEMASK", "=", "<NUM_LIT>", ";", "int", "ACTIVELANEPERMUTE", "=", "<NUM_LIT>", ";", "int", "CALL", "=", "<NUM_LIT>", ";", "int", "SCALL", "=", "<NUM_LIT>", ";", "int", "ICALL", "=", "<NUM_LIT>", ";", "int", "RET", "=", "<NUM_LIT>", ";", "int", "ALLOCA", "=", "<NUM_LIT>", ";", "int", "CURRENTWORKGROUPSIZE", "=", "<NUM_LIT>", ";", "int", "CURRENTWORKITEMFLATID", "=", "<NUM_LIT>", ";", "int", "DIM", "=", "<NUM_LIT>", ";", "int", "GRIDGROUPS", "=", "<NUM_LIT>", ";", "int", "GRIDSIZE", "=", "<NUM_LIT>", ";", "int", "PACKETCOMPLETIONSIG", "=", "<NUM_LIT>", ";", "int", "PACKETID", "=", "<NUM_LIT>", ";", "int", "WORKGROUPID", "=", "<NUM_LIT>", ";", "int", "WORKGROUPSIZE", "=", "<NUM_LIT>", ";", "int", "WORKITEMABSID", "=", "<NUM_LIT>", ";", "int", "WORKITEMFLATABSID", "=", "<NUM_LIT>", ";", "int", "WORKITEMFLATID", "=", "<NUM_LIT>", ";", "int", "WORKITEMID", "=", "<NUM_LIT>", ";", "int", "CLEARDETECTEXCEPT", "=", "<NUM_LIT>", ";", "int", "GETDETECTEXCEPT", "=", "<NUM_LIT>", ";", "int", "SETDETECTEXCEPT", "=", "<NUM_LIT>", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "offset", ";" ]

[ "}" ]

[ "def", "SWSri", ":", "BaseFPToInteger", "<", "<NUM_LIT>", ",", "rmode", ",", "opcode", ",", "FPR32", ",", "GPR32", ",", "fixedpoint_f32_i32", ",", "asm", ",", "[", "(", "set", "GPR32", ":", "$", "Rd", ",", "(", "OpN", "(", "fmul", "FPR32", ":", "$", "Rn", ",", "fixedpoint_f32_i32", ":", "$", "scale", ")", ")", ")", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "scale", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "let", "ParserMatchClass", "=", "!", "cast", "<", "AsmOperandClass", ">", "(", "<STR_LIT>", "#", "shift", "#", "<STR_LIT>", ")", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "MIOperandInfo", "=", "(", "ops", "GPRnopc", ":", "$", "base", ",", "MQPR", ":", "$", "offsreg", ")", ";" ]

[ ")", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "HI", "(", "mult", ":", "HI", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>" ]