Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "<FIXS>", "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "mult", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "HI", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "mult", ":", "HI", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "HI", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "mult", ":", "HI", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "define_expand", "<STR_LIT>", "[", "(", "parallel", "[", "(", "set", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mult", ":", "TI", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", ")", "]", "<STR_LIT>", "<STR_LIT>", ")", "(", "define_insn", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "mult", ":", "TI", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "mult", ":", "QI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "mult", ":", "HI", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "zero_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "mult", ":", "HI", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "sign_extend", ":", "HI", "(", "match_operand", ":", "QI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGS>", "(", "mult", ":", "TI", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "<BUGE>", "(", "zero_extend", ":", "TI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

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

[ "def", ":", "SIMDInsMainMovAlias", "<", "<STR_LIT>", ",", "!", "cast", "<", "Instruction", ">", "(", "NAME", "#" ]

[ "<FIXS>", "unsigned", "AArch64FastISel", "::", "emitLogicalOp", "(", "unsigned", "ISDOpc", ",", "MVT", "RetVT", ",", "const", "Value", "*", "LHS", ",", "const", "Value", "*", "RHS", ")", "{", "if", "(", "RetVT", "!=", "MVT", "::", "i32", "&&", "RetVT", "!=", "MVT", "::", "i64", ")", "return", "<NUM_LIT>", ";", "if", "(", "isa", "ConstantInt", ">", "(", "LHS", ")", "&&", "!", "isa", "ConstantInt", ">", "(", "RHS", ")", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "if", "(", "isValueAvailable", "(", "LHS", ")", ")", "if", "(", "const", "auto", "*", "SI", "=", "dyn_cast", "BinaryOperator", ">", "(", "LHS", ")", ")", "if", "(", "isa", "ConstantInt", ">", "(", "SI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "if", "(", "SI", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "unsigned", "LHSReg", "=", "getRegForValue", "(", "LHS", ")", ";", "if", "(", "!", "LHSReg", ")", "return", "<NUM_LIT>", ";", "bool", "LHSIsKill", "=", "hasTrivialKill", "(", "LHS", ")", ";", "unsigned", "ResultReg", "=", "<NUM_LIT>", ";", "if", "(", "const", "auto", "*", "C", "=", "dyn_cast", "ConstantInt", ">", "(", "RHS", ")", ")", "{", "uint64_t", "Imm", "=", "C", "->", "getZExtValue", "(", ")", ";", "ResultReg", "=", "emitLogicalOp_ri", "(", "ISDOpc", ",", "RetVT", ",", "LHSReg", ",", "LHSIsKill", ",", "Imm", ")", ";", "}", "if", "(", "ResultReg", ")", "return", "ResultReg", ";", "if", "(", "isValueAvailable", "(", "RHS", ")", ")", "if", "(", "const", "auto", "*", "SI", "=", "dyn_cast", "BinaryOperator", ">", "(", "RHS", ")", ")", "if", "(", "const", "auto", "*", "C", "=", "dyn_cast", "ConstantInt", ">", "(", "SI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "if", "(", "SI", "->", "getOpcode", "(", ")", "==", "Instruction", "::", "Shl", ")", "{", "uint64_t", "ShiftVal", "=", "C", "->", "getZExtValue", "(", ")", ";", "unsigned", "RHSReg", "=", "getRegForValue", "(", "SI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "RHSReg", ")", "return", "<NUM_LIT>", ";", "bool", "RHSIsKill", "=", "hasTrivialKill", "(", "SI", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "return", "emitLogicalOp_rs", "(", "ISDOpc", ",", "RetVT", ",", "LHSReg", ",", "LHSIsKill", ",", "RHSReg", ",", "RHSIsKill", ",", "ShiftVal", ")", ";", "}", "unsigned", "RHSReg", "=", "getRegForValue", "(", "RHS", ")", ";", "if", "(", "!", "RHSReg", ")", "return", "<NUM_LIT>", ";", "bool", "RHSIsKill", "=", "hasTrivialKill", "(", "RHS", ")", ";", "return", "fastEmit_rr", "(", "RetVT", ",", "RetVT", ",", "ISDOpc", ",", "LHSReg", ",", "LHSIsKill", ",", "RHSReg", ",", "RHSIsKill", ")", ";", "}", "unsigned", "AArch64FastISel", "::", "emitLogicalOp_ri", "(", "unsigned", "ISDOpc", ",", "MVT", "RetVT", ",", "unsigned", "LHSReg", ",", "bool", "LHSIsKill", ",", "uint64_t", "Imm", ")", "{", "assert", "(", "(", "ISD", "::", "AND", "+", "<NUM_LIT>", "==", "ISD", "::", "OR", ")", "&&", "(", "ISD", "::", "AND", "+", "<NUM_LIT>", "==", "ISD", "::", "XOR", ")", "&&", "<STR_LIT>", "ISD nodes are not consecutive!", "<STR_LIT>", ")", ";", "static", "const", "unsigned", "OpcTable", "[", "<NUM_LIT>", "]", "[", "<NUM_LIT>", "]", "=", "{", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", ",", "{", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", "}", "}", ";", "const", "TargetRegisterClass", "*", "RC", ";", "unsigned", "Opc", ";", "unsigned", "RegSize", ";", "<FIXE>", "<FIXS>", "case", "MVT", "::", "i32", ":", "{", "unsigned", "Idx", "=", "ISDOpc", "-", "ISD", "::", "AND", ";", "Opc", "=", "OpcTable", "[", "Idx", "]", "[", "<NUM_LIT>", "]", ";", "<FIXE>", "<FIXS>", "Opc", "=", "OpcTable", "[", "ISDOpc", "-", "ISD", "::", "AND", "]", "[", "<NUM_LIT>", "]", ";", "<FIXE>" ]

[ "WantResult", ")", ";", "}", "<BUGS>", "unsigned", "AArch64FastISel", "::", "emitAND_ri", "(", "MVT", "RetVT", ",", "unsigned", "LHSReg", ",", "bool", "LHSIsKill", ",", "uint64_t", "Imm", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "unsigned", "Opc", "=", "<NUM_LIT>", ";", "unsigned", "RegSize", "=", "<NUM_LIT>", ";", "<BUGE>", "switch", "(", "RetVT", ".", "SimpleTy", ")", "{", "default", ":", "return", "<NUM_LIT>", ";", "<BUGS>", "case", "MVT", "::", "i32", ":", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGE>", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "RegSize", "=", "<NUM_LIT>", ";", "break", ";", "case", "MVT", "::", "i64", ":", "<BUGS>", "Opc", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "<BUGE>", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "RegSize", "=", "<NUM_LIT>", ";", "break", ";" ]

[ "let", "isCompare", "=", "<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", "isFP", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "USR", "]", ";" ]

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

[ "return", "false", ";", "}", "if", "(", "Opc", "==", "Hexagon", "::", "A2_andir", "&&", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "isImm", "(", ")", ")", "{", "int32_t", "Imm", "=", "MI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "isInt", "<", "<NUM_LIT>", ">", "(", "Imm", ")", ")", "return", "false", ";", "}", "if", "(", "MI", "->", "hasUnmodeledSideEffects", "(", ")", "||", "MI", "->", "isInlineAsm", "(", ")", ")", "return", "false", ";", "unsigned", "W", "=", "RC", ".", "width", "(", ")", ";", "while", "(", "W", ">", "<NUM_LIT>", "&&", "RC", "[", "W", "-", "<NUM_LIT>", "]", ".", "is", "(", "<NUM_LIT>", ")", ")", "W", "--", ";", "if", "(", "W", "==", "<NUM_LIT>", "||", "W", "==", "RC", ".", "width", "(", ")", ")", "return", "false", ";", "unsigned", "NewOpc", "=", "(", "W", "==", "<NUM_LIT>", ")", "?", "Hexagon", "::", "A2_zxtb", ":", "(", "W", "==", "<NUM_LIT>", ")", "?", "Hexagon", "::", "A2_zxth", ":", "(", "W", "<", "<NUM_LIT>", ")", "?", "Hexagon", "::", "A2_andir", ":", "Hexagon", "::", "S2_extractu", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "for", "(", "auto", "&", "Op", ":", "MI", "->", "uses", "(", ")", ")", "{", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "BitTracker", "::", "RegisterRef", "RS", "=", "Op", ";", "if", "(", "!", "BT", ".", "has", "(", "RS", ".", "Reg", ")", ")", "continue", ";", "const", "BitTracker", "::", "RegisterCell", "&", "SC", "=", "BT", ".", "lookup", "(", "RS", ".", "Reg", ")", ";", "unsigned", "BN", ",", "BW", ";", "if", "(", "!", "HBS", "::", "getSubregMask", "(", "RS", ",", "BN", ",", "BW", ",", "MRI", ")", ")", "continue", ";", "if", "(", "BW", "<", "W", "||", "!", "HBS", "::", "isEqual", "(", "RC", ",", "<NUM_LIT>", ",", "SC", ",", "BN", ",", "W", ")", ")", "continue", ";", "if", "(", "!", "validateReg", "(", "RS", ",", "NewOpc", ",", "<NUM_LIT>", ")", ")", "continue", ";", "Register", "NewR", "=", "MRI", ".", "createVirtualRegister", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "auto", "At", "=", "MI", "->", "isPHI", "(", ")", "?", "B", ".", "getFirstNonPHI", "(", ")", ":", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ";", "auto", "MIB", "=", "BuildMI", "(", "B", ",", "At", ",", "DL", ",", "HII", ".", "get", "(", "NewOpc", ")", ",", "NewR", ")", ".", "addReg", "(", "RS", ".", "Reg", ",", "<NUM_LIT>", ",", "RS", ".", "Sub", ")", ";", "if", "(", "NewOpc", "==", "Hexagon", "::", "A2_andir", ")", "MIB", ".", "addImm", "(", "(", "<NUM_LIT>", "<<", "W", ")", "-", "<NUM_LIT>", ")", ";", "else", "if", "(", "NewOpc", "==", "Hexagon", "::", "S2_extractu", ")", "MIB", ".", "addImm", "(", "W", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "HBS", "::", "replaceSubWithSub", "(", "RD", ".", "Reg", ",", "RD", ".", "Sub", ",", "NewR", ",", "<NUM_LIT>", ",", "MRI", ")", ";", "BT", ".", "put", "(", "BitTracker", "::", "RegisterRef", "(", "NewR" ]

[ "Sched", "<", "[", "WriteVST4", "]", ">", ";" ]

[ "def", "VST2q32Pseudo", ":", "VSTQQPseudo", "<", "IIC_VST2x2", ">", "," ]

[ "let", "isNewValue", "=", "<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", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";" ]

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

[ "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "(", "elt", "=", "tree_to_uhwi", "(", "arg", ")", ",", "elt", ">", "max", ")", ")", "{", "error", "(", "<STR_LIT>", "selector must be an integer constant in the range 0..%wi", "<STR_LIT>" ]

[ ",", "_", "_", "artificial__", ")", ")", "_", "mm_castps_ph", "(", "_", "_", "m128", "_", "_", "a", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__" ]

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

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

[ "COND_NO", ";" ]

[ "case", "X86", "::", "JNE_1", ":", "return", "X86", "::", "COND_NE", ";", "case", "X86", "::", "JL_1", ":", "return", "X86", "::", "COND_L", ";", "case", "X86", "::", "JLE_1", ":", "return", "X86", "::", "COND_LE", ";", "case", "X86", "::", "JG_1", ":", "return", "X86", "::", "COND_G", ";", "case", "X86", "::", "JGE_1", ":", "return", "X86", "::", "COND_GE", ";", "case", "X86", "::", "JB_1", ":", "return", "X86", "::", "COND_B", ";", "case", "X86", "::", "JBE_1", ":", "return", "X86", "::", "COND_BE", ";", "case", "X86", "::", "JA_1", ":", "return", "X86", "::", "COND_A", ";", "case", "X86", "::", "JAE_1", ":", "return", "X86", "::", "COND_AE", ";", "case", "X86", "::", "JS_1", ":", "return", "X86", "::", "COND_S", ";", "case", "X86", "::", "JNS_1", ":", "return", "X86", "::", "COND_NS", ";", "case", "X86", "::", "JP_1", ":", "return", "X86", "::", "COND_P", ";", "case", "X86", "::", "JNP_1", ":", "return", "X86", "::", "COND_NP", ";", "case", "X86", "::", "JO_1", ":", "return", "X86", "::", "COND_O", ";", "case", "X86", "::", "JNO_1", ":", "return", "X86", "::" ]

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

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

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

[ "SDLoc", "DL", "(", "N", ")", ";", "EVT", "VT", "=", "N", "->", "getValueType", "(", "<NUM_LIT>", ")", ";", "SDValue", "Val", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "EVT", "ValVT", "=", "Val", ".", "getValueType", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i24", "&&", "ValVT", "==", "MVT", "::", "i16", ")", "{", "if", "(", "SDValue", "Res", "=", "implicitlyClearTop" ]

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

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "F", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", ":", "F" ]

[ "bool", "M88kMCAsmBackend", "::", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "{", "return", "Fixup", ".", "getKind", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "Fixup", ".", "getKind", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "MIB", ".", "addReg", "(", "CodeSourceRegister", ")", ";" ]

[ "const", "DebugLoc", "&", "DL", "=", "MergeBB", "->", "findDebugLoc", "(", "MergeBB", "->", "begin", "(", ")", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MergeBB", ",", "MergeBB", "->", "instr_begin", "(", ")", ",", "DL", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "PHI", ")", ",", "DestRegister", ")", ";", "if", "(", "IsUndefIfSource", "&&", "false", ")", "{", "MIB", ".", "addReg", "(", "IfSourceRegister", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "{", "MIB", ".", "addReg", "(", "IfSourceRegister", ")", ";", "}", "MIB", ".", "addMBB", "(", "IfBB", ")", ";" ]

[ ">", ";" ]

[ "def", "X86cvtpd2IntRnd", ":", "SDNode", "<", "<STR_LIT>", ",", "SDTDoubleToIntRnd" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "<STR_LIT>", "<FIXE>", "<FIXS>", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "<FIXE>", "<FIXS>", "&", "&", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "SImode", "|", "|", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "HImode", "|", "|", "(", "TARGET_64BIT", "&", "&", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "DImode", ")", ")", "<STR_LIT>", "register_operand", "<STR_LIT>", "<STR_LIT>", "<FIXE>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "(", "define_split", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "and", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "<BUGE>", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "strict_low_part", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "q_regs_operand", "<STR_LIT>", "<STR_LIT>", "(", "optimize_size", "|", "|", "!", "TARGET_PARTIAL_REG_STALL", ")", "<BUGS>", "&", "&", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "SImode", "|", "|", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "=", "=", "HImode", ")", "<STR_LIT>", "operands", "[", "<NUM_LIT>", "]", "=", "gen_lowpart", "(", "QImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "(", "define_split", "<BUGS>", "[", "(", "set", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "and", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<BUGE>", "[", "(", "parallel", "[", "(", "set", "(", "zero_extract", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")" ]

[ ")", "_", "mm256_setzero_si256", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_cvt_roundpd_epi32", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "const", "int", "_", "_", "R", ")", "{", "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_cvtpd2dq512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8si" ]

[ "}" ]

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

[ ":", "$", "val", ",", "(", "v8i16", "VECREG", ":", "$", "rA", ")", ")", ")", "]", ">", ";" ]

[ "def", "SFHIvec", ":", "RI10Form", "<", "<NUM_LIT>", ",", "(", "outs", "VECREG", ":", "$", "rT", ")", ",", "(", "ins", "VECREG", ":", "$", "rA", ",", "s10imm", ":", "$", "val", ")", ",", "<STR_LIT>", ",", "IntegerOp", ",", "[", "(", "set", "(", "v8i16", "VECREG", ":", "$", "rT", ")", ",", "(", "sub", "v8i16SExt10Imm" ]

[ "}" ]

[ "const", "X86RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "SDValue", "Offset", "=", "DAG", ".", "getConstant", "(", "RegInfo", "->", "getSlotSize", "(", ")", ",", "dl", ",", "PtrVT", ")", ";", "return", "DAG", ".", "getLoad", "(", "PtrVT", ",", "dl", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "DAG", ".", "getNode", "(", "ISD", "::", "ADD", ",", "dl", ",", "PtrVT", ",", "FrameAddr", ",", "Offset", ")", ",", "MachinePointerInfo", "(", ")", ")", ";" ]

[ "cum", "->", "call_abi", ":", "ix86_abi", ";" ]

[ "}", "else", "{", "gcc_assert", "(", "cfun", "->", "machine", "->", "func_type", "==", "TYPE_EXCEPTION", "&&", "TREE_CODE", "(", "type", ")", "==", "INTEGER_TYPE", "&&", "TYPE_MODE", "(", "type", ")", "==", "word_mode", ")", ";", "arg", "=", "gen_rtx_MEM", "(", "word_mode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "-", "UNITS_PER_WORD", ")", ")", ";", "}", "return", "arg", ";", "}", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "cum", "->", "bnds_in_bt", ")", "arg", "=", "NULL", ";", "else", "if", "(", "cum", "->", "bnd_regno", "<=", "LAST_BND_REG", ")", "arg", "=", "gen_rtx_REG", "(", "BNDmode", ",", "cum", "->", "bnd_regno", ")", ";", "else", "arg", "=", "GEN_INT", "(", "cum", "->", "bnd_regno", "-", "LAST_BND_REG", "-", "<NUM_LIT>", ")", ";", "return", "arg", ";", "}", "if", "(", "mode", "==", "BLKmode", ")", "bytes", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "CEIL", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "mode", "=", "type_natural_mode", "(", "type", ",", "cum", ",", "false", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?" ]

[ "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>", ":", "DecodeDDDRegisterClass", "(", "Inst", ",", "Rt", ",", "Addr", ",", "Decoder", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeQQQRegisterClass", "(", "Inst", ",", "Rt", ",", "Addr", ",", "Decoder", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeDDDDRegisterClass", "(", "Inst", ",", "Rt", ",", "Addr", ",", "Decoder", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "DecodeQQQQRegisterClass", "(", "Inst", ",", "Rt", ",", "Addr", ",", "Decoder", ")", ";", "break", ";", "}", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "default", ":", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "index", ")", ")", ";", "}", "DecodeGPR64spRegisterClass", "(", "Inst", ",", "Rn", ",", "Addr", ",", "Decoder", ")", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "::", "CALL_INDIRECT_EXCEPT_REF", ":" ]

[ "case", "WebAssembly", "::", "CALL_INDIRECT_F64", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v16i8", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v8i16", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v4i32", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v2i64", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v4f32", ":", "case", "WebAssembly", "::", "CALL_INDIRECT_v2f64", ":", "case", "WebAssembly" ]

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

[ "rtx", "insn", "if", "(", "TARGET_INLINE_SQRT", "=", "=", "INL_MIN_LAT", ")", "insn", "=", "gen_sqrtsf2_internal_lat", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[" ]

[ "Builder", ".", "buildBrIndirect", "(", "Builder", ".", "buildMerge", "(", "LLT", "::", "pointer", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "{", "LoAddr", ",", "HiAddr", "}", ")", ".", "getReg", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "Register", "LoAddr", "=", "MRI", ".", "createGenericVirtualRegister", "(", "S8", ")", ";", "Builder", ".", "buildInstr", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addDef", "(", "LoAddr", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "addUse", "(", "Offset", ")", ";", "Register", "HiAddr", "=", "MRI", ".", "createGenericVirtualRegister", "(", "S8", ")", ";", "Builder", ".", "buildInstr", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addDef", "(", "HiAddr", ")", ".", "addJumpTableIndex", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getIndex", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addUse", "(", "Offset", ")", ";" ]

[ "<FIXS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<FIXE>", "<FIXS>", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "<FIXE>" ]

[ "(", "clobber", "(", "reg", ":", "CC", "<NUM_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGE>", "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "if_then_else", ":", "SI", "<BUGS>", "(", "match_operator", "<NUM_LIT>", "<STR_LIT>", "<BUGE>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operator", ":", "SI", "<NUM_LIT>", "<STR_LIT>" ]

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

[ "return", "(", "int", ")", "_", "_", "builtin_c6x_add4", "(", "(", "_", "_", "uv4qi", ")", "src1", ",", "(", "_", "_", "uv4qi" ]

[ "SDValue", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ",", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "<NUM_LIT>", ">", "RVLocs", ";", "MipsCCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "const", "ExternalSymbolSDNode", "*", "ES", "=", "dyn_cast_or_null", "<", "const", "ExternalSymbolSDNode", ">", "(", "CLI", ".", "Callee", ".", "getNode", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_Mips", ",", "CLI", ".", "RetTy", ",", "ES", "?", "ES", "->", "getSymbol", "(", ")", ":", "nullptr", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "<STR_LIT>", "Can only return in registers!", "<STR_LIT>", ")", ";", "SDValue", "Val", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "DL", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getLocVT", "(", ")", ",", "InFlag", ")", ";", "Chain", "=", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "InFlag", "=", "Val", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "if", "(", "VA", ".", "isUpperBitsInLoc", "(", ")", ")", "{", "unsigned", "ValSizeInBits", "=", "Ins", "[", "i", "]", ".", "ArgVT", ".", "getSizeInBits", "(", ")", ";", "unsigned", "LocSizeInBits", "=", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ";", "unsigned", "Shift", "=", "VA", ".", "getLocInfo", "(", ")", "==", "CCValAssign", "::", "ZExtUpper", "?", "ISD", "::", "SRL", ":", "ISD", "::", "SRA", ";", "Val", "=", "DAG", ".", "getNode", "(", "Shift", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getConstant", "(", "LocSizeInBits", "-", "ValSizeInBits", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown loc info!", "<STR_LIT>", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "case", "CCValAssign", "::", "AExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "case", "CCValAssign", "::", "ZExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertZext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "SExtUpper", ":", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AssertSext", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "Val", ",", "DAG", ".", "getValueType", "(", "VA", ".", "getValVT", "(", ")", ")", ")", ";", "Val", "=", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "VA", ".", "getValVT", "(", ")", ",", "Val", ")", ";", "break", ";", "}", "InVals", ".", "push_back", "(", "Val", ")", ";", "}", "return", "Chain", ";", "}" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ ", #-", "<STR_LIT>", "<<", "-", "OffImm", ";" ]

[ "}", "O", "<<", "<STR_LIT>", "[", "<STR_LIT>", "<<", "getRegisterName", "(", "MO1", ".", "getReg", "(", ")", ")", ";", "int32_t", "OffImm", "=", "(", "int32_t", ")", "MO2", ".", "getImm", "(", ")", ";", "bool", "isSub", "=", "OffImm", "<", "<NUM_LIT>", ";", "if", "(", "OffImm", "==", "INT32_MIN", ")", "OffImm", "=", "<NUM_LIT>", ";", "if", "(", "isSub", ")", "O", "<<", "<STR_LIT>" ]

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

[ "unsigned", "Rd", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "imm", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "shift", "=", "fieldFromInstruction", "(", "insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "shift", "<<=", "<NUM_LIT>", ";", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "Fail", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "if", "(", "shift", "&", "(", "<NUM_LIT>", "U", "<<", "<NUM_LIT>", ")", ")", "return", "Fail", ";", "DecodeGPR32RegisterClass", "(", "Inst", ",", "Rd", ",", "Addr", ",", "Decoder", ")", ";", "break", ";" ]

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

[ "let", "MIOperandInfo", "=", "(", "ops", "dispSPE8", ":", "$", "imm", ",", "ptr_rc_nor0", ":", "$", "reg", ")", ";", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";" ]

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

[ "def", "ADJCALLSTACKUP", ":", "Pseudo", "<", "(", "outs", ")", ",", "(", "ins", "i32imm", ":", "$", "amt1", ",", "i32imm", ":", "$", "amt2", ")", ",", "[", "(", "AArch64callseq_end", "timm", ":", "$", "amt1", ",", "timm", ":", "$", "amt2" ]

[ "]", ")" ]

[ "(", "define_mode_iterator", "VS", "[", "V2SI", "V4SI" ]

[ "static", "void", "record_memory_reference", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_itanium_class", "insn_class", "=", "ia64_safe_itanium_class", "(", "insn", ")", ";", "switch", "(", "insn_class", ")", "{", "case", "ITANIUM_CLASS_FLD", ":", "case", "ITANIUM_CLASS_LD", ":", "mem_ops_in_group", "[", "current_cycle", "%", "<NUM_LIT>", "]", "++", ";", "break", ";", "case", "ITANIUM_CLASS_STF", ":", "case", "ITANIUM_CLASS_ST", ":", "mem_ops_in_group", "[", "(", "current_cycle", "+", "<NUM_LIT>", ")", "%", "<NUM_LIT>", "]", "++", ";", "break", ";", "default", ":", ";", "}", "}" ]

[ "If", "INSN", "is", "a", "memory", "reference", ",", "memoize", "it", "in", "MEM_OPS_IN_GROUP", "global", "array", "(", "taking", "account", "for", "3-cycle", "cache", "reference", "postponing", "for", "stores", ":", "Intel", "Itanium", "2", "Reference", "Manual", "for", "Software", "Development", "and", "Optimization", ",", "6.7.3.1", ")", "." ]

[ "let", "opExtentBits", "=", "<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", "CextOpcode", "=", "<STR_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "isCompare", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "printRegName", "(", "O", ",", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "+", "<NUM_LIT>", ")", ";" ]

[ "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";", "printRegName", "(", "O", ",", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", "+", "<NUM_LIT>", ")", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", ";" ]

[ "void", "TLCS900RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "<NUM_LIT>", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "<NUM_LIT>", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "<NUM_LIT>", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "}" ]

[ "def", "imm_arith6", ":", "Operand", "<", "i16", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";" ]

[ "break", ";" ]

[ "case", "'", "a", "'", ":", "case", "'", "b", "'", ":", "case", "'", "c", "'", ":", "case", "'", "d", "'", ":", "case", "'", "S", "'", ":", "case", "'", "D", "'", ":", "case", "'", "A", "'", ":", "if", "(", "CallOperandVal", "->", "getType", "(", ")", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'", "f", "'", ":", "case", "'", "t", "'", ":", "case", "'", "u", "'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'", "y", "'", ":", "if", "(", "type", "->", "isX86_MMXTy", "(", ")", "&&", "Subtarget", "->", "hasMMX", "(", ")", ")", "weight", "=", "CW_SpecificReg", ";", "break", ";", "case", "'", "x", "'", ":", "case", "'", "Y", "'", ":", "if", "(", "(", "type", "->", "getPrimitiveSizeInBits", "(", ")", "==", "<NUM_LIT>", ")", "&&", "Subtarget", "->", "hasXMM", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'", "I", "'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "info", ".", "CallOperandVal", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "<NUM_LIT>", ")", "weight", "=", "CW_Constant", ";", "}", "break", ";", "case", "'", "J", "'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "<NUM_LIT>", ")", "weight", "=", "CW_Constant", ";", "}", "break", ";", "case", "'", "K", "'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "{", "if", "(", "(", "C", "->", "getSExtValue", "(", ")", ">=", "-", "<NUM_LIT>", ")", "&&", "(", "C", "->", "getSExtValue", "(", ")", "<=", "<NUM_LIT>", ")", ")", "weight", "=", "CW_Constant", ";", "}", "break", ";", "case", "'", "L", "'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "{", "if", "(", "(", "C", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", "||", "(", "C", "->", "getZExtValue", "(", ")", "==", "<NUM_LIT>", ")", ")", "weight", "=", "CW_Constant", ";", "}", "break", ";", "case", "'", "M", "'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "<NUM_LIT>", ")", "weight", "=", "CW_Constant", ";", "}", "break", ";", "case", "'", "N", "'", ":", "if", "(", "ConstantInt", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "<=", "<NUM_LIT>", ")", "weight", "=", "CW_Constant", ";", "}" ]

[ "<FIXS>", "boolMipsELFObjectWriter", "::", "needsRelocateWithSymbol", "(", "unsigned", "Type", ")", "const", "{", "switch", "(", "Type", ")", "{", "default", ":", "return", "true", ";", "case", "ELF", "::", "R_MIPS_26", ":", "case", "ELF", "::", "R_MIPS_LO16", ":", "case", "ELF", "::", "R_MIPS_HI16", ":", "case", "ELF", "::", "R_MIPS_32", ":", "case", "ELF", "::", "R_MIPS_64", ":", "case", "ELF", "::", "R_MIPS_GPREL16", ":", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "<FIXE>" ]

[ "return", "Type", ";", "}", "<BUGS>", "static", "bool", "NeedsMatchingLo", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "RelEntry", "&", "R", ")", "{", "if", "(", "!", "R", ".", "Sym", ")", "return", "false", ";", "MCSymbolData", "&", "SD", "=", "Asm", ".", "getSymbolData", "(", "R", ".", "Sym", "->", "AliasedSymbol", "(", ")", ")", ";", "return", "(", "(", "R", ".", "Reloc", ".", "Type", "==", "ELF", "::", "R_MIPS_GOT16", ")", "&&", "!", "SD", ".", "isExternal", "(", ")", ")", "||", "(", "R", ".", "Reloc", ".", "Type", "==", "ELF", "::", "R_MIPS_HI16", ")", ";", "}", "static", "bool", "HasMatchingLo", "(", "const", "MCAssembler", "&", "Asm", ",", "RelLsIter", "I", ",", "RelLsIter", "Last", ")", "{", "if", "(", "I", "==", "Last", ")", "<BUGE>", "return", "false", ";", "<BUGS>", "RelLsIter", "Hi", "=", "I", "++", ";", "return", "(", "I", "->", "Reloc", ".", "Type", "==", "ELF", "::", "R_MIPS_LO16", ")", "&&", "(", "Hi", "->", "Sym", "==", "I", "->", "Sym", ")", "&&", "(", "Hi", "->", "Offset", "==", "I", "->", "Offset", ")", ";", "}", "static", "bool", "HasSameSymbol", "(", "const", "RelEntry", "&", "R0", ",", "const", "RelEntry", "&", "R1", ")", "{", "return", "R0", ".", "Sym", "==", "R1", ".", "Sym", ";", "}", "static", "int", "CompareOffset", "(", "const", "RelEntry", "&", "R0", ",", "const", "RelEntry", "&", "R1", ")", "{", "return", "(", "R0", ".", "Offset", ">", "R1", ".", "Offset", ")", "?", "<NUM_LIT>", ":", "(", "(", "R0", ".", "Offset", "==", "R1", ".", "Offset", ")", "?", "<NUM_LIT>", ":", "-", "<NUM_LIT>", ")", ";", "}", "void", "MipsELFObjectWriter", "::", "sortRelocs", "(", "const", "MCAssembler", "&", "Asm", ",", "std", "::", "vector", "ELFRelocationEntry", ">", "&", "Relocs", ")", "{", "MCELFObjectTargetWriter", "::", "sortRelocs", "(", "Asm", ",", "Relocs", ")", ";", "RelLs", "RelocLs", ";", "std", "::", "vector", "RelLsIter", ">", "Unmatched", ";", "for", "(", "std", "::", "vector", "ELFRelocationEntry", ">", "::", "reverse_iterator", "R", "=", "Relocs", ".", "rbegin", "(", ")", ";", "R", "!=", "Relocs", ".", "rend", "(", ")", ";", "++", "R", ")", "{", "std", "::", "pair", "const", "MCSymbolRefExpr", "*", ",", "int64_t", ">", "P", "=", "MipsGetSymAndOffset", "(", "*", "R", "->", "Fixup", ")", ";", "RelocLs", ".", "push_back", "(", "RelEntry", "(", "*", "R", ",", "P", ".", "first", "?", "&", "P", ".", "first", "->", "getSymbol", "(", ")", ":", "<NUM_LIT>", ",", "P", ".", "second", ")", ")", ";", "<BUGE>", "}", "<BUGS>", "for", "(", "RelLsIter", "R", "=", "RelocLs", ".", "begin", "(", ")", ";", "R", "!=", "RelocLs", ".", "end", "(", ")", ";", "++", "R", ")", "if", "(", "NeedsMatchingLo", "(", "Asm", ",", "*", "R", ")", "&&", "!", "HasMatchingLo", "(", "Asm", ",", "R", ",", "--", "RelocLs", ".", "end", "(", ")", ")", ")", "Unmatched", ".", "push_back", "(", "R", ")", ";", "for", "(", "std", "::", "vector", "RelLsIter", ">", "::", "iterator", "U", "=", "Unmatched", ".", "begin", "(", ")", ";", "U", "!=", "Unmatched", ".", "end", "(", ")", ";", "++", "U", ")", "{", "RelLsIter", "LoPos", "=", "RelocLs", ".", "end", "(", ")", ",", "HiPos", "=", "*", "U", ";", "bool", "MatchedLo", "=", "false", ";", "for", "(", "RelLsIter", "R", "=", "RelocLs", ".", "begin", "(", ")", ";", "R", "!=", "RelocLs", ".", "end", "(", ")", ";", "++", "R", ")", "{", "if", "(", "(", "R", "->", "Reloc", ".", "Type", "==", "ELF", "::", "R_MIPS_LO16", ")", "&&", "HasSameSymbol", "(", "*", "HiPos", ",", "*", "R", ")", "&&", "(", "CompareOffset", "(", "*", "R", ",", "*", "HiPos", ")", ">=", "<NUM_LIT>", ")", "&&", "(", "(", "LoPos", "==", "RelocLs", ".", "end", "(", ")", ")", "||", "(", "(", "CompareOffset", "(", "*", "R", ",", "*", "LoPos", ")", "<NUM_LIT>", ")", ")", "||", "(", "!", "MatchedLo", "&&", "!", "CompareOffset", "(", "*", "R", ",", "*", "LoPos", ")", ")", ")", ")", "LoPos", "=", "R", ";", "MatchedLo", "=", "NeedsMatchingLo", "(", "Asm", ",", "*", "R", ")", "&&", "HasMatchingLo", "(", "Asm", ",", "R", ",", "--", "RelocLs", ".", "end", "(", ")", ")", ";", "}", "if", "(", "LoPos", "!=", "RelocLs", ".", "end", "(", ")", ")", "{", "HiPos", "->", "Offset", "=", "LoPos", "->", "Offset", ";", "RelocLs", ".", "insert", "(", "LoPos", ",", "*", "HiPos", ")", ";", "RelocLs", ".", "erase", "(", "HiPos", ")", ";", "}", "}", "assert", "(", "Relocs", ".", "size", "(", ")", "==", "RelocLs", ".", "size", "(", ")", ")", ";", "unsigned", "I", "=", "RelocLs", ".", "size", "(", ")", ";", "for", "(", "RelLsIter", "R", "=", "RelocLs", ".", "begin", "(", ")", ";", "R", "!=", "RelocLs", ".", "end", "(", ")", ";", "++", "R", ")", "Relocs", "[", "--", "I", "]", "=", "R", "->", "Reloc", ";", "<BUGE>", "}", "MCObjectWriter", "*", "llvm", "::", "createMipsELFObjectWriter", "(", "raw_ostream", "&", "OS", "," ]

[ "Success", ";" ]

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

[ "getAdjustedFrameSize", "(", "NumBytes", ")", ";" ]

[ "const", "SparcRegisterInfo", "&", "RegInfo", "=", "*", "static_cast", "<", "const", "SparcRegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "bool", "NeedsStackRealignment", "=", "RegInfo", ".", "needsStackRealignment", "(", "MF", ")", ";", "if", "(", "!", "NeedsStackRealignment", "&&", "MFI", ".", "getMaxAlignment", "(", ")", ">", "getStackAlignment", "(", ")", ")", "report_fatal_error", "(", "<STR_LIT>", "Function \\\"", "<STR_LIT>", "+", "Twine", "(", "MF", ".", "getName", "(", ")", ")", "+", "<STR_LIT>", "\\\" required ", "<STR_LIT>", "<STR_LIT>", "stack re-alignment, but LLVM couldn't handle it ", "<STR_LIT>", "<STR_LIT>", "(probably because it has a dynamic alloca).", "<STR_LIT>", ")", ";", "int", "NumBytes", "=", "(", "int", ")", "MFI", ".", "getStackSize", "(", ")", ";", "unsigned", "SAVEri", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "SAVErr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "FuncInfo", "->", "isLeafProc", "(", ")", ")", "{", "if", "(", "NumBytes", "==", "<NUM_LIT>", ")", "return", ";", "SAVEri", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "SAVErr", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "}", "if", "(", "MFI", ".", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "NumBytes", "+=", "MFI", ".", "getMaxCallFrameSize", "(", ")", ";", "NumBytes", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", "." ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";" ]

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

[ "def", "rsi", ":", "AsI1", "<", "opcod", ",", "(", "outs", "GPR", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "Rn", ",", "so_reg_imm", ":", "$", "shift", ")", ",", "DPSoRegImmFrm", ",", "IIC_iALUsr", ",", "opc", ",", "<STR_LIT>", ",", "[", "(", "set", "GPR", ":", "$", "Rd", ",", "CPSR", ",", "(", "opnode", "GPR", ":", "$", "Rn", ",", "so_reg_imm", ":", "$", "shift", ",", "CPSR", ")", ")", "]", ">", ",", "Requires", "<", "[", "IsARM", "]", ">", ",", "Sched", "<", "[", "WriteALUsi", ",", "ReadALU", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "shift", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "shift", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ".", "simple", ".", "guard", "&&", "simple", ".", "guard", "==", "other", ".", "simple", ".", "predicate", ";" ]

[ "return", "is_simple", "(", ")", "&&", "other", ".", "is_simple", "(", ")", "&&", "simple", ".", "type", "==", "RAInfo", "::", "Register", "&&", "other", ".", "simple", ".", "type", "==", "RAInfo", "::", "Register", "&&", "simple", ".", "predicate", "==", "other" ]

[ "}" ]

[ "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unhandled load/store type!", "<STR_LIT>", ")", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "if", "(", "!", "useAM3", ")", "{", "needsLowering", "=", "(", "(", "Addr", ".", "Offset", "&", "<NUM_LIT>", ")", "!=", "Addr", ".", "Offset", ")", ";", "if", "(", "needsLowering", "&&", "isThumb2", ")", "needsLowering", "=", "!", "(", "Subtarget", "->", "hasV6T2Ops", "(", ")", "&&", "Addr", ".", "Offset", "<", "<NUM_LIT>", "&&", "Addr", ".", "Offset", ">", "-", "<NUM_LIT>", ")", ";", "}", "else", "{", "needsLowering", "=", "(", "Addr", ".", "Offset", ">", "<NUM_LIT>", "||", "Addr", ".", "Offset", "<", "-", "<NUM_LIT>", ")", ";", "}", "break", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "needsLowering", "=", "(", "(", "Addr", ".", "Offset", "&", "<NUM_LIT>", ")", "!=", "Addr", ".", "Offset", ")", ";", "break", ";", "}", "if", "(", "needsLowering", "&&", "Addr", ".", "BaseType", "==", "Address", "::", "FrameIndexBase", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "isThumb2", "?", "(", "const", "TargetRegisterClass", "*", ")", "&", "ARM", "::", "tGPRRegClass", ":", "(", "const", "TargetRegisterClass", "*", ")", "&", "ARM", "::", "GPRRegClass", ";", "unsigned", "ResultReg", "=", "createResultReg", "(", "RC", ")", ";", "unsigned", "Opc", "=", "isThumb2", "?", "ARM", "::", "t2ADDri", ":", "ARM", "::", "ADDri", ";", "AddOptionalDefs", "(", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "Addr", ".", "Base", ".", "FI", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ")", ";", "Addr", ".", "Base", ".", "Reg", "=", "ResultReg", ";", "Addr", ".", "BaseType", "=", "Address", "::", "RegBase", ";", "}", "if", "(", "needsLowering", ")", "{", "Addr", ".", "Base", ".", "Reg", "=", "FastEmit_ri_", "(", "MVT", "::", "i32", ",", "ISD", "::", "ADD", ",", "Addr", ".", "Base", ".", "Reg", ",", "false", ",", "Addr", ".", "Offset", ",", "MVT", "::", "i32", ")", ";", "Addr", ".", "Offset", "=", "<NUM_LIT>", ";" ]

[ "<STR_LIT>", ")" ]

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

[ ")", ")" ]

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

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

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

[ "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{" ]

[ "}", "}", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "Mask", ")", "{", "Src", "=", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "{", "uint64_t", "Mask", "=", "(", "<NUM_LIT>", "ULL", "<<", "NumBits", ")", "-", "<NUM_LIT>", ";", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ")", "{", "if", "(", "(", "C", "->", "getZExtValue", "(", ")", "&", "Mask", ")", "==", "<NUM_LIT>", ")", "{", "Src", "=", "Val", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "}" ]

[ "return", "OptLevel", ">=", "CodeGenOpt", "::", "Default", ";" ]

[ "bool", "SPUSubtarget", "::", "enablePostRAScheduler", "(", "CodeGenOpt", "::", "Level", "OptLevel", ",", "TargetSubtargetInfo", "::", "AntiDepBreakMode", "&", "Mode", ",", "RegClassVector", "&", "CriticalPathRCs", ")", "const", "{", "Mode", "=", "TargetSubtargetInfo", "::", "ANTIDEP_CRITICAL", ";", "CriticalPathRCs", ".", "clear", "(", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "CriticalPathRCs", ".", "push_back", "(", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "CC", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "compare", ":", "CC", "(", "not", ":", "GPR", "(", "match_operand", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "clobber", "(", "match_scratch", ":", "GPR", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "not", ":", "GPR", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "compare", ":", "CC", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

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

[ "<STR_LIT>", "{", "bool", "ok", "=", "ix86_expand_mask_vec_cmp", "(", "operands", "[", "<NUM_LIT>", "]", ",", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "," ]

[ ")", ";" ]

[ "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i32", ":", "case", "MVT", "::", "i64", ":", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "if", "(", "!", "UseUnscaled", ")", "needsLowering", "=", "(", "(", "Offset", "&", "<NUM_LIT>", ")", "!=", "Offset", ")", ";", "else", "needsLowering", "=", "(", "Offset", ">", "<NUM_LIT>", "||", "Offset", "<", "-", "<NUM_LIT>", ")", ";", "break", ";", "}", "if", "(", "needsLowering", "&&", "Addr", ".", "getKind", "(", ")", "==", "Address", "::", "FrameIndexBase", ")", "{", "return", "false", ";", "}", "if", "(", "needsLowering", ")", "{", "uint64_t", "UnscaledOffset", "=", "Addr", ".", "getOffset", "(", ")", "*", "ScaleFactor", ";", "unsigned", "ResultReg", "=", "FastEmit_ri_", "(", "MVT", "::", "i64", ",", "ISD", "::", "ADD", ",", "Addr", ".", "getReg", "(", ")", ",", "false", ",", "UnscaledOffset", ",", "MVT", "::", "i64", ")", ";", "if", "(", "ResultReg", "==", "<NUM_LIT>", ")", "return", "false", ";", "Addr", ".", "setReg", "(", "ResultReg" ]

[ "}" ]

[ "dbgs", "(", ")", "<<", "<STR_LIT>", "User of CPE#", "<STR_LIT>", "<<", "CPEMI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "<<", "<STR_LIT>", " max delta=", "<STR_LIT>", "<<", "MaxDisp", "<<", "format", "(", "<STR_LIT>", " insn address=%#x", "<STR_LIT>", ",", "UserOffset", ")", "<<", "<STR_LIT>", " in ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", ": ", "<STR_LIT>", "<<", "format", "(", "<STR_LIT>", "%#x-%x\\t", "<STR_LIT>", ",", "BBI", ".", "Offset", ",", "BBI", ".", "postOffset", "(", ")", ")", "<<", "*", "MI", "<<", "format", "(", "<STR_LIT>", "CPE address=%#x offset=%+d: ", "<STR_LIT>", ",", "CPEOffset", ",", "int", "(", "CPEOffset", "-", "UserOffset", ")", ")", ";", "}", ")", ";" ]

[ "}" ]

[ "file_node", "*", "temp_node", ",", "*", "tail_node", "=", "file_head", ";", "for", "(", "temp_node", "=", "file_head", ";", "temp_node", "!=", "<NUM_LIT>", ";", "tail_node", "=", "temp_node", ",", "temp_node", "=", "temp_node", "->", "next", ")", "if", "(", "strcmp", "(", "temp_node", "->", "name", ",", "file_name", ")", "==", "<NUM_LIT>", ")", "{", "current_file", "=", "temp_node", ";", "break", ";", "}", "if", "(", "temp_node", "==", "<NUM_LIT>", ")", "{", "temp_node", "=", "(", "file_node", "*", ")", "(", "alloca", "(", "sizeof", "(", "file_node", ")", ")", ")", ";", "temp_node", "->", "next", "=", "<NUM_LIT>", ";", "temp_node", "->", "name", "=", "(", "char", "*", ")", "(", "alloca", "(", "strlen", "(", "file_name", ")", "+", "<NUM_LIT>", ")", ")", ";", "strcpy", "(", "temp_node", "->", "name", ",", "file_name", ")", ";", "temp_node", "->", "head", "=", "temp_node", "->", "current_line", "=", "<NUM_LIT>", ";", "if", "(", "file_head", ")", "tail_node", "->", "next", "=", "temp_node", ";", "else", "file_head", "=", "temp_node", ";", "current_file", "=", "temp_node", ";", "load_single_file", "(", "file_name", ")", ";" ]

[ "llvm_unreachable", "(", "<STR_LIT>", "Invalid generic fixup size!", "<STR_LIT>", ")", ";" ]

[ "case", "<NUM_LIT>", ":", "return", "isPCRel", "?", "FK_PCRel_2", ":", "FK_Data_2", ";", "case", "<NUM_LIT>", ":", "return", "isPCRel", "?", "FK_PCRel_4", ":", "FK_Data_4", ";", "case", "<NUM_LIT>", ":", "return", "isPCRel", "?", "FK_PCRel_8", ":", "FK_Data_8", ";", "}" ]

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

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

[ "}" ]

[ "bool", "VERegisterInfo", "::", "isConstantPhysReg", "(", "MCRegister", "PhysReg", ")", "const", "{", "return", "false", ";" ]

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

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

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "BW", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "mem", ":", "BW", "(", "plus", ":", "SI", "(", "mult", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "SI", "<NUM_LIT>" ]

[ "<FIXS>", "|", "|", "!", "CONST_INT_P", "(", "XVECEXP", "(", "unspec", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "<FIXE>" ]

[ "|", "|", "XINT", "(", "unspec", ",", "<NUM_LIT>", ")", "!", "=", "UNSPEC_MOVESI_FROM_CR", "|", "|", "XVECLEN", "(", "unspec", ",", "<NUM_LIT>", ")", "!", "=", "<NUM_LIT>", "|", "|", "XVECEXP", "(", "unspec", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "!", "=", "src_reg", "<BUGS>", "|", "|", "GET_CODE", "(", "XVECEXP", "(", "unspec", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "!", "=", "CONST_INT", "<BUGE>", "|", "|", "INTVAL", "(", "XVECEXP", "(", "unspec", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "!", "=", "maskval", ")", "return", "<NUM_LIT>", "}" ]

[ "_", "v16hf", ")", "_", "_", "C", ",", "_", "mm256_setzero_ph", "(", ")", ",", "_", "_", "A", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_maskz_fmul_pch", "(", "_", "_", "mmask8", "_", "_", "A", ",", "_", "_", "m256h", "_", "_", "B", ",", "_", "_", "m256h", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m256h", ")", "_", "_", "builtin_ia32_vfmulcph256_mask", "(", "(", "_", "_", "v16hf", ")", "_", "_", "B", ",", "(", "_" ]

[ "mode", ")" ]

[ "return", "mips_const_vector_shuffle_set_p", "(", "op", "," ]

[ ";" ]

[ "for", "(", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", "LI", ":", "MRI", ".", "liveins", "(", ")", ")", "if", "(", "isYmmOrZmmReg", "(", "LI", ".", "first", ")", ")", "return", "true", ";", "return", "false" ]

[ "MaskElement", "=", "MaskElement", ".", "lshr", "(", "MaskEltSizeInBits", ")", ";" ]

[ "if", "(", "MaskNode", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MaskNode", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SCALAR_TO_VECTOR", ")", "{", "if", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "!=", "MaskEltSizeInBits", ")", "return", "false", ";", "SDValue", "MaskElement", "=", "MaskNode", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "auto", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "MaskElement", ")", ")", "{", "APInt", "RawElt", "=", "CN", "->", "getAPIntValue", "(", ")", ".", "getLoBits", "(", "MaskEltSizeInBits", ")", ";", "RawMask", ".", "push_back", "(", "RawElt", ".", "getZExtValue", "(", ")", ")", ";", "RawMask", ".", "append", "(", "VT", ".", "getVectorNumElements", "(", ")", "-", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "if", "(", "MaskNode", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "BUILD_VECTOR", ")", "return", "false", ";", "if", "(", "(", "VT", ".", "getScalarSizeInBits", "(", ")", "%", "MaskEltSizeInBits", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "unsigned", "ElementSplit", "=", "VT", ".", "getScalarSizeInBits", "(", ")", "/", "MaskEltSizeInBits", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "MaskNode", ".", "getNumOperands", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "SDValue", "Op", "=", "MaskNode", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", "->", "getOpcode", "(", ")", "==", "ISD", "::", "UNDEF", ")", "{", "RawMask", ".", "push_back", "(", "(", "uint64_t", ")", "SM_SentinelUndef", ")", ";", "continue", ";", "}", "APInt", "MaskElement", ";", "if", "(", "auto", "*", "CN", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getNode", "(", ")", ")", ")", "MaskElement", "=", "CN", "->", "getAPIntValue", "(", ")", ";", "else", "if", "(", "auto", "*", "CFN", "=", "dyn_cast", "<", "ConstantFPSDNode", ">", "(", "Op", ".", "getNode", "(", ")", ")", ")", "MaskElement", "=", "CFN", "->", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ";", "else", "return", "false", ";", "for", "(", "unsigned", "j", "=", "<NUM_LIT>", ";", "j", "<", "ElementSplit", ";", "++", "j", ")", "{", "APInt", "RawElt", "=", "MaskElement", ".", "getLoBits", "(", "MaskEltSizeInBits", ")", ";", "RawMask", ".", "push_back", "(", "RawElt", ".", "getZExtValue", "(", ")", ")", ";" ]

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

[ "(", "define_mode_attr", "dbpsadbwmode", "[", "(", "V32HI", "<STR_LIT>", ")", "(", "V16HI", "<STR_LIT>", ")", "(", "V8HI" ]

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

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

[ "Pt4", ",", "PredRegs", ":", "$", "Pu4", ")", ",", "<STR_LIT>", ",", "tc_b31c2e97", ",", "TypeCR", ">", ",", "Enc_9ac432", "{" ]

[ "def", "C4_and_and", ":", "HInst", "<", "(", "outs", "PredRegs", ":", "$", "Pd4", ")", ",", "(", "ins", "PredRegs", ":", "$", "Ps4", ",", "PredRegs", ":", "$" ]

[ "true", ";" ]

[ "if", "(", "!", "Ordering", "||", "!", "Volatile", ")", "return", "false", ";", "unsigned", "OrderingVal", "=", "Ordering", "->", "getZExtValue", "(", ")", ";", "if", "(", "OrderingVal", ">", "static_cast", "<", "unsigned", ">", "(", "AtomicOrdering", "::", "SequentiallyConsistent", ")", ")", "return", "false", ";", "Info", ".", "PtrVal", "=", "Inst", "->", "getArgOperand", "(", "<NUM_LIT>", ")", ";", "Info", ".", "Ordering", "=", "static_cast", "<", "AtomicOrdering", ">", "(", "OrderingVal", ")", ";", "Info", ".", "ReadMem", "=", "true", ";", "Info", ".", "WriteMem", "=", "true", ";", "Info", ".", "IsVolatile", "=", "!", "Volatile", "->", "isZero", "(", ")", ";", "return" ]

[ "$", "rhs", ")", ",", "$", "tval", ",", "$", "fval", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v4i32", "(", "selectcc", "i1", ":", "$", "lhs", ",", "i1", ":", "$", "rhs", ",", "v4i32", ":", "$", "tval", ",", "v4i32", ":", "$", "fval", ",", "SETNE", ")", ")", ",", "(", "SELECT_VRRC", "(", "CRXOR", "$", "lhs", "," ]

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

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_conflict_epi32", "(", "_", "_", "m128i", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vpconflictsi_128_mask", "(", "(", "_", "_", "v4si", ")", "_", "_", "A", ",", "(", "_", "_" ]

[ "<FIXS>", "auto", "*", "CI", "=", "cast", "ConstantInt", ">", "(", "cast", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<FIXE>" ]

[ "}", "if", "(", "canFoldAddIntoGEP", "(", "U", ",", "Op", ")", ")", "{", "<BUGS>", "ConstantInt", "*", "CI", "=", "cast", "ConstantInt", ">", "(", "cast", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "<BUGE>", "TmpOffset", "+=", "CI", "->", "getSExtValue", "(", ")", "*", "S", ";", "Op", "=", "cast", "AddOperator", ">", "(", "Op", ")", "->", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

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

[ "unsigned", "Encoding", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ".", "lower", "(", ")", ")", ".", "Case", "(", "<STR_LIT>", "r8_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r9_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r10_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r11_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r12_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_usr", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r8_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r9_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r10_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r11_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "r12_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_irq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_irq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_svc", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_svc", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_abt", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_abt", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_und", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_und", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "lr_mon", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_mon", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "elr_hyp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "sp_hyp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_fiq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_irq", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_svc", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_abt", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_und", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_mon", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Case", "(", "<STR_LIT>", "spsr_hyp", "<STR_LIT>", ",", "<NUM_LIT>", ")", ".", "Default", "(", "~", "<NUM_LIT>", "U", ")", ";", "if", "(", "Encoding", "==", "~", "<NUM_LIT>", "U", ")" ]

[ ")" ]

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

[ "for", "(", "const", "SDep", "&", "Dep", ":", "SUJ", "->", "Succs", ")", "{" ]

[ "if", "(", "getSlot", "(", "*", "MII", ")", "==", "getSlot", "(", "*", "MIJ", ")", ")", "ConsideredInstUsesAlreadyWrittenVectorElement", "=", "true", ";", "int", "OpI", "=", "TII", "->", "getOperandIdx", "(", "MII", "->", "getOpcode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "pred_sel", ")", ",", "OpJ", "=", "TII", "->", "getOperandIdx", "(", "MIJ", "->", "getOpcode", "(", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", "::", "pred_sel", ")", ";", "Register", "PredI", "=", "(", "OpI", ">", "-", "<NUM_LIT>", ")", "?", "MII", "->", "getOperand", "(", "OpI", ")", ".", "getReg", "(", ")", ":", "Register", "(", ")", ",", "PredJ", "=", "(", "OpJ", ">", "-", "<NUM_LIT>", ")", "?", "MIJ", "->", "getOperand", "(", "OpJ", ")", ".", "getReg", "(", ")", ":", "Register", "(", ")", ";", "if", "(", "PredI", "!=", "PredJ", ")", "return", "false", ";", "if", "(", "SUJ", "->", "isSucc", "(", "SUI", ")", ")", "{" ]

[ "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", "Opcode", ")", "{", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "ENDPGM", ")", "NODE_NAME_CASE", "(", "RETURN", ")", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "CLAMP", ")", "NODE_NAME_CASE", "(", "COS_HW", ")", "NODE_NAME_CASE", "(", "SIN_HW", ")", "NODE_NAME_CASE", "(", "FMAX_LEGACY", ")", "NODE_NAME_CASE", "(", "FMIN_LEGACY", ")", "NODE_NAME_CASE", "(", "FMAX3", ")", "NODE_NAME_CASE", "(", "SMAX3", ")", "NODE_NAME_CASE", "(", "UMAX3", ")", "NODE_NAME_CASE", "(", "FMIN3", ")", "NODE_NAME_CASE", "(", "SMIN3", ")", "NODE_NAME_CASE", "(", "UMIN3", ")", "NODE_NAME_CASE", "(", "FMED3", ")", "NODE_NAME_CASE", "(", "SMED3", ")", "NODE_NAME_CASE", "(", "UMED3", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "DIV_SCALE", ")", "NODE_NAME_CASE", "(", "DIV_FMAS", ")", "NODE_NAME_CASE", "(", "DIV_FIXUP", ")", "NODE_NAME_CASE", "(", "TRIG_PREOP", ")", "NODE_NAME_CASE", "(", "RCP", ")", "NODE_NAME_CASE", "(", "RSQ", ")", "NODE_NAME_CASE", "(", "RSQ_LEGACY", ")", "NODE_NAME_CASE", "(", "RSQ_CLAMP", ")", "NODE_NAME_CASE", "(", "LDEXP", ")", "NODE_NAME_CASE", "(", "FP_CLASS", ")", "NODE_NAME_CASE", "(", "DOT4", ")", "NODE_NAME_CASE", "(", "CARRY", ")", "NODE_NAME_CASE", "(", "BORROW", ")", "NODE_NAME_CASE", "(", "BFE_U32", ")", "NODE_NAME_CASE", "(", "BFE_I32", ")", "NODE_NAME_CASE", "(", "BFI", ")", "NODE_NAME_CASE", "(", "BFM", ")", "NODE_NAME_CASE", "(", "FFBH_U32", ")", "NODE_NAME_CASE", "(", "MUL_U24", ")", "NODE_NAME_CASE", "(", "MUL_I24", ")", "NODE_NAME_CASE", "(", "MAD_U24", ")", "NODE_NAME_CASE", "(", "MAD_I24", ")", "NODE_NAME_CASE", "(", "TEXTURE_FETCH", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "NODE_NAME_CASE", "(", "CONST_ADDRESS", ")", "NODE_NAME_CASE", "(", "REGISTER_LOAD", ")", "NODE_NAME_CASE", "(", "REGISTER_STORE", ")", "NODE_NAME_CASE", "(", "LOAD_INPUT", ")", "NODE_NAME_CASE", "(", "SAMPLE", ")", "NODE_NAME_CASE", "(", "SAMPLEB", ")", "NODE_NAME_CASE", "(", "SAMPLED", ")", "NODE_NAME_CASE", "(", "SAMPLEL", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE0", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE1", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE2", ")", "NODE_NAME_CASE", "(", "CVT_F32_UBYTE3", ")", "NODE_NAME_CASE", "(", "BUILD_VERTICAL_VECTOR", ")", "NODE_NAME_CASE", "(", "CONST_DATA_PTR", ")", "NODE_NAME_CASE", "(", "PC_ADD_REL_OFFSET", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "NODE_NAME_CASE", "(", "SENDMSG", ")", "NODE_NAME_CASE", "(", "INTERP_MOV", ")", "NODE_NAME_CASE", "(", "INTERP_P1", ")", "NODE_NAME_CASE", "(", "INTERP_P2", ")", "NODE_NAME_CASE", "(", "STORE_MSKOR", ")", "NODE_NAME_CASE", "(", "LOAD_CONSTANT", ")", "NODE_NAME_CASE", "(", "TBUFFER_STORE_FORMAT", ")", "NODE_NAME_CASE", "(", "ATOMIC_CMP_SWAP", ")", "NODE_NAME_CASE", "(", "ATOMIC_INC", ")", "NODE_NAME_CASE", "(", "ATOMIC_DEC", ")", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "}", "return", "nullptr", ";", "}" ]

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

[ "<NUM_LIT>", ";" ]

[ "static", "SDValue", "lowerVECTOR_SHUFFLE_VSHUF4I", "(", "const", "SDLoc", "&", "DL", ",", "ArrayRef", "<", "int", ">", "Mask", ",", "MVT", "VT", ",", "SDValue", "V1", ",", "SDValue", "V2", ",", "SelectionDAG", "&", "DAG", ")", "{", "if", "(", "Mask", ".", "size", "(", ")", "<", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "int", "SubMask", "[", "<NUM_LIT>", "]", "=", "{", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", ",", "-", "<NUM_LIT>", "}", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "{", "for", "(", "unsigned", "j", "=", "i", ";", "j", "<", "Mask", ".", "size", "(", ")", ";", "j", "+=", "<NUM_LIT>", ")", "{", "int", "Idx", "=", "Mask", "[", "j", "]", ";", "if", "(", "Idx", "!=", "-", "<NUM_LIT>", ")", "{", "Idx", "-=", "<NUM_LIT>", "*", "(", "j", "/", "<NUM_LIT>", ")", ";", "if", "(", "Idx", "<", "<NUM_LIT>", "||", "Idx", ">=", "<NUM_LIT>", ")", "return", "SDValue", "(", ")", ";", "}", "if", "(", "SubMask", "[", "i", "]", "==", "-", "<NUM_LIT>", ")", "SubMask", "[", "i", "]", "=", "Idx", ";", "else", "if", "(", "Idx", "!=", "-", "<NUM_LIT>", "&&", "Idx", "!=", "SubMask", "[", "i", "]", ")", "return", "SDValue", "(", ")", ";", "}", "}", "APInt", "Imm", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", ">=", "<NUM_LIT>", ";", "--", "i", ")", "{", "int", "Idx", "=", "SubMask", "[", "i", "]", ";", "if", "(", "Idx", "==", "-", "<NUM_LIT>", ")", "Idx", "=" ]

[ "}" ]

[ "if", "(", "DstRC", "!=", "SrcRC", ")", "return", "false", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ",", "e", "=", "sizeof", "(", "map", ")", "/", "sizeof", "(", "map", "[", "<NUM_LIT>", "]", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "DstRC", "==", "map", "[", "i", "]", ".", "cls", ")", "{", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "map", "[", "i", "]", ".", "opcode", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "MCID", ",", "DstReg", ")", ".", "addReg", "(", "SrcReg", ")", ";", "AddDefaultPredicate", "(", "MI", ")", ";", "return", "true", ";" ]

[ "<STR_LIT>" ]

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

[ ")", ";" ]

[ "for", "(", "SelectionDAG", "::", "allnodes_iterator", "I", "=", "CurDAG", "->", "allnodes_begin", "(", ")", ",", "E", "=", "CurDAG", "->", "allnodes_end", "(", ")", ";", "I", "!=", "E", ";", ")", "{", "SDNode", "*", "N", "=", "I", "++", ";", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", "&&", "(", "(", "N", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "!", "Subtarget", "->", "callRegIndirect", "(", ")", ")", "||", "(", "N", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "(", "Subtarget", "->", "is64Bit", "(", ")", "||", "getTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", ")", ")", ")", "{", "bool", "HasCallSeq", "=", "N", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ";", "SDValue", "Chain", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "SDValue", "Load", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "isCalleeLoad", "(", "Load", ",", "Chain", ",", "HasCallSeq", ")", ")", "continue", ";", "MoveBelowOrigChain", "(", "CurDAG", ",", "Load", ",", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "Chain", ")", ";", "++", "NumLoadMoved", ";", "continue", ";", "}", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_ROUND", "&&", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "MVT", "SrcVT", "=", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getSimpleValueType", "(" ]

[ "(", "V2DI", "<STR_LIT>", ")", "(", "V4DI", "<STR_LIT>", ")", "(", "V8DI", "<STR_LIT>", ")" ]

[ "(", "define_mode_attr", "sse2_avx_avx512f", "[", "(", "V16QI", "<STR_LIT>", ")", "(", "V32QI", "<STR_LIT>", ")", "(", "V64QI", "<STR_LIT>", ")", "(", "V8HI", "<STR_LIT>", ")", "(", "V16HI", "<STR_LIT>", ")", "(", "V32HI", "<STR_LIT>", ")", "(", "V4SI", "<STR_LIT>", ")", "(", "V8SI", "<STR_LIT>", ")", "(", "V16SI", "<STR_LIT>", ")" ]

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

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

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

[ "(", "clobber", "(", "reg", ":", "SI", "REG_B2", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "REG_B3", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "REG_B4", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "REG_B30", ")", ")", "(", "clobber", "(", "reg", ":", "SI", "REG_B31", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "InstrItinClass", "Itinerary", "=", "NoItinerary", ";" ]

[ "string", "AsmString", "=", "!", "strconcat", "(", "<STR_LIT>", ",", "<STR_LIT>", ")", ";", "list", "<", "dag", ">", "Pattern", "=", "[", "(", "int_mips_wrdsp", "GPR32Opnd", ":", "$", "rt", ",", "immZExt7", ":", "$", "mask", ")", "]", ";" ]

[ "}" ]

[ "if", "(", "Op", ".", "isRegOrImmWithInputMods", "(", ")", ")", "{", "Op", ".", "addRegOrImmWithInputModsOperands", "(", "Inst", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "Op", ".", "isDPPCtrl", "(", ")", ")", "{", "Op", ".", "addImmOperands", "(", "Inst", ",", "<NUM_LIT>", ")", ";", "}", "else", "if", "(", "Op", ".", "isImm", "(", ")", ")", "{", "OptionalIdx", "[", "Op", ".", "getImmTy", "(", ")", "]", "=", "I", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Invalid operand type", "<STR_LIT>", ")", ";" ]

[ "if", "(", "!", "Check", "(", "S", ",", "DecodeSPRRegisterClass", "(", "Inst", ",", "Rm", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "if", "(", "Rt", "==", "<NUM_LIT>", "||", "Rt2", "==", "<NUM_LIT>", "||", "Rm", "==", "<NUM_LIT>", ")", "S", "=", "MCDisassembler", "::", "SoftFail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rt", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "if", "(", "!", "Check", "(", "S", ",", "DecodeGPRRegisterClass", "(", "Inst", ",", "Rt2", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "emit_insn", "(", "gen_blockage", "(", ")", ")" ]

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

[ "BranchTarget26Operand", ";" ]

[ "def", "am_bl_target", ":", "Operand", "<", "i64", ">", "{", "let", "EncoderMethod", "=", "<STR_LIT>", ";", "let", "PrintMethod", "=", "<STR_LIT>", ";", "let", "ParserMatchClass", "=" ]

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

[ "def", "Z6_HI", ":", "AArch64Reg", "<", "<NUM_LIT>" ]

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

[ "{", "return", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "\t", "\t", "\t", "<STR_LIT>", "<STR_LIT>", "}", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "emit_insn", "(", "gen_atomic_", "<", "fetchop_name", ">", "<", "mode", ">", "_soft_tcb", "(" ]

[ "}" ]

[ "case", "ISD", "::", "SETUO", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUEQ", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUNE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGT", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETULE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETUGE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "case", "ISD", "::", "SETTRUE", ":", "return", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "<NUM_LIT>", ";" ]

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

[ "<STR_LIT>" ]

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

[ "<FIXS>", "<FIXE>", "<FIXS>", "<FIXE>", "<FIXS>", "if", "(", "!", "MO", ".", "isExpr", "(", ")", ")", "return", "(", "(", "getMachineOpValue", "(", "MI", ",", "MO", ",", "Fixups", ",", "STI", ")", ")", "&", "<NUM_LIT>", "UL", ")", "|", "RegBits", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "switch", "(", "Expr", "->", "getKind", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unsupported MCExpr for getMemRI34PCRelEncoding.", "<STR_LIT>", ")", ";", "case", "MCExpr", "::", "SymbolRef", ":", "{", "<FIXE>", "<FIXS>", "case", "MCExpr", "::", "Binary", ":", "{", "const", "MCBinaryExpr", "*", "BE", "=", "cast", "MCBinaryExpr", ">", "(", "Expr", ")", ";", "assert", "(", "BE", "->", "getOpcode", "(", ")", "==", "MCBinaryExpr", "::", "Add", "&&", "<STR_LIT>", "Binary expression opcode must be an add.", "<STR_LIT>", ")", ";", "const", "MCExpr", "*", "LHS", "=", "BE", "->", "getLHS", "(", ")", ";", "const", "MCExpr", "*", "RHS", "=", "BE", "->", "getRHS", "(", ")", ";", "if", "(", "LHS", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "SymbolRef", ")", "std", "::", "swap", "(", "LHS", ",", "RHS", ")", ";", "if", "(", "LHS", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "SymbolRef", "||", "RHS", "->", "getKind", "(", ")", "!=", "MCExpr", "::", "Constant", ")", "llvm_unreachable", "(", "<STR_LIT>", "Expecting to have one constant and one relocation.", "<STR_LIT>", ")", ";", "const", "MCSymbolRefExpr", "*", "SRE", "=", "cast", "MCSymbolRefExpr", ">", "(", "LHS", ")", ";", "const", "MCConstantExpr", "*", "CE", "=", "cast", "MCConstantExpr", ">", "(", "RHS", ")", ";", "assert", "(", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_PCREL", "||", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_PPC_GOT_PCREL", ")", "&&", "<STR_LIT>", "VariantKind must be VK_PCREL or VK_PPC_GOT_PCREL", "<STR_LIT>", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "IsLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "Expr", ",", "static_cast", "MCFixupKind", ">", "(", "PPC", "::", "fixup_ppc_pcrel34", ")", ")", ")", ";", "assert", "(", "isInt", "<NUM_LIT>", ">", "(", "CE", "->", "getValue", "(", ")", ")", "&&", "<STR_LIT>", "Value must fit in 34 bits.", "<STR_LIT>", ")", ";", "return", "(", "CE", "->", "getValue", "(", ")", "&", "<NUM_LIT>", "UL", ")", "|", "RegBits", ";", "}", "}", "<FIXE>" ]

[ "PPCMCCodeEmitter", "::", "getMemRI34PCRelEncoding", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "<BUGS>", "<BUGE>", "assert", "(", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ".", "isImm", "(", ")", "&&", "<STR_LIT>", "Expecting an immediate.", "<STR_LIT>", ")", ";", "uint64_t", "RegBits", "=", "getMachineOpValue", "(", "MI", ",", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ",", "Fixups", ",", "STI", ")", "<<", "<NUM_LIT>", ";", "<BUGS>", "if", "(", "RegBits", "!=", "<NUM_LIT>", ")", "report_fatal_error", "(", "<STR_LIT>", "Operand must be 0", "<STR_LIT>", ")", ";", "<BUGE>", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "<BUGS>", "if", "(", "MO", ".", "isExpr", "(", ")", ")", "{", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "<BUGE>", "const", "MCSymbolRefExpr", "*", "SRE", "=", "cast", "MCSymbolRefExpr", ">", "(", "Expr", ")", ";", "(", "void", ")", "SRE", ";", "assert", "(", "(", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_PCREL", "||", "SRE", "->", "getKind", "(", ")", "==", "MCSymbolRefExpr", "::", "VK_PPC_GOT_PCREL", ")", "&&", "<STR_LIT>", "VariantKind must be VK_PCREL or VK_PPC_GOT_PCREL", "<STR_LIT>", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "IsLittleEndian", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ",", "Expr", ",", "static_cast", "MCFixupKind", ">", "(", "PPC", "::", "fixup_ppc_pcrel34", ")", ")", ")", ";", "return", "<NUM_LIT>", ";", "}", "<BUGS>", "return", "(", "(", "getMachineOpValue", "(", "MI", ",", "MO", ",", "Fixups", ",", "STI", ")", ")", "&", "<NUM_LIT>", "UL", ")", "|", "RegBits", ";", "<BUGE>", "}", "uint64_t" ]

[ "void", "Thumb2InstrInfo", "::", "ReplaceTailWithBranchTo", "(", "MachineBasicBlock", "::", "iterator", "Tail", ",", "MachineBasicBlock", "*", "NewDest", ")", "const", "{", "MachineBasicBlock", "*", "MBB", "=", "Tail", "->", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "!", "AFI", "->", "hasITBlocks", "(", ")", ")", "{", "TargetInstrInfo", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "return", ";", "}", "unsigned", "PredReg", "=", "<NUM_LIT>", ";", "<STR_LIT>", "::", "<STR_LIT>", "CC", "=", "getInstrPredicate", "(", "Tail", ",", "PredReg", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "Tail", ";", "if", "(", "CC", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "--", "MBBI", ";", "TargetInstrInfo", "::", "ReplaceTailWithBranchTo", "(", "Tail", ",", "NewDest", ")", ";", "if", "(", "CC", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MachineBasicBlock", "::", "iterator", "E", "=", "MBB", "->", "begin", "(", ")", ";", "unsigned", "Count", "=", "<NUM_LIT>", ";", "while", "(", "Count", "&&", "MBBI", "!=", "E", ")", "{", "if", "(", "MBBI", "->", "isDebugValue", "(", ")", ")", "{", "--", "MBBI", ";", "continue", ";", "}", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2IT", ")", "{", "unsigned", "Mask", "=", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "Count", "==", "<NUM_LIT>", ")", "MBBI", "->", "eraseFromParent", "(", ")", ";", "else", "{", "unsigned", "MaskOn", "=", "<NUM_LIT>", "<<", "Count", ";", "unsigned", "MaskOff", "=", "~", "(", "MaskOn", "-", "<NUM_LIT>", ")", ";", "MBBI", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "setImm", "(", "(", "Mask", "&", "MaskOff", ")", "|", "MaskOn", ")", ";", "}", "return", ";", "}", "--", "MBBI", ";", "--", "Count", ";", "}", "}", "}" ]

[ "Delete", "the", "instruction", "OldInst", "and", "everything", "after", "it", ",", "replacing", "it", "with", "an", "unconditional", "branch", "to", "NewDest", "." ]

[ "Base", "=", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ";" ]

[ "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "N", ")", "->", "getIndex", "(", ")", ";", "Base", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "TLI", "->", "getPointerTy", "(", "CurDAG", "->", "getDataLayout", "(", ")", ")", ")", ";", "OffImm", "=", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "SDLoc", "(", "N", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true", ";", "}", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetGlobalAddress", "&&", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetExternalSymbol", "&&", "N", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getOpcode", "(", ")", "!=", "ISD", "::", "TargetGlobalTLSAddress", ")", "{" ]