Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "}" ]

[ "def", "C2_cmpgtup", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_85d5d03f", ",", "TypeALU64", ">", ",", "Enc_fcf7a7", "{", "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", "isCompare", "=", "<NUM_LIT>", ";" ]

[ "}", ")" ]

[ "{", "emit_insn", "(", "gen_fix_trunc", "<", "DSF", ":", "mode", ">", "<", "GPR", ":", "mode", ">", "<NUM_LIT>", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "GEN_INT", "(", "BFP_RND_TOWARD_0", ")", ")", ")", "DONE" ]

[ "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i8", ";", "if", "(", "VT", ".", "isSimple", "(", ")", ")", "{", "MVT", "VVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "const", "unsigned", "NumElts", "=", "VVT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "EltVT", "=", "VVT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VVT", ".", "is512BitVector", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i32", "||", "EltVT", "==", "MVT", "::", "i64", "||", "EltVT", "==", "MVT", "::", "f32", "||", "EltVT", "==", "MVT", "::", "f64", ")", "switch", "(", "NumElts", ")", "{", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v8i1", ";", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v16i1", ";", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", ")", "if", "(", "EltVT", "==", "MVT", "::", "i8", "||", "EltVT", "==", "MVT", "::", "i16", ")", "switch", "(", "NumElts", ")", "{", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v32i1", ";", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v64i1", ";", "}", "}", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "return", "MVT", "::", "getVectorVT", "(", "MVT", "::", "i1", ",", "NumElts", ")", ";", "if", "(", "!", "isTypeLegal", "(", "VT", ")", "&&", "getTypeAction", "(", "Context", ",", "VT", ")", "==", "TypePromoteInteger", ")", "{", "EVT", "LegalVT", "=", "getTypeToTransformTo", "(", "Context", ",", "VT", ")", ";", "EltVT", "=", "LegalVT", ".", "getVectorElementType", "(", ")", ".", "getSimpleVT", "(", ")", ";", "}", "if", "(", "Subtarget", ".", "hasVLX", "(", ")", "&&", "EltVT", ".", "getSizeInBits", "(", ")", ">=", "<NUM_LIT>", ")", "switch", "(", "NumElts", ")", "{", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v2i1", ";", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v4i1", ";", "case", "<NUM_LIT>", ":", "return", "MVT", "::", "v8i1", ";", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "(", "mul", "node", ":", "$", "Rn", ",", "node", ":", "$", "Rm", ")", ")", ">", ";" ]

[ "def", "Neon_mla", ":", "PatFrag", "<", "(", "ops", "node", ":", "$", "Ra", ",", "node", ":", "$", "Rn", ",", "node", ":", "$", "Rm", ")", ",", "(", "add", "node", ":", "$", "Ra", "," ]

[ "<FIXS>", "Register", "VReg", "=", "MI", ".", "getOperand", "(", "Idx", ")", ".", "getReg", "(", ")", ";", "<FIXE>" ]

[ "for", "(", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "Idx", "<NUM_LIT>", ";", "++", "Idx", ")", "{", "<BUGS>", "unsigned", "VReg", "=", "MI", ".", "getOperand", "(", "Idx", ")", ".", "getReg", "(", ")", ";", "<BUGE>", "MachineInstr", "*", "DefMI", "=", "MRI", ".", "getVRegDef", "(", "VReg", ")", ";", "if", "(", "getRegBank", "(", "VReg", ",", "MRI", ",", "TRI", ")", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", "||", "onlyDefinesFP", "(", "*", "DefMI", ",", "MRI", ",", "TRI", ")", ")" ]

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

[ "def", "PCRelLabel19Operand", ":", "PCRelLabel" ]

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

[ "(", "const_string", "<STR_LIT>", ")", ")", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set", "(", "attr", "<STR_LIT>", ")", "<BUGS>", "(", "cond", "[", "(", "and", "(", "match_test", "<STR_LIT>", ")", "<BUGE>", "(", "ior", "(", "match_test", "<STR_LIT>", ")", "(", "match_test", "<STR_LIT>", ")", ")", ")", "(", "const_string", "<STR_LIT>", ")" ]

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

[ "if", "(", "PreAlloc", ")", "return", "new" ]

[ "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb", "(", ")", ")", "return", "false", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ",", "AssignFn", ")", ";", "SmallVector", "<", "ArgInfo", ",", "<NUM_LIT>", ">", "ArgInfos", ";", "SmallVector", "<", "unsigned", ",", "<NUM_LIT>", ">", "SplitRegs", ";", "unsigned", "Idx", "=", "<NUM_LIT>", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "AInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "AInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "SplitRegs", ".", "clear", "(", ")", ";", "splitToValueTypes", "(", "AInfo", ",", "ArgInfos", ",", "MF", ",", "[", "&", "]", "(", "unsigned", "Reg", ",", "uint64_t", "Offset", ")", "{", "SplitRegs", ".", "push_back", "(", "Reg", ")", ";", "}", ")", ";", "if", "(", "!", "SplitRegs", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "buildMerge", "(", "VRegs", "[", "Idx", "]", ",", "SplitRegs", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "return", "handleAssignments", "(", "MIRBuilder", ",", "ArgInfos", ",", "ArgHandler", ")", ";", "}" ]

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

[ "static", "bool", "nios2_rtx_costs", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "int", "code", "=", "GET_CODE", "(", "x", ")", ";", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "x", ")", "==", "<NUM_LIT>", "||", "nios2_simple_const_p", "(", "x", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "case", "CONST", ":", "case", "CONST_DOUBLE", ":", "if", "(", "gprel_constant_p", "(", "x", ")", "||", "r0rel_constant_p", "(", "x", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "else", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "HIGH", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "LO_SUM", ":", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "case", "AND", ":", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "NOT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", "==", "NOT", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "case", "MULT", ":", "{", "if", "(", "!", "TARGET_HAS_MUL", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "if", "(", "TARGET_HAS_MULX", "&&", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "{", "enum", "rtx_code", "c0", "=", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "enum", "rtx_code", "c1", "=", "GET_CODE", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "(", "c0", "==", "SIGN_EXTEND", "&&", "c1", "==", "SIGN_EXTEND", ")", "||", "(", "c0", "==", "ZERO_EXTEND", "&&", "c1", "==", "ZERO_EXTEND", ")", ")", "{", "*", "total", "=", "*", "total", "*", "<NUM_LIT>", "+", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "case", "DIV", ":", "{", "if", "(", "!", "TARGET_HAS_DIV", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "if", "(", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "false", ";", "}", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "ROTATE", ":", "{", "if", "(", "!", "speed", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "false", ";", "}", "case", "ZERO_EXTRACT", ":", "if", "(", "TARGET_HAS_BMX", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "SIGN_EXTEND", ":", "{", "if", "(", "MEM_P", "(", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ")", ")", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "else", "*", "total", "=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "false", ";", "}", "case", "MEM", ":", "{", "rtx", "addr", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "*", "total", "=", "nios2_address_cost", "(", "addr", ",", "mode", ",", "ADDR_SPACE_GENERIC", ",", "speed", ")", ";", "if", "(", "outer_code", "==", "SET", "&&", "opno", "==", "<NUM_LIT>", ")", ";", "else", "if", "(", "outer_code", "==", "SET", "||", "outer_code", "==", "SIGN_EXTEND", "||", "outer_code", "==", "ZERO_EXTEND", ")", "{", "if", "(", "speed", ")", "*", "total", "+=", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "}", "else", "*", "total", "+=", "COSTS_N_INSNS", "(", "speed", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "Inst", ";" ]

[ "class", "InstRILb", "<", "bits", "<", "<NUM_LIT>", ">", "op", ",", "dag", "outs", ",", "dag", "ins", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "InstSystemZ", "<", "<NUM_LIT>", ",", "outs", ",", "ins", ",", "asmstr", ",", "pattern", ">", "{", "field", "bits", "<", "<NUM_LIT>", ">" ]

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

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

[ ")", ",", "(", "ins", ")", ",", "<STR_LIT>", ",", "[", "]", ",", "IIC_std", ">", ";" ]

[ "def", "STDFQrr", ":", "F3_1", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "(", "outs", "MEMrr", ":", "$", "addr" ]

[ ")", "{" ]

[ "RegisterRef", "UR", "=", "UN", ".", "Addr", "->", "getRegRef", "(", ")", ";", "NodeSet", "Visited", ",", "Defs", ";", "const", "auto", "&", "ReachingDefs", "=", "LV", "->", "getAllReachingDefsRec", "(", "UR", ",", "UN", ",", "Visited", ",", "Defs", ")", ";", "if", "(", "ReachingDefs", ".", "size", "(", ")", ">", "<NUM_LIT>", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** Multiple Reaching Defs found!!! ***\\n", "<STR_LIT>", ";", "for", "(", "auto", "DI", ":", "ReachingDefs" ]

[ "[", "(", "mem", ":", "I12MODE", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]" ]

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

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

[ "void", "ARM64InstPrinter", "::", "printPostIncOperand6", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "printPostIncOperand", "(", "MI", ",", "OpNo", ",", "<NUM_LIT>", "," ]

[ "<FIXS>", "static", "bool", "flow_dependent_p", "(", "rtx_insn", "*", ",", "rtx_insn", "*", ")", ";", "<FIXE>" ]

[ "HOST_WIDE_INT", ",", "tree", ")", ";", "static", "void", "sh_file_start", "(", "void", ")", ";", "static", "bool", "sh_assemble_integer", "(", "rtx", ",", "unsigned", "int", ",", "int", ")", ";", "<BUGS>", "static", "bool", "flow_dependent_p", "(", "rtx", ",", "rtx", ")", ";", "<BUGE>", "static", "void", "flow_dependent_p_1", "(", "rtx", ",", "const_rtx", ",", "void", "*", ")", ";", "static", "int", "shiftcosts", "(", "rtx", ")", ";", "static", "int", "and", "_", "xor", "_", "ior_costs", "(", "rtx", ",", "int", ")", ";" ]

[ ")", ";" ]

[ "PPCTargetMachine", "::", "PPCTargetMachine", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ",", "CPU", ",", "computeFSAdditions", "(", "FS", ",", "OL", ",", "TT", ")", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "Triple", "(", "getTargetTriple", "(", ")", ")", ")", ")", ",", "DL", "(", "getDataLayoutString", "(", "Triple", "(", "TT", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "TargetFS", ",", "*", "this", ")", "{", "initAsmInfo", "(" ]

[ "static", "bool", "mcore_legitimate_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict_p", ",", "addr_space_t", "as", ",", "code_helper", ")", "{", "gcc_assert", "(", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", ";", "if", "(", "mcore_base_register_rtx_p", "(", "x", ",", "strict_p", ")", ")", "return", "true", ";", "else", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "||", "GET_CODE", "(", "x", ")", "==", "LO_SUM", ")", "{", "rtx", "xop0", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "rtx", "xop1", "=", "XEXP", "(", "x", ",", "<NUM_LIT>", ")", ";", "if", "(", "mcore_base_register_rtx_p", "(", "xop0", ",", "strict_p", ")", "&&", "mcore_legitimate_index_p", "(", "mode", ",", "xop1", ")", ")", "return", "true", ";", "if", "(", "mcore_base_register_rtx_p", "(", "xop1", ",", "strict_p", ")", "&&", "mcore_legitimate_index_p", "(", "mode", ",", "xop0", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Worker", "function", "for", "TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P", ".", "Allow", "REG", "REG", "+", "disp" ]

[ "}" ]

[ "dag", "OutOperandList", "=", "oops", ";", "dag", "InOperandList", "=", "iops", ";", "let", "AsmString", "=", "!", "strconcat", "(", "asm", ",", "operands", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "M4", ";", "bits", "<", "<NUM_LIT>", ">", "M5", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V2", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "M5", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "!", "if", "(", "!", "eq", "(", "m4or", "{", "<NUM_LIT>", "}", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "M4", "{", "<NUM_LIT>", "}", ")", ";" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", "compare_eq_p", "(", "rtx_insn", "*", "insn", ")", "<FIXE>", "<FIXS>", "return", "(", "cond", "==", "EQ", "||", "cond", "==", "NE", ")", ";", "<FIXE>", "<FIXS>", "static", "voidavr_canonicalize_comparison", "(", "int", "*", "icode", ",", "rtx", "*", "op0", ",", "rtx", "*", "op1", ",", "bool", "op0_fixed", ")", "<FIXE>", "<FIXS>", "enum", "rtx_code", "code", "=", "(", "enum", "rtx_code", ")", "*", "icode", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "*", "op0", ")", ";", "bool", "signed_p", "=", "code", "==", "GT", "||", "code", "==", "LE", ";", "bool", "unsigned_p", "=", "code", "==", "GTU", "||", "code", "==", "LEU", ";", "bool", "difficult_p", "=", "signed_p", "||", "unsigned_p", ";", "if", "(", "(", "!", "SCALAR_INT_MODE_P", "(", "mode", ")", "&&", "!", "ALL_SCALAR_FIXED_POINT_MODE_P", "(", "mode", ")", ")", "||", "!", "register_operand", "(", "*", "op0", ",", "mode", ")", ")", "return", ";", "if", "(", "!", "op0_fixed", "&&", "difficult_p", "&&", "register_operand", "(", "*", "op1", ",", "mode", ")", ")", "{", "std", "::", "swap", "(", "*", "op0", ",", "*", "op1", ")", ";", "*", "icode", "=", "(", "int", ")", "swap_condition", "(", "code", ")", ";", "return", ";", "}", "if", "(", "CONST_INT_P", "(", "*", "op1", ")", "||", "CONST_FIXED_P", "(", "*", "op1", ")", ")", "{", "scalar_int_mode", "imode", "=", "int_mode_for_mode", "(", "mode", ")", ".", "require", "(", ")", ";", "unsigned", "HOST_WIDE_INT", "mask", "=", "GET_MODE_MASK", "(", "imode", ")", ";", "unsigned", "HOST_WIDE_INT", "maxval", "=", "signed_p", "?", "mask", ">>", "<NUM_LIT>", ":", "mask", ";", "rtx", "xval", "=", "simplify_gen_subreg", "(", "imode", ",", "*", "op1", ",", "mode", ",", "<NUM_LIT>", ")", ";", "if", "(", "difficult_p", "&&", "(", "UINTVAL", "(", "xval", ")", "&", "mask", ")", "!=", "maxval", ")", "{", "xval", "=", "simplify_binary_operation", "(", "PLUS", ",", "imode", ",", "xval", ",", "const1_rtx", ")", ";", "*", "op1", "=", "simplify_gen_subreg", "(", "mode", ",", "xval", ",", "imode", ",", "<NUM_LIT>", ")", ";", "*", "icode", "=", "(", "int", ")", "avr_normalize_condition", "(", "code", ")", ";", "return", ";", "}", "if", "(", "code", "==", "LTU", "&&", "xval", "==", "const1_rtx", ")", "{", "*", "icode", "=", "(", "int", ")", "EQ", ";", "*", "op1", "=", "CONST0_RTX", "(", "mode", ")", ";", "return", ";", "}", "if", "(", "code", "==", "GEU", "&&", "xval", "==", "const1_rtx", ")", "{", "*", "icode", "=", "(", "int", ")", "NE", ";", "*", "op1", "=", "CONST0_RTX", "(", "mode", ")", ";", "return", ";", "}", "}", "<FIXE>" ]

[ "}", "<BUGS>", "<BUGE>", "static", "bool", "<BUGS>", "compare_diff_p", "(", "rtx_insn", "*", "insn", ")", "<BUGE>", "{", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "<BUGS>", "return", "(", "cond", "==", "GT", "||", "cond", "==", "GTU", "||", "cond", "==", "LE", "||", "cond", "==", "LEU", ")", "?", "cond", ":", "<NUM_LIT>", ";", "<BUGE>", "}", "<BUGS>", "static", "boolcompare_eq_p", "(", "rtx_insn", "*", "insn", ")", "<BUGE>", "{", "<BUGS>", "RTX_CODE", "cond", "=", "compare_condition", "(", "insn", ")", ";", "return", "(", "cond", "==", "EQ", "||", "cond", "==", "NE", ")", ";", "<BUGE>", "}" ]

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

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

[ "<FIXS>", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%c value", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "case", "'", "c", "'", ":", "if", "(", "GET_CODE", "(", "x", ")", "!=", "REG", "||", "!", "CR_REGNO_P", "(", "REGNO", "(", "x", ")", ")", ")", "<BUGS>", "output_operand_lossage", "(", "<STR_LIT>", "invalid %%E value", "<STR_LIT>", ")", ";", "<BUGE>", "elsefprintf", "(", "file", ",", "<STR_LIT>", "%d", "<STR_LIT>", ",", "<NUM_LIT>", "*", "(", "REGNO", "(", "x", ")", "-", "CR0_REGNO", ")", "+", "<NUM_LIT>", ")", ";", "return", ";" ]

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

[ "static", "rtx", "rs6000_emit_stack_reset", "(", "rs6000_stack_t", "*", "info", ",", "rtx", "frame_reg_rtx", ",", "HOST_WIDE_INT", "frame_off", ",", "unsigned", "updt_regno", ")", "{", "rtx", "updt_reg_rtx", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "(", "TARGET_SPE_ABI", "&&", "info", "->", "spe_64bit_regs_used", "!=", "<NUM_LIT>", "&&", "info", "->", "first_gp_reg_save", "!=", "<NUM_LIT>", ")", ")", "rs6000_emit_stack_tie", "(", "frame_reg_rtx", ",", "frame_pointer_needed", ")", ";", "updt_reg_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "updt_regno", ")", ";", "if", "(", "frame_off", "!=", "<NUM_LIT>", ")", "return", "emit_insn", "(", "gen_add3_insn", "(", "updt_reg_rtx", ",", "frame_reg_rtx", ",", "GEN_INT", "(" ]

[ "}" ]

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

[ "<NUM_LIT>", ";" ]

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

[ "return", "SPDiff", ";" ]

[ "int", "SPDiff", "=", "(", "int", ")", "CallerMinReservedArea", "-", "(", "int", ")", "ParamSize", ";", "if", "(", "SPDiff", "<", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "FI", "->", "setTailCallSPDelta", "(", "SPDiff", ")", ";" ]

[ "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "ARM", "::", "CPSR", ")", "continue", ";" ]

[ "default", ":", "break", ";", "case", "ARM", "::", "RSBrr", ":", "case", "ARM", "::", "RSBri", ":", "case", "ARM", "::", "RSCrr", ":", "case", "ARM", "::", "RSCri", ":", "case", "ARM", "::", "ADDrr", ":", "case", "ARM", "::", "ADDri", ":", "case", "ARM", "::", "ADCrr", ":", "case", "ARM", "::", "ADCri", ":", "case", "ARM", "::", "SUBrr", ":", "case", "ARM", "::", "SUBri", ":", "case", "ARM", "::", "SBCrr", ":", "case", "ARM", "::", "SBCri", ":", "case", "ARM", "::", "t2RSBri", ":", "case", "ARM", "::", "t2ADDrr", ":", "case", "ARM", "::", "t2ADDri", ":", "case", "ARM", "::", "t2ADCrr", ":", "case", "ARM", "::", "t2ADCri", ":", "case", "ARM", "::", "t2SUBrr", ":", "case", "ARM", "::", "t2SUBri", ":", "case", "ARM", "::", "t2SBCrr", ":", "case", "ARM", "::", "t2SBCri", ":", "case", "ARM", "::", "ANDrr", ":", "case", "ARM", "::", "ANDri", ":", "case", "ARM", "::", "t2ANDrr", ":", "case", "ARM", "::", "t2ANDri", ":", "case", "ARM", "::", "ORRrr", ":", "case", "ARM", "::", "ORRri", ":", "case", "ARM", "::", "t2ORRrr", ":", "case", "ARM", "::", "t2ORRri", ":", "case", "ARM", "::", "EORrr", ":", "case", "ARM", "::", "EORri", ":", "case", "ARM", "::", "t2EORrr", ":", "case", "ARM", "::", "t2EORri", ":", "{", "bool", "isSafe", "=", "false", ";", "I", "=", "CmpInstr", ";", "E", "=", "MI", "->", "getParent", "(", ")", "->", "end", "(", ")", ";", "while", "(", "!", "isSafe", "&&", "++", "I", "!=", "E", ")", "{", "const", "MachineInstr", "&", "Instr", "=", "*", "I", ";", "for", "(", "unsigned", "IO", "=", "<NUM_LIT>", ",", "EO", "=", "Instr", ".", "getNumOperands", "(", ")", ";", "!", "isSafe", "&&", "IO", "!=", "EO", ";", "++", "IO", ")", "{", "const", "MachineOperand", "&", "MO", "=", "Instr", ".", "getOperand", "(", "IO", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "CPSR", ")", ")", "{", "isSafe", "=", "true", ";", "break", ";", "}" ]

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

[ "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "pc", ")", "(", "any_return", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>" ]

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

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

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

[ "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "(", "clobber", "(", "reg", ":", "HI", "<NUM_LIT>", ")", ")", "]", ")", "(", "set", "(", "match_operand", ":", "ALL4A", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "reg", ":", "ALL4A", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "{", "avr_fix_inputs", "(", "operands", ",", "<NUM_LIT>", "<", "<", "<NUM_LIT>", ",", "regmask", "(", "<", "MODE", ">", "mode" ]

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

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

[ "}" ]

[ "if", "(", "_", "_", "GTHR_W32_InterlockedCompareExchange", "(", "&", "mutex", "->", "counter", ",", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ")", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "else", "return", "<NUM_LIT>", ";" ]

[ "}", "def", "GenericReadCOP0", ":", "SchedWriteRes", "<", "[", "GenericIssueCOP0", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "}", "def", "GenericReadWritePGPR", ":", "SchedWriteRes", "<", "[", "GenericIssueCOP0", "]", ">", ";" ]

[ "def", "GenericCOP0", ":", "ProcResource", "<", "<NUM_LIT>", ">", "{", "let", "BufferSize", "=", "<NUM_LIT>", ";", "}", "def", "GenericIssueCOP0", ":", "ProcResource", "<", "<NUM_LIT>", ">", "{", "let", "Super", "=", "GenericCOP0", ";", "}", "def", "GenericWriteCOP0TLB", ":", "SchedWriteRes", "<", "[", "GenericIssueCOP0", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";", "}", "def", "GenericWriteCOP0", ":", "SchedWriteRes", "<", "[", "GenericIssueCOP0", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ";" ]

[ "if", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR64RegClassID", "]", ".", "contains", "(", "BaseReg", ")", "&&", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR16RegClassID", "]", ".", "contains", "(", "IndexReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "GR32RegClassID", "]", ".", "contains", "(", "IndexReg", ")", ")", "&&", "IndexReg", "!=", "X86", "::", "RIZ", ")", "{", "ErrMsg", "=", "<STR_LIT>", "base register is 64-bit, but index register is not", "<STR_LIT>", ";", "return", "true", ";", "}", "if", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR32RegClassID", "]", ".", "contains", "(", "BaseReg", ")", "&&", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR16RegClassID", "]", ".", "contains", "(", "IndexReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "GR64RegClassID", "]", ".", "contains", "(", "IndexReg", ")", ")", "&&", "IndexReg", "!=", "X86", "::", "EIZ", ")", "{", "ErrMsg", "=", "<STR_LIT>", "base register is 32-bit, but index register is not", "<STR_LIT>", ";", "return", "true", ";", "}", "if", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR16RegClassID", "]", ".", "contains", "(", "BaseReg", ")", ")", "{", "if", "(", "X86MCRegisterClasses", "[", "X86", "::", "GR32RegClassID", "]", ".", "contains", "(", "IndexReg", ")", "||", "X86MCRegisterClasses", "[", "X86", "::", "GR64RegClassID", "]", ".", "contains", "(", "IndexReg", ")", ")", "{", "ErrMsg", "=", "<STR_LIT>", "base register is 16-bit, but index register is not", "<STR_LIT>", ";", "return", "true", ";", "}", "if", "(", "(", "(", "BaseReg", "==", "X86", "::", "BX", "||", "BaseReg", "==", "X86", "::", "BP", ")", "&&", "IndexReg", "!=", "X86", "::", "SI", "&&", "IndexReg", "!=", "X86", "::", "DI", ")", "||", "(", "(", "BaseReg", "==", "X86", "::", "SI", "||", "BaseReg", "==", "X86", "::", "DI", ")", "&&", "IndexReg", "!=", "X86", "::", "BX", "&&", "IndexReg", "!=", "X86", "::", "BP", ")", ")", "{", "ErrMsg", "=", "<STR_LIT>", "invalid 16-bit base/index register combination" ]

[ "}", "=", "BD2", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "BD2", ";", "bits", "<", "<NUM_LIT>", ">", "R3", ";", "bits", "<", "<NUM_LIT>", ">", "M4", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "op", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "V1", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "R3", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>" ]

[ "}" ]

[ "SDValue", "Z80oldTargetLowering", "::", "combineINSERT_SUBREG", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "return", "SDValue", "(", ")", ";" ]

[ "case", "AtomicRMWInst", "::", "Max", ":" ]

[ "case", "AtomicRMWInst", "::", "Add", ":", "return", "B", ".", "CreateBinOp", "(", "Instruction", "::", "Add", ",", "LHS", ",", "RHS", ")", ";", "case", "AtomicRMWInst", "::", "FAdd", ":", "return", "B", ".", "CreateFAdd", "(", "LHS", ",", "RHS", ")", ";", "case", "AtomicRMWInst", "::", "Sub", ":", "return", "B", ".", "CreateBinOp", "(", "Instruction", "::", "Sub", ",", "LHS", ",", "RHS", ")", ";", "case", "AtomicRMWInst", "::", "FSub", ":", "return", "B", ".", "CreateFSub", "(", "LHS", ",", "RHS", ")", ";", "case", "AtomicRMWInst", "::", "And", ":", "return", "B", ".", "CreateBinOp", "(", "Instruction", "::", "And", ",", "LHS", ",", "RHS", ")", ";", "case", "AtomicRMWInst", "::", "Or", ":", "return", "B", ".", "CreateBinOp", "(", "Instruction", "::", "Or", ",", "LHS", ",", "RHS", ")", ";", "case", "AtomicRMWInst", "::", "Xor", ":", "return", "B", ".", "CreateBinOp", "(", "Instruction", "::", "Xor", ",", "LHS", ",", "RHS", ")", ";" ]

[ "const", "{" ]

[ "unsigned", "getPointerSize", "(", ")" ]

[ "_", "_", "X", ";" ]

[ "long", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "blsi_u64", "(", "unsigned", "long", "long", "_", "_", "X", ")", "{", "return", "_", "_", "X", "&", "-" ]

[ "if", "(", "!", "TARGET_H8300SX", ")", "{" ]

[ "if", "(", "(", "!", "TARGET_H8300S", "&&", "TARGET_EXR", ")", "&&", "(", "!", "TARGET_H8300SX", "&&", "TARGET_EXR", ")", ")", "{", "error", "(", "<STR_LIT>", "-mexr is used without -ms or -msx", "<STR_LIT>", ")", ";", "target_flags", "|=", "MASK_H8300S_1", ";", "}", "if", "(", "(", "!", "TARGET_H8300S", "&&", "TARGET_NEXR", ")", "&&", "(", "!", "TARGET_H8300SX", "&&", "TARGET_NEXR", ")", ")", "{", "warning", "(", "OPT_mno_exr", ",", "<STR_LIT>", "-mno-exr valid only with -ms or -msx \\ - Option ignored!", "<STR_LIT>", ")", ";", "}", "if", "(", "(", "TARGET_NORMAL_MODE", ")", ")", "{", "error", "(", "<STR_LIT>", "-mn is not supported for linux targets", "<STR_LIT>", ")", ";", "target_flags", "^=", "MASK_NORMAL_MODE", ";", "}", "if", "(", "optimize_size", ")", "{", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_LSHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_300H", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "shift_alg_hi", "[", "H8_S", "]", "[", "SHIFT_ASHIFTRT", "]", "[", "<NUM_LIT>", "]", "=", "SHIFT_LOOP", ";", "}" ]

[ "int", "thumb_legitimate_offset_p", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "<NUM_LIT>", ":", "return", "val", ">=", "<NUM_LIT>", "&&", "val", "<", "<NUM_LIT>", ";", "case", "<NUM_LIT>", ":", "return", "val", ">=", "<NUM_LIT>", "&&", "val", "<", "<NUM_LIT>", "&&", "(", "val", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ";", "default", ":", "return", "(", "val", ">=", "<NUM_LIT>", "&&", "(", "val", "+", "GET_MODE_SIZE", "(", "mode", ")", ")", "<=", "<NUM_LIT>", "&&", "(", "val", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ";", "}", "}" ]

[ "Return", "nonzero", "if", "VAL", "can", "be", "used", "as", "an", "offset", "in", "a", "Thumb-state", "address", "instruction", "of", "mode", "MODE", "." ]

[ ")", "name", "+=", "skip", ";" ]

[ "const", "char", "*", "arm_strip_name_encoding", "(", "const", "char", "*", "name", ")", "{", "int", "skip", ";", "while", "(", "(", "skip", "=", "arm_get_strip_length", "(", "*", "name", ")", ")" ]

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

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

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

[ "MachineLoop", "*", "loop", "=", "MLI", ".", "getLoopFor", "(", "MBB", ")", ";", "if", "(", "loop", ")", "{", "depth", "=", "loop", "->", "getLoopDepth", "(", ")", ";", "if", "(", "loop", "->", "getLoopDepth", "(", ")", "<=", "<NUM_LIT>", ")", "return", "false", ";", "else", "return", "true", ";", "}" ]

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

[ "(", "unspec", ":", "DI", "[", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "]", "UNSPEC_CVTLQ", ")", ")", "]", "<STR_LIT>", "<STR_LIT>" ]

[ "unsigned", "Imm", "=", "<STR_LIT>", "::", "<STR_LIT>", "(", "ET", ",", "getShiftExtendAmount", "(", ")", ")", ";" ]

[ "<STR_LIT>", "::", "<STR_LIT>", "ET", "=", "getShiftExtendType", "(", ")", ";", "if", "(", "ET", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "ET", "=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "}" ]

[ "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "}", "else", "{", "errs", "(", ")", "<<", "<STR_LIT>", "Register: ", "<STR_LIT>", "<<", "DestReg", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "llvm_unreachable", "(", "<STR_LIT>", "Register class not handled!", "<STR_LIT>", ")", ";", "}" ]

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

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

[ "}" ]

[ "Mul", "=", "AddcNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "Mul", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "MUL", ")", "return", "SDValue", "(", ")", ";", "}", "SDValue", "SRA", "=", "AddeNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Hi", "=", "AddeNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "SRA", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SRA", ")", "{", "SRA", "=", "AddeNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Hi", "=", "AddeNode", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "SRA", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "SRA", ")", "return", "SDValue", "(", ")", ";", "}", "if", "(", "auto", "Const", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "SRA", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "Const", "->", "getZExtValue", "(", ")", "!=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "}", "else", "return", "SDValue", "(", ")", ";", "if", "(", "SRA", ".", "getOperand", "(", "<NUM_LIT>", ")", "!=", "Mul", ")", "return", "SDValue", "(", ")", ";", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "SDLoc", "dl", "(", "AddcNode", ")", ";", "unsigned", "Opcode", "=", "<NUM_LIT>", ";", "SDValue", "Op0", ";", "SDValue", "Op1", ";", "if", "(", "isS16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", "&&", "isS16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ")", "{", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Op0", "=", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Op1", "=", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "isS16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", "&&", "isSRA16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Op0", "=", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Op1", "=", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "isSRA16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "isS16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ")", ")", "{", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Op0", "=", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Op1", "=", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "isSRA16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "&&", "isSRA16", "(", "Mul", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "Opcode", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "Op0", "=", "Mul", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "Op1", "=", "Mul", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "}", "if", "(", "!", "Op0", "||", "!", "Op1", ")", "return", "SDValue", "(", ")", ";", "SDValue", "SMLAL", "=", "DAG", ".", "getNode", "(", "Opcode", ",", "dl", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ")", ",", "Op0", ",", "Op1", ",", "Lo", ",", "Hi", ")", ";", "SDValue", "HiMLALResult", "(", "SMLAL", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ";", "SDValue", "LoMLALResult", "(", "SMLAL", ".", "getNode", "(", ")", ",", "<NUM_LIT>", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "AddcNode", ",", "<NUM_LIT>", ")", ",", "LoMLALResult", ")", ";", "DAG", ".", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "AddeNode", ",", "<NUM_LIT>", ")", ",", "HiMLALResult", ")", ";", "SDValue", "resNode", "(", "AddcNode", ",", "<NUM_LIT>", ")", ";", "return", "resNode", ";" ]

[ "int", "cr16_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", ">=", "<NUM_LIT>", ")", "&&", "(", "regno", "==", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", "{", "if", "(", "(", "regno", ">", "<NUM_LIT>", ")", "||", "(", "regno", "&", "<NUM_LIT>", ")", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}", "if", "(", "(", "TARGET_INT32", ")", "&&", "(", "(", "regno", ">=", "<NUM_LIT>", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

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

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_cvtps2udq128_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4si", ")", "_" ]

[ "}", "else", "if", "(", "RetOpcode", "==", "X86", "::", "TCRETURNri", "||", "RetOpcode", "==", "X86", "::", "TCRETURNdi", "||", "RetOpcode", "==", "X86", "::", "TCRETURNmi", "||", "RetOpcode", "==", "X86", "::", "TCRETURNri64", "||", "RetOpcode", "==", "X86", "::", "TCRETURNdi64", "||", "RetOpcode", "==", "X86", "::", "TCRETURNmi64", ")", "{" ]

[ "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "assert", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "&&", "<STR_LIT>", "Returning block has no instructions", "<STR_LIT>", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "const", "X86Subtarget", "&", "STI", "=", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "Is64Bit", "=", "STI", ".", "is64Bit", "(", ")", ";", "const", "bool", "Uses64BitFramePtr", "=", "STI", ".", "isTarget64BitLP64", "(", ")", "||", "STI", ".", "isTargetNaCl64", "(", ")", ";", "const", "bool", "Is64BitILP32", "=", "STI", ".", "isTarget64BitILP32", "(", ")", ";", "bool", "UseLEA", "=", "STI", ".", "useLeaForSP", "(", ")", ";", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "unsigned", "SlotSize", "=", "RegInfo", "->", "getSlotSize", "(", ")", ";", "unsigned", "FramePtr", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "MachineFramePtr", "=", "Is64BitILP32", "?", "getX86SubSuperRegister", "(", "FramePtr", ",", "MVT", "::", "i64", ",", "false", ")", ":", "FramePtr", ";", "unsigned", "StackPtr", "=", "RegInfo", "->", "getStackRegister", "(", ")", ";", "bool", "IsWinEH", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "WinEH", ";", "bool", "NeedsWinEH", "=", "IsWinEH", "&&", "MF", ".", "getFunction", "(", ")", "->", "needsUnwindTableEntry", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Can only insert epilog into returning blocks", "<STR_LIT>", ")", ";", "case", "X86", "::", "RETQ", ":", "case", "X86", "::", "RETL", ":", "case", "X86", "::", "RETIL", ":", "case", "X86", "::", "RETIQ", ":", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "case", "X86", "::", "EH_RETURN", ":", "case", "X86", "::", "EH_RETURN64", ":", "break", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "CSSize", "=", "X86FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "<NUM_LIT>", ";", "if", "(", "ForceStackAlign", ")", "{", "if", "(", "MFI", "->", "hasCalls", "(", ")", ")", "MaxAlign", "=", "(", "StackAlign", ">", "MaxAlign", ")", "?", "StackAlign", ":", "MaxAlign", ";", "else", "MaxAlign", "=", "MaxAlign", "?", "MaxAlign", ":", "<NUM_LIT>", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "SlotSize", ";", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "FrameSize", "-=", "CSSize", ";", "NumBytes", "=", "(", "FrameSize", "+", "MaxAlign", "-", "<NUM_LIT>", ")", "/", "MaxAlign", "*", "MaxAlign", ";", "}", "else", "{", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "}", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Is64Bit", "?", "X86", "::", "POP64r", ":", "X86", "::", "POP32r", ")", ",", "MachineFramePtr", ")", ";", "}", "else", "{", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "}", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "X86", "::", "POP32r", "&&", "Opc", "!=", "X86", "::", "POP64r", "&&", "Opc", "!=", "X86", "::", "DBG_VALUE", "&&", "!", "PI", "->", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "MachineBasicBlock", "::", "iterator", "FirstCSPop", "=", "MBBI", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "NumBytes", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "mergeSPUpdatesUp", "(", "MBB", ",", "MBBI", ",", "StackPtr", ",", "&", "NumBytes", ")", ";", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "MBBI", "=", "FirstCSPop", ";", "if", "(", "CSSize", "!=", "<NUM_LIT>", ")", "{", "unsigned", "Opc", "=", "getLEArOpcode", "(", "Uses64BitFramePtr", ")", ";", "addRegOffset", "(", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ",", "FramePtr", ",", "false", ",", "-", "CSSize", ")", ";", "--", "MBBI", ";", "}", "else", "{", "unsigned", "Opc", "=", "(", "Uses64BitFramePtr", "?", "X86", "::", "MOV64rr", ":", "X86", "::", "MOV32rr", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "FramePtr", ")", ";", "--", "MBBI", ";", "}", "}", "else", "if", "(", "NumBytes", ")", "{", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "StackPtr", ",", "NumBytes", ",", "Is64Bit", ",", "Uses64BitFramePtr", ",", "UseLEA", ",", "TII", ",", "*", "RegInfo", ")", ";", "--", "MBBI", ";", "}", "if", "(", "NeedsWinEH", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "X86", "::", "SEH_Epilogue", ")", ")", ";", "if", "(", "RetOpcode", "==", "X86", "::", "EH_RETURN", "||", "RetOpcode", "==", "X86", "::", "EH_RETURN64", ")", "{", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "MachineOperand", "&", "DestAddr", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "assert", "(", "DestAddr", ".", "isReg", "(", ")", "&&", "<STR_LIT>", "Offset should be in register!", "<STR_LIT>", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Uses64BitFramePtr", "?", "X86", "::", "MOV64rr", ":", "X86", "::", "MOV32rr", ")", ",", "StackPtr", ")", ".", "addReg", "(", "DestAddr", ".", "getReg", "(", ")", ")", ";" ]

[ "type", "ATTRIBUTE_UNUSED", ")", "{" ]

[ "static", "unsigned", "int", "m32c_function_arg_boundary", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "const_tree" ]

[ ";" ]

[ "auto", "Op", "=", "CreateReg", "(", "RegNum", ",", "Kind", ",", "S", ",", "E", ",", "Ctx", ",", "EqualsReg", ",", "ExtTy", ",", "ShiftAmount", ",", "HasExplicitAmount", ")", ";", "Op", "->", "Reg", ".", "ElementWidth", "=", "ElementWidth", ";", "return", "Op" ]

[ "}" ]

[ "def", "A2_addsp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rs32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", "{", "let", "isPseudo", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "_", "_", "arm_vandq_s16", "(", "int16x8_t", "_", "_", "a", ",", "int16x8_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_mve_vandq_sv8hi", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

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

[ "def", ":", "LoadPatGlobalAddrOffOnly", "<", "i32", ",", "atomic_load_16" ]

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

[ "(", "define_mode_iterator", "VDQ_I", "[", "V8QI", "V16QI", "V4HI", "V8HI", "V2SI", "V4SI" ]

[ "}" ]

[ "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XT", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "B", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "xo", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "XT", "{", "<NUM_LIT>", "}", ";" ]

[ "]", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lshiftrt", ":", "VI", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "VI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ ")", "{" ]

[ "}", "if", "(", "!", "TARGET_MMX", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "MMX_REGS", "]", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "<NUM_LIT>", ",", "reg_names", "[", "i", "]", "=", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "!", "TARGET_SSE", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "SSE_REGS", "]", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "<NUM_LIT>", ",", "reg_names", "[", "i", "]", "=", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "!", "(", "TARGET_80387", "||", "TARGET_FLOAT_RETURNS_IN_80387", ")", ")", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "FLOAT_REGS", "]", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "<NUM_LIT>", ",", "reg_names", "[", "i", "]", "=", "<STR_LIT>", "<STR_LIT>", ";", "if", "(", "!", "TARGET_AVX512F" ]

[ "for", "(", "unsigned", "i", "=", "I", ".", "getNumExplicitDefs", "(", ")", ";", "i", "<", "I", ".", "getNumExplicitOperands", "(", ")", ";", "++", "i", ")", "MIB", ".", "addUse", "(", "I", ".", "getOperand", "(", "i", ")", ".", "getReg", "(", ")", ")", ";" ]

[ "}", ")", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "*", "I", ".", "getParent", "(", ")", ",", "I", ",", "I", ".", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addDef", "(", "ResVReg", ")", ".", "addUse", "(", "GR", ".", "getSPIRVTypeID", "(", "ResType", ")", ")", ";" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "XB", ";", "let", "Pattern", "=", "pattern", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XT", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "XA", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "<FIXS>", "else", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "MEM", "|", "|", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "REG", ")", "<FIXE>" ]

[ "RET", "}", "<BUGS>", "else", "if", "(", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!", "=", "MEM", ")", "<BUGE>", "return", "AS1", "(", "push", "%", "L1", ",", "%", "<NUM_LIT>", ")", "else" ]

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

[ "def", "C2_muxir", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ",", "s32_0Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_4c5ba658", ",", "TypeALU32_2op", ">", ",", "Enc_e38e1f", "{", "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", "InputType", "=", "<STR_LIT>", ";" ]

[ "}" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "return", "MI", ".", "getOperand", "(", "Desc", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", "&&", "MI", ".", "getOperand", "(", "Desc", ".", "getNumOperands", "(", ")", "-", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

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

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

[ ")", "->", "getDataLayout", "(", ")", ")", ")", ";" ]

[ "TargetIRAnalysis", "AMDGPUTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "AMDGPUTTIImpl", "(", "this", ",", "F", ".", "getParent", "(" ]

[ ";" ]

[ "const", "InstrItineraryData", "&", "getInstrItineraryData", "(", ")", "const", "{", "return", "InstrItins" ]

[ "<FIXS>", "O", "<<", "Mang", "->", "getMangledName", "(", "Items", "[", "j", "]", ")", ";", "<FIXE>" ]

[ "O", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "SwitchToSection", "(", "PTAI", "->", "ROSections", "[", "i", "]", "->", "S_", ")", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "Items", ".", "size", "(", ")", ";", "j", "++", ")", "{", "<BUGS>", "O", "<<", "Mang", "->", "getValueName", "(", "Items", "[", "j", "]", ")", ";", "<BUGE>", "Constant", "*", "C", "=", "Items", "[", "j", "]", "->", "getInitializer", "(", ")", ";", "int", "AddrSpace", "=", "Items", "[", "j", "]", "->", "getType", "(", ")", "->", "getAddressSpace", "(", ")", ";", "EmitGlobalConstant", "(", "C", ",", "AddrSpace", ")", ";" ]

[ ":" ]

[ "case", "X86", "::", "CVTSI2SDrm", ":", "case", "X86", "::", "CVTSI2SD64rr", ":", "case", "X86", "::", "CVTSI2SD64rm", ":", "case", "X86", "::", "CVTSD2SSrr", ":", "case", "X86", "::", "CVTSD2SSrm", ":", "case", "X86", "::", "Int_CVTSD2SSrr", ":", "case", "X86", "::", "Int_CVTSD2SSrm", ":", "case", "X86", "::", "CVTSS2SDrr", ":", "case", "X86", "::", "CVTSS2SDrm", ":", "case", "X86", "::", "Int_CVTSS2SDrr", ":", "case", "X86", "::", "Int_CVTSS2SDrm", ":", "case", "X86", "::", "MOVHPDrm", ":", "case", "X86", "::", "MOVHPSrm", ":", "case", "X86", "::", "MOVLPDrm", ":", "case", "X86", "::", "MOVLPSrm", ":", "case", "X86", "::", "RCPSSr", ":", "case", "X86", "::", "RCPSSm", ":", "case", "X86", "::", "RCPSSr_Int", ":", "case", "X86", "::", "RCPSSm_Int", ":", "case", "X86", "::", "ROUNDSDr", ":", "case", "X86", "::", "ROUNDSDm", ":", "case", "X86", "::", "ROUNDSDr_Int", ":", "case", "X86", "::", "ROUNDSSr", ":", "case", "X86", "::", "ROUNDSSm", ":", "case", "X86", "::", "ROUNDSSr_Int" ]

[ "for", "(", "APInt", "&", "Elt", ":", "EltBits", ")", "{" ]

[ "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "unsigned", "NumBitsPerElt", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "assert", "(", "VT", "==", "N0", ".", "getValueType", "(", ")", "&&", "(", "NumBitsPerElt", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected value type", "<STR_LIT>", ")", ";", "assert", "(", "N1", ".", "getValueType", "(", ")", "==", "MVT", "::", "i8", "&&", "<STR_LIT>", "Unexpected shift amount type", "<STR_LIT>", ")", ";", "unsigned", "ShiftVal", "=", "cast", "<", "ConstantSDNode", ">", "(", "N1", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "ShiftVal", ">=", "NumBitsPerElt", ")", "{", "if", "(", "LogicalShift", ")", "return", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ")", ";", "else", "ShiftVal", "=", "NumBitsPerElt", "-", "<NUM_LIT>", ";", "}", "if", "(", "!", "ShiftVal", ")", "return", "N0", ";", "if", "(", "ISD", "::", "isBuildVectorAllZeros", "(", "N0", ".", "getNode", "(", ")", ")", ")", "return", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ")", ";", "if", "(", "Opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "N0", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "unsigned", "ShiftVal2", "=", "cast", "<", "ConstantSDNode", ">", "(", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", "->", "getZExtValue", "(", ")", ";", "unsigned", "NewShiftVal", "=", "ShiftVal", "+", "ShiftVal2", ";", "if", "(", "NewShiftVal", ">=", "NumBitsPerElt", ")", "NewShiftVal", "=", "NumBitsPerElt", "-", "<NUM_LIT>", ";", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "SDLoc", "(", "N", ")", ",", "VT", ",", "N0", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "DAG", ".", "getConstant", "(", "NewShiftVal", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i8", ")", ")", ";", "}", "if", "(", "LogicalShift", "&&", "(", "ShiftVal", "%", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", "{", "SDValue", "Op", "(", "N", ",", "<NUM_LIT>", ")", ";", "if", "(", "SDValue", "Res", "=", "combineX86ShufflesRecursively", "(", "{", "Op", "}", ",", "<NUM_LIT>", ",", "Op", ",", "{", "<NUM_LIT>", "}", ",", "{", "}", ",", "<NUM_LIT>", ",", "false", ",", "true", ",", "DAG", ",", "Subtarget", ")", ")", "return", "Res", ";", "}", "APInt", "UndefElts", ";", "SmallVector", "<", "APInt", ",", "<NUM_LIT>", ">", "EltBits", ";", "if", "(", "N", "->", "isOnlyUserOf", "(", "N0", ".", "getNode", "(", ")", ")", "&&", "getTargetConstantBitsFromNode", "(", "N0", ",", "NumBitsPerElt", ",", "UndefElts", ",", "EltBits", ")", ")", "{", "assert", "(", "EltBits", ".", "size", "(", ")", "==", "VT", ".", "getVectorNumElements", "(", ")", "&&", "<STR_LIT>", "Unexpected shift value type", "<STR_LIT>", ")", ";" ]

[ "}" ]

[ "bits", "<", "<NUM_LIT>", ">", "RST", ";", "bits", "<", "<NUM_LIT>", ">", "B", ";", "bit", "RC", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RST", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "B", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "xo", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "RC", ";" ]

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Base", ")", ")", ";" ]

[ "unsigned", "Base", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Reg", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Reg", ")", ";", "Base", "=", "getReg", "(", "Decoder", ",", "Mips", "::", "GPR32RegClassID", ",", "Base", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "Mips", "::", "SC", "||", "Inst", ".", "getOpcode", "(", ")", "==", "Mips", "::", "SCD", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Reg", ")", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Reg", ")", ")", ";" ]

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

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

[ ")" ]

[ "(", "define_mode_attr", "BOOL_REGS_UNARY", "\t", "[", "(", "TI", "\t", "<STR_LIT>", ")", "(", "PTI", "\t", "<STR_LIT>", ")", "(", "V16QI", "\t", "<STR_LIT>", ")", "(", "V8HI", "\t", "<STR_LIT>" ]

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

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

[ "void", "WebAssemblyDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "<STR_LIT>", "== ", "<STR_LIT>", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ")", ";", "Node", "->", "setNodeId", "(", "-", "<NUM_LIT>", ")", ";", "return", ";", "}", "MVT", "PtrVT", "=", "TLI", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ";", "auto", "GlobalGetIns", "=", "PtrVT", "==", "MVT", "::", "i64", "?", "WebAssembly", "::", "GLOBAL_GET_I64", ":", "WebAssembly", "::", "GLOBAL_GET_I32", ";", "SDLoc", "DL", "(", "Node", ")", ";", "MachineFunction", "&", "MF", "=", "CurDAG", "->", "getMachineFunction", "(", ")", ";", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "ATOMIC_FENCE", ":", "{", "if", "(", "!", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "hasAtomics", "(", ")", ")", "break", ";", "uint64_t", "SyncScopeID", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "MachineSDNode", "*", "Fence", "=", "nullptr", ";", "switch", "(", "SyncScopeID", ")", "{", "case", "SyncScope", "::", "SingleThread", ":", "Fence", "=", "CurDAG", "->", "getMachineNode", "(", "WebAssembly", "::", "COMPILER_FENCE", ",", "DL", ",", "MVT", "::", "Other", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "case", "SyncScope", "::", "System", ":", "Fence", "=", "CurDAG", "->", "getMachineNode", "(", "WebAssembly", "::", "ATOMIC_FENCE", ",", "DL", ",", "MVT", "::", "Other", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "DL", ",", "MVT", "::", "i32", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown scope!", "<STR_LIT>", ")", ";", "}", "ReplaceNode", "(", "Node", ",", "Fence", ")", ";", "CurDAG", "->", "RemoveDeadNode", "(", "Node", ")", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "{", "unsigned", "IntNo", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "wasm_tls_size", ":", "{", "MachineSDNode", "*", "TLSSize", "=", "CurDAG", "->", "getMachineNode", "(", "GlobalGetIns", ",", "DL", ",", "PtrVT", ",", "CurDAG", "->", "getTargetExternalSymbol", "(", "<STR_LIT>", "__tls_size", "<STR_LIT>", ",", "PtrVT", ")", ")", ";", "ReplaceNode", "(", "Node", ",", "TLSSize", ")", ";", "return", ";", "}", "case", "Intrinsic", "::", "wasm_tls_align", ":", "{", "MachineSDNode", "*", "TLSAlign", "=", "CurDAG", "->", "getMachineNode", "(", "GlobalGetIns", ",", "DL", ",", "PtrVT", ",", "CurDAG", "->", "getTargetExternalSymbol", "(", "<STR_LIT>", "__tls_align", "<STR_LIT>", ",", "PtrVT", ")", ")", ";", "ReplaceNode", "(", "Node", ",", "TLSAlign", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "const", "auto", "&", "TLI", "=", "CurDAG", "->", "getTargetLoweringInfo", "(", ")", ";", "MVT", "PtrVT", "=", "TLI", ".", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "wasm_tls_base", ":", "{", "MachineSDNode", "*", "TLSBase", "=", "CurDAG", "->", "getMachineNode", "(", "GlobalGetIns", ",", "DL", ",", "PtrVT", ",", "MVT", "::", "Other", ",", "CurDAG", "->", "getTargetExternalSymbol", "(", "<STR_LIT>", "__tls_base", "<STR_LIT>", ",", "PtrVT", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "ReplaceNode", "(", "Node", ",", "TLSBase", ")", ";", "return", ";", "}", "case", "Intrinsic", "::", "wasm_catch", ":", "{", "int", "Tag", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "SDValue", "SymNode", "=", "getTagSymNode", "(", "Tag", ",", "CurDAG", ")", ";", "MachineSDNode", "*", "Catch", "=", "CurDAG", "->", "getMachineNode", "(", "WebAssembly", "::", "CATCH", ",", "DL", ",", "{", "PtrVT", ",", "MVT", "::", "Other", "}", ",", "{", "SymNode", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ")", ";", "ReplaceNode", "(", "Node", ",", "Catch", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_VOID", ":", "{", "unsigned", "IntNo", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "wasm_throw", ":", "{", "int", "Tag", "=", "Node", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ";", "SDValue", "SymNode", "=", "getTagSymNode", "(", "Tag", ",", "CurDAG", ")", ";", "MachineSDNode", "*", "Throw", "=", "CurDAG", "->", "getMachineNode", "(", "WebAssembly", "::", "THROW", ",", "DL", ",", "MVT", "::", "Other", ",", "{", "SymNode", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", "}", ")", ";", "ReplaceNode", "(", "Node", ",", "Throw", ")", ";", "return", ";", "}", "}", "break", ";", "}", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "{", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Ops", ";", "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "Node", "->", "getNumOperands", "(", ")", ";", "++", "i", ")", "{", "SDValue", "Op", "=", "Node", "->", "getOperand", "(", "i", ")", ";", "if", "(", "i", "==", "<NUM_LIT>", "&&", "Op", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "Op", "=", "Op", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "Ops", ".", "push_back", "(", "Op", ")", ";", "}", "Ops", ".", "push_back", "(", "Node", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MachineSDNode", "*", "CallParams", "=", "CurDAG", "->", "getMachineNode", "(", "WebAssembly", "::", "CALL_PARAMS", ",", "DL", ",", "MVT", "::", "Glue", ",", "Ops", ")", ";", "unsigned", "Results", "=", "Node", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "?", "WebAssembly", "::", "CALL_RESULTS", ":", "WebAssembly", "::", "RET_CALL_RESULTS", ";", "SDValue", "Link", "(", "CallParams", ",", "<NUM_LIT>", ")", ";", "MachineSDNode", "*", "CallResults", "=", "CurDAG", "->", "getMachineNode", "(", "Results", ",", "DL", ",", "Node", "->", "getVTList", "(", ")", ",", "Link", ")", ";", "ReplaceNode", "(", "Node", ",", "CallResults", ")", ";", "return", ";", "}", "default", ":", "break", ";", "}", "SelectCode", "(", "Node", ")", ";", "}" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

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

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

[ "]", ".", "internal_label", ";" ]

[ "if", "(", "deferred_plabels", "==", "<NUM_LIT>", ")", "deferred_plabels", "=", "(", "struct", "deferred_plabel", "*", ")", "ggc_alloc", "(", "sizeof", "(", "struct", "deferred_plabel", ")", ")", ";", "else", "deferred_plabels", "=", "(", "struct", "deferred_plabel", "*", ")", "ggc_realloc", "(", "deferred_plabels", ",", "(", "(", "n_deferred_plabels", "+", "<NUM_LIT>", ")", "*", "sizeof", "(", "struct", "deferred_plabel", ")", ")", ")", ";", "i", "=", "n_deferred_plabels", "++", ";", "deferred_plabels", "[", "i", "]", ".", "internal_label", "=", "gen_label_rtx", "(", ")", ";", "deferred_plabels", "[", "i", "]", ".", "symbol", "=", "symbol", ";", "id", "=", "maybe_get_identifier", "(", "targetm", ".", "strip_name_encoding", "(", "fname", ")", ")", ";", "if", "(", "id", ")", "mark_referenced", "(", "id", ")", ";", "}", "return", "deferred_plabels", "[", "i" ]

[ "}" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "<NUM_LIT>", ";", "}" ]

[ "v4sf", ")", "_", "_", "C", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_fmaddsub_ps", "(", "_", "_", "m128", "_", "_", "A", ",", "_", "_", "m128", "_", "_", "B", ",", "_", "_", "m128", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "builtin_ia32_vfmaddsubps", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "(", "_", "_", "v4sf", ")", "_", "_", "B", ",", "(", "_", "_" ]

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

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

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

[ "if", "(", "RegNo", ">", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "unsigned", "Reg", "=", "CPRegDecoderTable", "[", "RegNo", "]", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createReg", "(", "Reg" ]

[ "amdgcn_struct_ptr_buffer_atomic_umin", ":" ]

[ "case", "Intrinsic", "::", "amdgcn_struct_ptr_buffer_atomic_sub", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_sub", ":", "case", "Intrinsic", "::", "amdgcn_raw_ptr_buffer_atomic_sub", ":", "Op", "=", "AtomicRMWInst", "::", "Sub", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_buffer_atomic_and", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_and", ":", "case", "Intrinsic", "::", "amdgcn_struct_ptr_buffer_atomic_and", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_and", ":", "case", "Intrinsic", "::", "amdgcn_raw_ptr_buffer_atomic_and", ":", "Op", "=", "AtomicRMWInst", "::", "And", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_buffer_atomic_or", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_or", ":", "case", "Intrinsic", "::", "amdgcn_struct_ptr_buffer_atomic_or", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_or", ":", "case", "Intrinsic", "::", "amdgcn_raw_ptr_buffer_atomic_or", ":", "Op", "=", "AtomicRMWInst", "::", "Or", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_buffer_atomic_xor", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_xor", ":", "case", "Intrinsic", "::", "amdgcn_struct_ptr_buffer_atomic_xor", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_xor", ":", "case", "Intrinsic", "::", "amdgcn_raw_ptr_buffer_atomic_xor", ":", "Op", "=", "AtomicRMWInst", "::", "Xor", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_buffer_atomic_smin", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_smin", ":", "case", "Intrinsic", "::", "amdgcn_struct_ptr_buffer_atomic_smin", ":", "case", "Intrinsic", "::", "amdgcn_raw_buffer_atomic_smin", ":", "case", "Intrinsic", "::", "amdgcn_raw_ptr_buffer_atomic_smin", ":", "Op", "=", "AtomicRMWInst", "::", "Min", ";", "break", ";", "case", "Intrinsic", "::", "amdgcn_buffer_atomic_umin", ":", "case", "Intrinsic", "::", "amdgcn_struct_buffer_atomic_umin", ":", "case", "Intrinsic", "::" ]

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

[ "def", "A2_absp", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ")", ",", "<STR_LIT>", ",", "tc_cf8126ae", ",", "TypeS_2op", ">", ",", "Enc_b9c5fb", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

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

[ "assert", "(", "AluMCOp", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Third operator is not immediate.", "<STR_LIT>", ")", ";", "unsigned", "AluOp", "=", "AluMCOp", ".", "getImm", "(", ")", ";", "Encoding", "|=", "LPAC", "::", "encodeLanaiAluCode", "(", "AluOp", ")", "<<", "<NUM_LIT>", ";", "if", "(", "LPAC", "::", "isPreOp", "(", "AluOp", ")", ")", "Encoding", "|=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";", "if", "(", "LPAC", "::", "isPostOp", "(", "AluOp", ")", ")", "Encoding", "|=", "(", "<NUM_LIT>", "<<", "<NUM_LIT>", ")", ";", "switch", "(", "LPAC", "::", "getAluOp" ]

[ "}" ]

[ "SGPRsUsed", ".", "insert", "(", "LastSGPR", ")", ";", "++", "ConstantBusUseCount", ";", "}", "}", "else", "{", "if", "(", "Desc", ".", "OpInfo", "[", "OpIdx", "]", ".", "OperandType", "==", "MCOI", "::", "OPERAND_IMMEDIATE", ")", "continue", ";", "unsigned", "Size", "=", "AMDGPU", "::", "getOperandSize", "(", "Desc", ",", "OpIdx", ")", ";", "if", "(", "Size", "<", "<NUM_LIT>", ")", "Size", "=", "<NUM_LIT>", ";", "if", "(", "NumLiterals", "==", "<NUM_LIT>", ")", "{", "NumLiterals", "=", "<NUM_LIT>", ";", "LiteralSize", "=", "Size", ";", "}", "else", "if", "(", "LiteralSize", "!=", "Size", ")", "{", "NumLiterals", "=", "<NUM_LIT>", ";", "}", "}", "}", "}", "}", "ConstantBusUseCount", "+=", "NumLiterals", ";", "if", "(", "ConstantBusUseCount", "<=", "getConstantBusLimit", "(", "Opcode", ")", ")", "return", "true", ";", "SMLoc", "LitLoc", "=", "getLitLoc", "(", "Operands", ")", ";", "SMLoc", "RegLoc", "=", "getRegLoc", "(", "LastSGPR", ",", "Operands", ")", ";", "SMLoc", "Loc", "=", "(", "LitLoc", ".", "getPointer", "(", ")", "<", "RegLoc", ".", "getPointer", "(", ")", ")", "?", "RegLoc", ":", "LitLoc", ";", "Error", "(", "Loc", ",", "<STR_LIT>", "invalid operand (violates constant bus restrictions)", "<STR_LIT>", ")", ";", "return", "false", ";" ]

[ "break", ";" ]

[ "LowerMemOpCallTo", "(", "DAG", ",", "MF", ",", "Chain", ",", "Arg", ",", "PtrOff", ",", "SPDiff", ",", "ArgOffset", ",", "isPPC64", ",", "isTailCall", ",", "false", ",", "MemOpChains", ",", "TailCallArguments", ",", "dl", ")", ";", "}", "ArgOffset", "+=", "PtrByteSize", ";", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "FPR_idx", "!=", "NumFPRs", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "FPR", "[", "FPR_idx", "++", "]", ",", "Arg", ")", ")", ";", "if", "(", "isVarArg", ")", "{", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Store", ")", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "{", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Store", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "}", "if", "(", "GPR_idx", "!=", "NumGPRs", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", "&&", "!", "isPPC64", ")", "{", "SDValue", "ConstFour", "=", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "PtrOff", ".", "getValueType", "(", ")", ")", ";", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "PtrOff", ",", "ConstFour", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Store", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "}", "}", "else", "{", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "++", "GPR_idx", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", "&&", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f64", "&&", "!", "isPPC64", ")", "++", "GPR_idx", ";", "}", "}", "else", "{", "LowerMemOpCallTo", "(", "DAG", ",", "MF", ",", "Chain", ",", "Arg", ",", "PtrOff", ",", "SPDiff", ",", "ArgOffset", ",", "isPPC64", ",", "isTailCall", ",", "false", ",", "MemOpChains", ",", "TailCallArguments", ",", "dl", ")", ";", "}", "if", "(", "isPPC64", ")", "ArgOffset", "+=", "<NUM_LIT>", ";", "else", "ArgOffset", "+=", "Arg", ".", "getValueType", "(", ")", "==", "MVT", "::", "f32", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v16i8", ":", "if", "(", "isVarArg", ")", "{", "while", "(", "ArgOffset", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "{", "ArgOffset", "+=", "PtrByteSize", ";", "if", "(", "GPR_idx", "!=", "NumGPRs", ")", "GPR_idx", "++", ";", "}", "PtrOff", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "StackPtr", ",", "DAG", ".", "getConstant", "(", "ArgOffset", ",", "PtrVT", ")", ")", ";", "SDValue", "Store", "=", "DAG", ".", "getStore", "(", "Chain", ",", "dl", ",", "Arg", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Store", ")", ";", "if", "(", "VR_idx", "!=", "NumVRs", ")", "{", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "MVT", "::", "v4f32", ",", "dl", ",", "Store", ",", "PtrOff", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VR", "[", "VR_idx", "++", "]", ",", "Load", ")", ")", ";", "}", "ArgOffset", "+=", "<NUM_LIT>", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "i", "+=", "PtrByteSize", ")", "{", "if", "(", "GPR_idx", "==", "NumGPRs", ")", "break", ";", "SDValue", "Ix", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "PtrOff", ",", "DAG", ".", "getConstant", "(", "i", ",", "PtrVT", ")", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "Store", ",", "Ix", ",", "NULL", ",", "<NUM_LIT>", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "MemOpChains", ".", "push_back", "(", "Load", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "GPR", "[", "GPR_idx", "++", "]", ",", "Load", ")", ")", ";", "}", "break", ";", "}", "if", "(", "VR_idx", "!=", "NumVRs", ")", "{", "RegsToPass", ".", "push_back", "(", "std", "::", "make_pair", "(", "VR", "[", "VR_idx", "++", "]", ",", "Arg", ")", ")", ";", "}", "else", "if", "(", "nAltivecParamsAtEnd", "==", "<NUM_LIT>", ")", "{", "LowerMemOpCallTo", "(", "DAG", ",", "MF", ",", "Chain", ",", "Arg", ",", "PtrOff", ",", "SPDiff", ",", "ArgOffset", ",", "isPPC64", ",", "isTailCall", ",", "true", ",", "MemOpChains", ",", "TailCallArguments", ",", "dl", ")", ";", "ArgOffset", "+=", "<NUM_LIT>", ";", "}" ]

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

[ "if", "(", "!", "TARGET_ADJUST_UNROLL", ")", "return", "nunroll", ";", "subrtx_iterator", "::", "array_type", "array", ";", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "NONCONST", ")", "if", "(", "const_rtx", "x", "=", "*", "iter", ")", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "unsigned", "int", "n_words", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "n_words", ">", "<NUM_LIT>", ")", "mem_count", "+=", "<NUM_LIT>", ";", "else", "mem_count" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeGETD", "(", "insn", ")", ";" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeBEQI", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeBR", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeBRI", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeBSRL", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeBSRLI", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeRSUBK", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeFADD", "(", "insn", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "return", "decodeGET", "(", "insn", ")", ";" ]

[ "std", "::", "fill", "(", "SMask", ".", "begin", "(", ")", "+", "CurSize", ",", "SMask", ".", "end", "(", ")", ",", "CurSize", ")", ";" ]

[ "assert", "(", "isa", "<", "VectorType", ">", "(", "Val", "->", "getType", "(", ")", ")", ")", ";", "auto", "*", "ValTy", "=", "cast", "<", "VectorType", ">", "(", "Val", "->", "getType", "(", ")", ")", ";", "assert", "(", "ValTy", "->", "getElementType", "(", ")", "==", "Pad", "->", "getType", "(", ")", ")", ";", "int", "CurSize", "=", "length", "(", "ValTy", ")", ";", "if", "(", "CurSize", "==", "NewSize", ")", "return", "Val", ";", "if", "(", "CurSize", ">", "NewSize", ")", "return", "getElementRange", "(", "Builder", ",", "Val", ",", "Val", ",", "<NUM_LIT>", ",", "NewSize", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "SMask", "(", "NewSize", ")", ";", "std", "::", "iota", "(", "SMask", ".", "begin", "(", ")", ",", "SMask", ".", "begin", "(", ")", "+", "CurSize", ",", "<NUM_LIT>", ")", ";" ]

[ "let", "MIOperandInfo", "=", "(", "ops", "i8imm", ":", "$", "datatype", ")", ";" ]

[ "let", "ParserMatchClass", "=", "DataTypeAsmOperand", ";", "let", "OperandType", "=", "<STR_LIT>", ";" ]

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

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

[ "=", "&", "*", "UI", ";" ]

[ "static", "bool", "isDefBetween", "(", "unsigned", "Reg", ",", "SlotIndex", "First", ",", "SlotIndex", "Last", ",", "const", "MachineRegisterInfo", "*", "MRI", ",", "const", "LiveIntervals", "*", "LIS", ")", "{", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "UI", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "UE", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "UI", "!=", "UE", ";", "++", "UI", ")", "{", "const", "MachineInstr", "*", "MI" ]

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

[ "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isIndirectBranch", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "InputType", "=", "<STR_LIT>", ";" ]

[ ")", ")" ]

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

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

[ "static", "bool", "TruncSizeCompatible", "(", "int", "TruncSize", ",", "unsigned", "opcode", ")", "{", "if", "(", "TruncSize", "==", "<NUM_LIT>", ")", "return", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TruncSize", "==", "<NUM_LIT>", ")", "return", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "TruncSize", "==", "<NUM_LIT>", ")", "return", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "opcode", "==", "<STR_LIT>", "::", "<STR_LIT>", ";" ]