Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

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

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

[ "Inst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "static_cast", "<", "unsigned", ">", "(", "MAI", "->", "Addr", ")", ")", ")", ";" ]

[ "MCInst", "Inst", ";", "Inst", ".", "setOpcode", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

[ ":", "$", "Rn", ",", "FPR16", ":", "$", "Rm", ")", ",", "asm", ",", "<STR_LIT>", ",", "[", "]", ">", ";" ]

[ "def", "i16", ":", "BaseSIMDThreeScalarMixed", "<", "U", ",", "<NUM_LIT>", ",", "opc", ",", "(", "outs", "FPR32", ":", "$", "dst", ")", ",", "(", "ins", "FPR32", ":", "$", "Rd", ",", "FPR16" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RdaHiDest", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "RdaLoDest", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "X", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_8", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "A", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_0", ";" ]

[ "<FIXS>", "if", "(", "!", "count", ")", "unroll_factor", "=", "<NUM_LIT>", ";", "elsewhile", "(", "GET_MODE_SIZE", "(", "move_mode", ")", "*", "unroll_factor", "*", "<NUM_LIT>", "count", "&&", "unroll_factor", "<NUM_LIT>", ")", "unroll_factor", "*=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "move_mode", "=", "TARGET_64BIT", "?", "V2DImode", ":", "V4SImode", ";", "unroll_factor", "=", "<NUM_LIT>", ";", "<BUGS>", "while", "(", "GET_MODE_SIZE", "(", "move_mode", ")", "*", "unroll_factor", "*", "<NUM_LIT>", "count", "&&", "unroll_factor", "<NUM_LIT>", ")", "unroll_factor", "*=", "<NUM_LIT>", ";", "<BUGE>", "size_needed", "=", "GET_MODE_SIZE", "(", "move_mode", ")", "*", "unroll_factor", ";", "break", ";", "case", "rep_prefix_8_byte", ":" ]

[ "setOperationAction", "(", "ISD", "::", "ROTR", ",", "MVT", "::", "i8", ",", "Custom", ")", ";" ]

[ "setLoadExtAction", "(", "ISD", "::", "SEXTLOAD", ",", "MVT", "::", "i8", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setTruncStoreAction", "(", "MVT", "::", "i16", ",", "MVT", "::", "i8", ",", "Expand", ")", ";", "setOperationAction", "(", "ISD", "::", "LOAD", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "STORE", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ZERO_EXTEND", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SIGN_EXTEND", ",", "MVT", "::", "i16", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SHL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "SRA", ",", "MVT", "::", "i8", ",", "Custom", ")", ";", "setOperationAction", "(", "ISD", "::", "ROTL", ",", "MVT", "::", "i8", ",", "Custom", ")", ";" ]

[ "<FIXS>", "saved_first", "=", "crtl", "->", "emit", ".", "x_first_insn", ";", "saved_last", "=", "crtl", "->", "emit", ".", "x_last_insn", ";", "for", "(", "seq", "=", "crtl", "->", "emit", ".", "sequence_stack", ";", "seq", "&&", "seq", "->", "next", ";", "seq", "=", "seq", "->", "next", ")", "<FIXE>", "<FIXS>", "crtl", "->", "emit", ".", "x_first_insn", "=", "seq", "->", "first", ";", "crtl", "->", "emit", ".", "x_last_insn", "=", "seq", "->", "last", ";", "<FIXE>", "<FIXS>", "crtl", "->", "emit", ".", "x_first_insn", "=", "saved_first", ";", "crtl", "->", "emit", ".", "x_last_insn", "=", "saved_last", ";", "<FIXE>" ]

[ "struct", "sequence_stack", "*", "seq", ";", "int", "rv", ";", "<BUGS>", "saved_first", "=", "rtl", ".", "emit", ".", "x_first_insn", ";", "saved_last", "=", "rtl", ".", "emit", ".", "x_last_insn", ";", "for", "(", "seq", "=", "rtl", ".", "emit", ".", "sequence_stack", ";", "seq", "&&", "seq", "->", "next", ";", "seq", "=", "seq", "->", "next", ")", "<BUGE>", ";", "if", "(", "seq", ")", "{", "<BUGS>", "rtl", ".", "emit", ".", "x_first_insn", "=", "seq", "->", "first", ";", "rtl", ".", "emit", ".", "x_last_insn", "=", "seq", "->", "last", ";", "<BUGE>", "}", "rv", "=", "leaf_function_p", "(", ")", ";", "<BUGS>", "rtl", ".", "emit", ".", "x_first_insn", "=", "saved_first", ";", "rtl", ".", "emit", ".", "x_last_insn", "=", "saved_last", ";", "<BUGE>", "return", "rv", ";", "}" ]

[ "rtx", "swap_endian_selector_for_mode", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "swap1", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "unsigned", "int", "swap2", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "unsigned", "int", "swap4", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "unsigned", "int", "swap8", "[", "<NUM_LIT>", "]", "=", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ";", "unsigned", "int", "*", "swaparray", ",", "i", ";", "rtx", "perm", "[", "<NUM_LIT>", "]", ";", "switch", "(", "mode", ")", "{", "case", "E_V1TImode", ":", "swaparray", "=", "swap1", ";", "break", ";", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "swaparray", "=", "swap2", ";", "break", ";", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "swaparray", "=", "swap4", ";", "break", ";", "case", "E_V8HImode", ":", "swaparray", "=", "swap8", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "<NUM_LIT>", ";", "++", "i", ")", "if", "(", "BYTES_BIG_ENDIAN", ")", "perm", "[", "i", "]", "=", "GEN_INT", "(", "swaparray", "[", "i", "]", ")", ";", "else", "perm", "[", "i", "]", "=", "GEN_INT", "(", "~", "swaparray", "[", "i", "]", "&", "<NUM_LIT>", ")", ";", "return", "force_reg", "(", "V16QImode", ",", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "<NUM_LIT>", ",", "perm", ")", ")", ")", ";", "}" ]

[ "Return", "the", "permutation", "index", "for", "the", "swapping", "on", "the", "given", "vector", "mode", ".", "Note", "that", "the", "permutation", "index", "is", "correspondingly", "generated", "by", "endianness", ",", "it", "should", "be", "used", "by", "direct", "vector", "permutation", "." ]

[ ";" ]

[ "static", "bool", "MSA3OpIntrinsicToGeneric", "(", "MachineInstr", "&", "MI", ",", "unsigned", "Opcode", ",", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "MipsSubtarget", "&", "ST", ")", "{", "assert", "(", "ST", ".", "hasMSA", "(", ")", "&&", "<STR_LIT>", "MSA intrinsic not supported on target without MSA.", "<STR_LIT>", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "Opcode", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "MI", ".", "eraseFromParent", "(", ")", ";", "return", "true" ]

[ "case", "Intrinsic", "::", "ssub_sat", ":" ]

[ "case", "Intrinsic", "::", "fabs", ":", "case", "Intrinsic", "::", "copysign", ":", "case", "Intrinsic", "::", "floor", ":", "case", "Intrinsic", "::", "ceil", ":", "case", "Intrinsic", "::", "trunc", ":", "case", "Intrinsic", "::", "rint", ":", "case", "Intrinsic", "::", "nearbyint", ":", "case", "Intrinsic", "::", "round", ":", "case", "Intrinsic", "::", "canonicalize", ":", "case", "Intrinsic", "::", "lround", ":", "case", "Intrinsic", "::", "llround", ":", "case", "Intrinsic", "::", "lrint", ":", "case", "Intrinsic", "::", "llrint", ":", "if", "(", "F", "->", "getReturnType", "(", ")", "->", "isDoubleTy", "(", ")", "&&", "!", "ST", "->", "hasFP64", "(", ")", ")", "return", "true", ";", "if", "(", "F", "->", "getReturnType", "(", ")", "->", "isHalfTy", "(", ")", "&&", "!", "ST", "->", "hasFullFP16", "(", ")", ")", "return", "true", ";", "return", "!", "ST", "->", "hasFPARMv8Base", "(", ")", "&&", "!", "ST", "->", "hasVFP2Base", "(", ")", ";", "case", "Intrinsic", "::", "masked_store", ":", "case", "Intrinsic", "::", "masked_load", ":", "case", "Intrinsic", "::", "masked_gather", ":", "case", "Intrinsic", "::", "masked_scatter", ":", "return", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ";", "case", "Intrinsic", "::", "sadd_with_overflow", ":", "case", "Intrinsic", "::", "uadd_with_overflow", ":", "case", "Intrinsic", "::", "ssub_with_overflow", ":", "case", "Intrinsic", "::", "usub_with_overflow", ":", "case", "Intrinsic", "::", "sadd_sat", ":", "case", "Intrinsic", "::", "uadd_sat", ":" ]

[ "<FIXS>", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "NumBytes", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "<FIXE>" ]

[ "if", "(", "NumBytes", ")", "<BUGS>", "emitSPUpdate", "(", "MBB", ",", "MBBI", ",", "TII", ",", "dl", ",", "*", "RegInfo", ",", "-", "NumBytes", ")", ";", "<BUGE>", "if", "(", "STI", ".", "isTargetELF", "(", ")", "&&", "hasFP", "(", "MF", ")", ")", "MFI", "->", "setOffsetAdjustment", "(", "MFI", "->", "getOffsetAdjustment", "(", ")", "-" ]

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

[ "class", "BaseBitfieldImmWith2RegArgs", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "regtype", ",", "Operand", "imm_type", ",", "string", "asm", ">", ":", "I", "<", "(", "outs", "regtype", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "src", ",", "regtype", ":", "$", "Rn", ",", "imm_type", ":", "$", "immr", ",", "imm_type", ":", "$", "imms", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteIS", ",", "ReadI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "immr", ";", "bits", "<", "<NUM_LIT>", ">", "imms", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "immr", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "imms", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "NewMask", ",", "DL", ",", "DAG", ")", ")", ";" ]

[ "}", "}", "else", "if", "(", "NumV2Elements", "==", "<NUM_LIT>", ")", "{", "if", "(", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "&&", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", ")", "{", "NewMask", "[", "<NUM_LIT>", "]", "-=", "<NUM_LIT>", ";", "NewMask", "[", "<NUM_LIT>", "]", "-=", "<NUM_LIT>", ";", "}", "else", "if", "(", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "&&", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", ")", "{", "NewMask", "[", "<NUM_LIT>", "]", "-=", "<NUM_LIT>", ";", "NewMask", "[", "<NUM_LIT>", "]", "-=", "<NUM_LIT>", ";", "HighV", "=", "V1", ";", "LowV", "=", "V2", ";", "}", "else", "{", "int", "BlendMask", "[", "<NUM_LIT>", "]", "=", "{", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "?", "Mask", "[", "<NUM_LIT>", "]", ":", "Mask", "[", "<NUM_LIT>", "]", ",", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "?", "Mask", "[", "<NUM_LIT>", "]", ":", "Mask", "[", "<NUM_LIT>", "]", ",", "(", "Mask", "[", "<NUM_LIT>", "]", ">=", "<NUM_LIT>", "?", "Mask", "[", "<NUM_LIT>", "]", ":", "Mask", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", ",", "(", "Mask", "[", "<NUM_LIT>", "]", ">=", "<NUM_LIT>", "?", "Mask", "[", "<NUM_LIT>", "]", ":", "Mask", "[", "<NUM_LIT>", "]", ")", "-", "<NUM_LIT>", "}", ";", "V1", "=", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "V1", ",", "V2", ",", "getV4X86ShuffleImm8ForMask", "(", "BlendMask", ",", "DL", ",", "DAG", ")", ")", ";", "LowV", "=", "HighV", "=", "V1", ";", "NewMask", "[", "<NUM_LIT>", "]", "=", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "NewMask", "[", "<NUM_LIT>", "]", "=", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "NewMask", "[", "<NUM_LIT>", "]", "=", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "NewMask", "[", "<NUM_LIT>", "]", "=", "Mask", "[", "<NUM_LIT>", "]", "<", "<NUM_LIT>", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "DL", ",", "VT", ",", "LowV", ",", "HighV", ",", "getV4X86ShuffleImm8ForMask", "(" ]

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

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

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

[ "(", "define_mode_iterator", "VWB", "[", "V2SI" ]

[ "<FIXS>", "int", "llvm", "::", "getMatchingCondBranchOpcode", "(", "int", "Opc", ")", "{", "<FIXE>" ]

[ "return", "false", ";", "}", "<BUGS>", "int", "ARMBaseInstrInfo", "::", "getMatchingCondBranchOpcode", "(", "int", "Opc", ")", "const", "{", "<BUGE>", "if", "(", "Opc", "==", "ARM", "::", "B", ")", "return", "ARM", "::", "Bcc", ";", "else", "if", "(", "Opc", "==", "ARM", "::", "tB", ")" ]

[ "SDValue", "JTILo", "=", "DAG", ".", "getTargetJumpTable", "(", "JT", "->", "getIndex", "(", ")", ",", "PtrVT", ",", "MOLoFlag", ")", ";" ]

[ "getLabelAccessInfo", "(", "IsPIC", ",", "Subtarget", ",", "MOHiFlag", ",", "MOLoFlag", ")", ";", "if", "(", "IsPIC", "&&", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "{", "SDValue", "GA", "=", "DAG", ".", "getTargetJumpTable", "(", "JT", "->", "getIndex", "(", ")", ",", "PtrVT", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "return", "getTOCEntry", "(", "DAG", ",", "SDLoc", "(", "GA", ")", ",", "false", ",", "GA", ")", ";", "}", "SDValue", "JTIHi", "=", "DAG", ".", "getTargetJumpTable", "(", "JT", "->", "getIndex", "(", ")", ",", "PtrVT", ",", "MOHiFlag", ")", ";" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "mmask32", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_cmpeq_epu8_mask", "(", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "mmask32", ")", "_", "_", "builtin_ia32_ucmpb256_mask", "(", "(", "_", "_", "v32qi", ")", "_", "_", "A", ",", "(", "_", "_", "v32qi", ")", "_", "_", "B", ",", "<NUM_LIT>", ",", "(", "_", "_", "mmask32", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "<STR_LIT>" ]

[ "[", "(", "set", "(", "reg", ":", "CCC", "CC_REG", ")", "(", "compare", ":", "CCC", "(", "not", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", ")", "(", "const_int", "-", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "neg", ":", "W", "(", "geu", ":", "W", "(", "reg", ":", "CCC", "CC_REG", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", ")", "]" ]

[ "true", ";" ]

[ "return", "false", ";", "}", "if", "(", "RegKind1", "!=", "RegKind", ")", "{", "return", "false", ";", "}", "if", "(", "!", "AddNextRegisterToList", "(", "Reg", ",", "RegWidth", ",", "RegKind1", ",", "Reg1", ",", "RegNum1", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "return", "false", ";", "}", "}", "while", "(", "true", ")", ";", "}", "else", "{", "return", "false", ";", "}", "switch", "(", "RegKind", ")", "{", "case", "IS_SPECIAL", ":", "RegNum", "=", "<NUM_LIT>", ";", "RegWidth", "=", "<NUM_LIT>", ";", "break", ";", "case", "IS_VGPR", ":", "case", "IS_SGPR", ":", "case", "IS_TTMP", ":", "{", "unsigned", "Size", "=", "<NUM_LIT>", ";", "if", "(", "RegKind", "==", "IS_SGPR", "||", "RegKind", "==", "IS_TTMP", ")", "{", "Size", "=", "std", "::", "min", "(", "RegWidth", ",", "<NUM_LIT>", "u", ")", ";", "}", "if", "(", "RegNum", "%", "Size", "!=", "<NUM_LIT>", ")", "return", "false", ";", "RegNum", "=", "RegNum", "/", "Size", ";", "int", "RCID", "=", "getRegClass", "(", "RegKind", ",", "RegWidth", ")", ";", "if", "(", "RCID", "==", "-", "<NUM_LIT>", ")", "return", "false", ";", "const", "MCRegisterClass", "RC", "=", "TRI", "->", "getRegClass", "(", "RCID", ")", ";", "if", "(", "RegNum", ">=", "RC", ".", "getNumRegs", "(", ")", ")", "return", "false", ";", "Reg", "=", "RC", ".", "getRegister", "(", "RegNum", ")", ";", "break", ";", "}", "default", ":", "assert", "(", "false", ")", ";", "return", "false", ";", "}", "if", "(", "!", "subtargetHasRegister", "(", "*", "TRI", ",", "Reg", ")", ")", "return", "false", ";", "return" ]

[ "const", "uint16_t", "*", "PatmosRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "TM", ".", "getFrameLowering", "(", ")", ";", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "<STR_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>", "::", "<STR_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>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "<STR_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>", "::", "<STR_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>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<NUM_LIT>", "}", ";", "return", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "?", "CalleeSavedRegsFP", ":", "CalleeSavedRegs", ";", "}" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "<FIXS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "c3", "-", "isa", "(", "SLOTS", "C3", ")", "(", "INTRINSIC", "<STR_LIT>", "cpcmpgtu_b", "<STR_LIT>", ")", "(", "CPTYPE", "V8UQI", ")", "VOLATILE", ")", "<FIXE>" ]

[ ";", "<NUM_LIT>", "<NUM_LIT>", "<NUM_LIT>", "<NUM_LIT>", "<NUM_LIT>", "qqqqq", "ppppp", "<NUM_LIT>", "cpcmpgtu", ".", "b", "crqc", ",", "crpc", "(", "c3_1", ")", "(", "dni", "cpcmpgtu_b_C3", "<STR_LIT>", "cpcmpgtu.b $crqc,$crpc C3", "<STR_LIT>", "<BUGS>", "(", "OPTIONAL_CP_INSN", "ivc2", "-", "c3", "-", "isa", "(", "SLOTS", "C3", ")", "(", "INTRINSIC", "<STR_LIT>", "cpcmpgtu_b", "<STR_LIT>", ")", "(", "CPTYPE", "V8UQI", ")", ")", "<BUGE>", "<STR_LIT>", "cpcmpgtu.b $crqc,$crpc", "<STR_LIT>", "(", "+", "MAJ_15", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u4", "#", "x0", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u7", "#", "x10", ")", "(", "f", "-", "sub4", "<NUM_LIT>", ")", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u16", "#", "x12", ")", "crqc", "crpc", "(", "f", "-", "ivc2", "-", "<NUM_LIT>", "u31", "#", "x0", ")", ")" ]

[ ".", "_", "_", "o", ",", "_", "_", "c", ")", ";" ]

[ "union", "{", "float32x4x3_t", "_", "_", "i", ";", "_", "_", "builtin_neon_ci", "_", "_", "o", ";", "}", "_", "_", "rv", ";", "_", "_", "rv", ".", "_", "_", "o", "=", "_", "_", "builtin_neon_vld3_lanev4sf", "(", "(", "const", "_", "_", "builtin_neon_sf", "*", ")", "_", "_", "a", ",", "_", "_", "bu" ]

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

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

[ "}" ]

[ "}", "if", "(", "RelocOp", "->", "isGlobal", "(", ")", ")", "{", "FinalSize", "+=", "sizeGlobalAddress", "(", "false", ")", ";", "}", "else", "if", "(", "RelocOp", "->", "isCPI", "(", ")", ")", "{", "FinalSize", "+=", "sizeConstPoolAddress", "(", "false", ")", ";", "}", "else", "if", "(", "RelocOp", "->", "isJTI", "(", ")", ")", "{", "FinalSize", "+=", "sizeJumpTableAddress", "(", "false", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "<STR_LIT>", "Unknown value to relocate!", "<STR_LIT>", ")", ";", "}", "return", "FinalSize", ";" ]

[ ";" ]

[ "return", "true" ]

[ "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ";" ]

[ "if", "(", "X86", "::", "VR128RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "unsigned", "Opc", "=", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ";" ]

[ "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "BaseLongOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "isExtended", "=", "<NUM_LIT>", ";", "let", "InputType", "=", "<STR_LIT>", ";", "let", "DecoderNamespace", "=" ]

[ ")", "==", "MVT", "::", "i1", ")", ";" ]

[ "unsigned", "ToSz", "=", "StVT", ".", "getVectorElementType", "(", ")", ".", "getSizeInBits", "(", ")", ";", "const", "TargetLowering", "&", "TLI", "=", "DAG", ".", "getTargetLoweringInfo", "(", ")", ";", "if", "(", "TLI", ".", "isTruncStoreLegal", "(", "VT", ",", "StVT", ")", ")", "return", "SDValue", "(", ")", ";", "assert", "(", "isPowerOf2_32", "(", "NumElems", "*", "FromSz", "*", "ToSz", ")", "&&", "<STR_LIT>", "Unexpected size for truncating masked store", "<STR_LIT>", ")", ";", "assert", "(", "(", "(", "NumElems", "*", "FromSz", ")", "%", "ToSz", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected ratio for truncating masked store", "<STR_LIT>", ")", ";", "unsigned", "SizeRatio", "=", "FromSz", "/", "ToSz", ";", "assert", "(", "SizeRatio", "*", "NumElems", "*", "ToSz", "==", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "EVT", "WideVecVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "StVT", ".", "getScalarType", "(", ")", ",", "NumElems", "*", "SizeRatio", ")", ";", "assert", "(", "WideVecVT", ".", "getSizeInBits", "(", ")", "==", "VT", ".", "getSizeInBits", "(", ")", ")", ";", "SDValue", "WideVec", "=", "DAG", ".", "getBitcast", "(", "WideVecVT", ",", "Mst", "->", "getValue", "(", ")", ")", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "ShuffleVec", "(", "NumElems", "*", "SizeRatio", ",", "-", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "i", "*", "SizeRatio", ";", "assert", "(", "DAG", ".", "getTargetLoweringInfo", "(", ")", ".", "isTypeLegal", "(", "WideVecVT", ")", "&&", "<STR_LIT>", "WideVecVT should be legal", "<STR_LIT>", ")", ";", "SDValue", "TruncatedVal", "=", "DAG", ".", "getVectorShuffle", "(", "WideVecVT", ",", "dl", ",", "WideVec", ",", "DAG", ".", "getUNDEF", "(", "WideVecVT", ")", ",", "&", "ShuffleVec", "[", "<NUM_LIT>", "]", ")", ";", "SDValue", "NewMask", ";", "SDValue", "Mask", "=", "Mst", "->", "getMask", "(", ")", ";", "if", "(", "Mask", ".", "getValueType", "(", ")", "==", "VT", ")", "{", "NewMask", "=", "DAG", ".", "getBitcast", "(", "WideVecVT", ",", "Mask", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElems", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "i", "*", "SizeRatio", ";", "for", "(", "unsigned", "i", "=", "NumElems", ";", "i", "!=", "NumElems", "*", "SizeRatio", ";", "++", "i", ")", "ShuffleVec", "[", "i", "]", "=", "NumElems", "*", "SizeRatio", ";", "NewMask", "=", "DAG", ".", "getVectorShuffle", "(", "WideVecVT", ",", "dl", ",", "NewMask", ",", "DAG", ".", "getConstant", "(", "<NUM_LIT>", ",", "dl", ",", "WideVecVT", ")", ",", "&", "ShuffleVec", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "assert", "(", "Mask", ".", "getValueType", "(", ")", ".", "getVectorElementType", "(" ]

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

[ "class", "VST1D", "<", "bits", "<", "<NUM_LIT>", ">", "op7_4", ",", "string", "Dt", ",", "Operand", "AddrMode", ">", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ",", "VecListOneD", ":", "$", "Vd", ")", ",", "IIC_VST1", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVST1", "]", ">", "{", "let", "Rm", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "}", ";" ]

[ "Invalid number of operands!", "<STR_LIT>", ")", ";" ]

[ "assert", "(", "Kind", "==", "k_Immediate", "&&", "<STR_LIT>", "Unexpected operand kind", "<STR_LIT>", ")", ";", "assert", "(", "N", "==", "<NUM_LIT>", "&&", "<STR_LIT>" ]

[ "Vn", ",", "DPR_VFP2", ":", "$", "Vm", ",", "imm", ":", "$", "lane", ")", ">", ";" ]

[ "def", ":", "Pat", "<", "(", "v2i64", "(", "int_arm_neon_vqsubs", "(", "v2i64", "QPR", ":", "$", "src1", ")", ",", "(", "v2i64", "(", "int_arm_neon_vqdmull", "(", "v2i32", "DPR", ":", "$", "Vn", ")", ",", "(", "v2i32", "(", "NEONvduplane", "(", "v2i32", "DPR_VFP2", ":", "$", "Vm", ")", ",", "imm", ":", "$", "lane", ")", ")", ")", ")", ")", ")", ",", "(", "VQDMLSLslv2i32", "QPR", ":", "$", "src1", ",", "DPR", ":", "$" ]

[ "}" ]

[ "def", "irr", ":", "MMXI", "<", "opc", ",", "MRMSrcReg", ",", "(", "outs", "VR64", ":", "$", "dst", ")", ",", "(", "ins", "VR64", ":", "$", "src1", ",", "VR64", ":", "$", "src2", ")", ",", "!", "strconcat", "(", "OpcodeStr", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "VR64", ":", "$", "dst", ",", "(", "IntId", "VR64", ":", "$", "src1", ",", "VR64", ":", "$", "src2", ")", ")", "]", ">", ",", "Sched", "<", "[", "sched", "]", ">", "{", "let", "isCommutable", "=", "Commutable", ";" ]

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

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

[ "<FIXS>", "DAG", ".", "getConstant", "(", "StoreVal", ",", "DL", ",", "MVT", "::", "getIntegerVT", "(", "Size", "*", "<NUM_LIT>", ")", ")", ",", "<FIXE>" ]

[ "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ";", "I", "Size", ";", "++", "I", ")", "StoreVal", "|=", "ByteVal", "<<", "(", "I", "*", "<NUM_LIT>", ")", ";", "return", "DAG", ".", "getStore", "(", "Chain", ",", "DL", ",", "<BUGS>", "DAG", ".", "getConstant", "(", "StoreVal", ",", "MVT", "::", "getIntegerVT", "(", "Size", "*", "<NUM_LIT>", ")", ")", ",", "<BUGE>", "Dst", ",", "DstPtrInfo", ",", "false", ",", "false", ",", "Align", ")", ";", "}" ]

[ "&", "O", ")", "{" ]

[ "void", "HSAILInstPrinter", "::", "printBrigSegCvtModifierMask", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream" ]

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

[ "(", "FOP3", ":", "F", "(", "match_operand", ":", "F", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "F", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "return", "nios2_fpu_insn_asm", "(", "n2fpu_f", "<", "fop3", ">", "<", "f", ">", ")", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "}" ]

[ "unsigned", "OffBits", "=", "getMachineOpValue", "(", "MI", ",", "MI", ".", "getOperand", "(", "OpNo", "+", "<NUM_LIT>", ")", ",", "Fixups", ",", "STI", ")", ";", "return", "(", "OffBits", "&", "<NUM_LIT>", ")", "|", "RegBits", ";" ]

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

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

[ "}" ]

[ "vreinterpret_s8_s32", "(", "int32x2_t", "_", "_", "a", ")", "{", "return", "(", "int8x8_t", ")", "_", "_", "builtin_neon_vreinterpretv8qiv2si", "(", "_", "_", "a", ")", ";" ]

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

[ "(", "define_mode_attr", "cmp1_constraints", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>", ")", "]", ")", "(", "define_mode_attr", "cmp2_constraints", "[", "(", "QI", "<STR_LIT>", ")", "(", "HI", "<STR_LIT>", ")", "(", "SI", "<STR_LIT>" ]

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

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

[ "Mods", "|=", "<STR_LIT>", "::", "<STR_LIT>", ";" ]

[ "if", "(", "isExtractHiElt", "(", "Hi", ",", "Hi", ")", ")", "Mods", "|=", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "VecSize", "=", "Src", ".", "getValueSizeInBits", "(", ")", ";", "Lo", "=", "stripExtractLoElt", "(", "Lo", ")", ";", "Hi", "=", "stripExtractLoElt", "(", "Hi", ")", ";", "if", "(", "Lo", ".", "getValueSizeInBits", "(", ")", ">", "VecSize", ")", "{", "Lo", "=", "CurDAG", "->", "getTargetExtractSubreg", "(", "(", "VecSize", ">", "<NUM_LIT>", ")", "?", "AMDGPU", "::", "sub0_sub1", ":", "AMDGPU", "::", "sub0", ",", "SDLoc", "(", "In", ")", ",", "MVT", "::", "getIntegerVT", "(", "VecSize", ")", ",", "Lo", ")", ";", "}", "if", "(", "Hi", ".", "getValueSizeInBits", "(", ")", ">", "VecSize", ")", "{", "Hi", "=", "CurDAG", "->", "getTargetExtractSubreg", "(", "(", "VecSize", ">", "<NUM_LIT>", ")", "?", "AMDGPU", "::", "sub0_sub1", ":", "AMDGPU", "::", "sub0", ",", "SDLoc", "(", "In", ")", ",", "MVT", "::", "getIntegerVT", "(", "VecSize", ")", ",", "Hi", ")", ";", "}", "assert", "(", "Lo", ".", "getValueSizeInBits", "(", ")", "<=", "VecSize", "&&", "Hi", ".", "getValueSizeInBits", "(", ")", "<=", "VecSize", ")", ";", "if", "(", "Lo", "==", "Hi", "&&", "!", "isInlineImmediate", "(", "Lo", ".", "getNode", "(", ")", ")", ")", "{", "if", "(", "VecSize", "==", "<NUM_LIT>", "||", "VecSize", "==", "Lo", ".", "getValueSizeInBits", "(", ")", ")", "{", "Src", "=", "Lo", ";", "}", "else", "{", "assert", "(", "Lo", ".", "getValueSizeInBits", "(", ")", "==", "<NUM_LIT>", "&&", "VecSize", "==", "<NUM_LIT>", ")", ";", "SDLoc", "SL", "(", "In", ")", ";", "SDValue", "Undef", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "SL", ",", "Lo", ".", "getValueType", "(", ")", ")", ",", "<NUM_LIT>", ")", ";", "auto", "RC", "=", "Lo", "->", "isDivergent", "(", ")", "?", "AMDGPU", "::", "VReg_64RegClassID", ":", "AMDGPU", "::", "SReg_64RegClassID", ";", "const", "SDValue", "Ops", "[", "]", "=", "{", "CurDAG", "->", "getTargetConstant", "(", "RC", ",", "SL", ",", "MVT", "::", "i32", ")", ",", "Lo", ",", "CurDAG", "->", "getTargetConstant", "(", "AMDGPU", "::", "sub0", ",", "SL", ",", "MVT", "::", "i32", ")", ",", "Undef", ",", "CurDAG", "->", "getTargetConstant", "(", "AMDGPU", "::", "sub1", ",", "SL", ",", "MVT", "::", "i32", ")", "}", ";", "Src", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "TargetOpcode", "::", "REG_SEQUENCE", ",", "SL", ",", "Src", ".", "getValueType", "(", ")", ",", "Ops", ")", ",", "<NUM_LIT>", ")", ";", "}", "SrcMods", "=", "CurDAG", "->", "getTargetConstant", "(", "Mods", ",", "SDLoc", "(", "In", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true", ";", "}", "if", "(", "VecSize", "==", "<NUM_LIT>", "&&", "Lo", "==", "Hi", "&&", "isa", "<", "ConstantFPSDNode", ">", "(", "Lo", ")", ")", "{", "uint64_t", "Lit", "=", "cast", "<", "ConstantFPSDNode", ">", "(", "Lo", ")", "->", "getValueAPF", "(", ")", ".", "bitcastToAPInt", "(", ")", ".", "getZExtValue", "(", ")", ";", "if", "(", "AMDGPU", "::", "isInlinableLiteral32", "(", "Lit", ",", "Subtarget", "->", "hasInv2PiInlineImm", "(", ")", ")", ")", "{", "Src", "=", "CurDAG", "->", "getTargetConstant", "(", "Lit", ",", "SDLoc", "(", "In", ")", ",", "MVT", "::", "i64", ")", ";", ";", "SrcMods", "=", "CurDAG", "->", "getTargetConstant", "(", "Mods", ",", "SDLoc", "(", "In", ")", ",", "MVT", "::", "i32", ")", ";", "return", "true", ";", "}", "}", "Mods", "=", "VecMods", ";", "}" ]

[ "}" ]

[ "addr", "=", "XEXP", "(", "mem", ",", "<NUM_LIT>", ")", ";", "if", "(", "REG_P", "(", "addr", ")", "||", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "REG_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", "&&", "CONST_INT_P", "(", "XEXP", "(", "addr", ",", "<NUM_LIT>", ")", ")", ")", ")", "return", "<NUM_LIT>", ";", "else", "return", "<NUM_LIT>", ";" ]

[ "}" ]

[ "default", ":", "return", "MCDisassembler", "::", "Fail", ";", "case", "<NUM_LIT>", ":", "if", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "index", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "index", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "if", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "align", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "if", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "index", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "switch", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "{", "case", "<NUM_LIT>", ":", "align", "=", "<NUM_LIT>", ";", "break", ";", "case", "<NUM_LIT>", ":", "align", "=", "<NUM_LIT>", ";", "break", ";", "default", ":", "return", "MCDisassembler", "::", "Fail", ";", "}", "break", ";" ]

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

[ "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "fix", ":", "SI", "(", "match_operand", ":", "DF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "use", "(", "match_operand", ":", "PSI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGS>", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_i32gather_ps", "(", "_", "_", "m512", "_", "_", "v1_old", ",", "_", "_", "mmask16", "_", "_", "mask", ",", "_", "_", "m512i", "_", "_", "index", ",", "void", "const", "*", "_", "_", "addr", ",", "int", "_", "_", "scale", ")", "{", "return", "(", "_", "_", "m512", ")", "_", "_", "builtin_ia32_gathersiv16sf", "(", "(", "_", "_", "v16sf", ")", "_", "_", "v1_old", ",", "_", "_", "addr", ",", "(", "_", "_", "v16si", ")", "_", "_", "index", ",", "_", "_", "mask", ",", "_", "_", "scale", ")", ";" ]

[ ")" ]

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

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

[ "static", "bool", "isConjunctionDisjunctionTree", "(", "const", "SDValue", "Val", ",", "bool", "&", "CanPushNegate", ",", "unsigned", "Depth", "=", "<NUM_LIT>", ")", "{", "if", "(", "!", "Val", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "unsigned", "Opcode", "=", "Val", "->", "getOpcode", "(", ")", ";", "if", "(", "Opcode", "==", "ISD", "::", "SETCC", ")", "{", "CanPushNegate", "=", "true", ";", "return", "true", ";", "}", "if", "(", "Depth", ">", "<NUM_LIT>" ]

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

[ "else", "if", "(", "CCMask", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "auto", "*", "TrueVal", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "TrueVal", ")", "return", "false", ";", "auto", "*", "FalseVal", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "FalseVal", ")", "return", "false", ";", "if", "(", "CompareRHS", "->", "getZExtValue", "(", ")", "==", "FalseVal", "->", "getZExtValue", "(", ")", ")", "Invert", "=", "!", "Invert", ";", "else", "if", "(", "CompareRHS", "->", "getZExtValue", "(", ")", "!=", "TrueVal", "->", "getZExtValue", "(", ")", ")", "return", "false", ";", "auto", "*", "NewCCValid", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "auto", "*", "NewCCMask", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "NewCCValid", "||", "!", "NewCCMask", ")", "return", "false", ";", "CCValid", "=", "NewCCValid", "->", "getZExtValue", "(", ")", ";", "CCMask", "=", "NewCCMask", "->", "getZExtValue", "(", ")", ";", "if", "(", "Invert", ")", "CCMask", "^=", "CCValid", ";", "CCReg", "=", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "return", "true", ";", "}", "if", "(", "CompareLHS", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SRA", ")", "{", "auto", "*", "SRACount", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "SRACount", "||", "SRACount", "->", "getZExtValue", "(", ")", "!=", "<NUM_LIT>", ")", "return", "false", ";", "auto", "*", "SHL", "=", "CompareLHS", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "if", "(", "SHL", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", ")", "return", "false", ";", "auto", "*", "SHLCount", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "SHL", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "if", "(", "!", "SHLCount", "||", "SHLCount", "->", "getZExtValue", "(", ")", "!=", "<NUM_LIT>", "-", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "auto", "*", "IPM", "=", "SHL", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ";", "if", "(", "IPM", "->", "getOpcode", "(", ")", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "return", "false", ";", "if", "(", "!", "CompareLHS", "->", "hasOneUse", "(", ")", ")" ]

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

[ "let", "addrMode", "=", "BaseImmOffset", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "CextOpcode", "=", "<STR_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isPredicable", "=", "<NUM_LIT>", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "unsigned", "Rd", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Rd", "|=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "Rn", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Rn", "|=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "Rm", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Rm", "|=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "op", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<FIXE>" ]

[ "uint64_t", "Address", ",", "const", "void", "*", "Decoder", ")", "{", "DecodeStatus", "S", "=", "MCDisassembler", "::", "Success", ";", "<BUGS>", "unsigned", "Rd", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Rd", "|=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "Rn", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Rn", "|=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "Rm", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "Rm", "|=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ";", "unsigned", "op", "=", "fieldFromInstruction32", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "<BUGE>", "if", "(", "!", "Check", "(", "S", ",", "DecodeDPRRegisterClass", "(", "Inst", ",", "Rd", ",", "Address", ",", "Decoder", ")", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "]", ";" ]

[ "if", "(", "RegNum", "<", "PPC", "::", "CR0EQ", "||", "RegNum", ">", "PPC", "::", "CR7UN", ")", "return", "nullptr", ";", "const", "char", "*", "CRBits", "[", "]", "=", "{", "<STR_LIT>", "lt", "<STR_LIT>", ",", "<STR_LIT>", "gt", "<STR_LIT>", ",", "<STR_LIT>", "eq", "<STR_LIT>", ",", "<STR_LIT>", "un", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ",", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", "}", ";", "return", "CRBits", "[", "RegEncoding" ]

[ "else", "output_asm_insn", "(", "<STR_LIT>", "cmp%.b %d1,%d0", "<STR_LIT>", ",", "ops", ")", ";" ]

[ "else", "if", "(", "GET_CODE", "(", "op0", ")", "==", "MEM", "&&", "GET_CODE", "(", "op1", ")", "==", "MEM", ")", "output_asm_insn", "(", "<STR_LIT>", "cmpm%.b %1,%0", "<STR_LIT>", ",", "ops", ")", ";", "else", "if", "(", "REG_P", "(", "op1", ")", "||", "(", "!", "REG_P", "(", "op0", ")", "&&", "GET_CODE", "(", "op0", ")", "!=", "MEM", ")", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "cmp%.b %d0,%d1", "<STR_LIT>", ",", "ops", ")", ";", "std", "::", "swap", "(", "flags_compare_op0", ",", "flags_compare_op1", ")", ";", "return", "swap_condition", "(", "code", ")", ";", "}" ]

[ "<FIXS>", "updateBufferMMO", "(", "M", "->", "getMemOperand", "(", ")", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ")", ";", "<FIXE>" ]

[ "}", ";", "auto", "*", "M", "=", "cast", "MemSDNode", ">", "(", "Op", ")", ";", "<BUGS>", "M", "->", "getMemOperand", "(", ")", "->", "setOffset", "(", "getBufferOffsetForMMO", "(", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ",", "Ops", "[", "<NUM_LIT>", "]", ")", ")", ";", "<BUGE>", "return", "lowerIntrinsicLoad", "(", "M", ",", "IsFormat", ",", "DAG", ",", "Ops", ")", ";", "}", "case", "Intrinsic", "::", "amdgcn_struct_buffer_load", ":" ]

[ "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "BrOp", ",", "MVT", "::", "Other", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "VCC", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";" ]

[ "return", ";", "}", "bool", "UseSCCBr", "=", "isCBranchSCC", "(", "N", ")", "&&", "isUniformBr", "(", "N", ")", ";", "unsigned", "BrOp", "=", "UseSCCBr", "?", "AMDGPU", "::", "S_CBRANCH_SCC1", ":", "AMDGPU", "::", "S_CBRANCH_VCCNZ", ";", "unsigned", "CondReg", "=", "UseSCCBr", "?", "AMDGPU", "::", "SCC", ":", "AMDGPU", "::", "VCC", ";", "SDLoc", "SL", "(", "N", ")", ";", "if", "(", "!", "UseSCCBr", ")", "{", "Cond", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "AMDGPU", "::", "S_AND_B64", ",", "SL", ",", "MVT", "::", "i1", ",", "CurDAG", "->", "getRegister", "(", "AMDGPU", "::", "EXEC", ",", "MVT", "::", "i1", ")", ",", "Cond", ")", ",", "<NUM_LIT>", ")", ";", "}", "SDValue", "VCC", "=", "CurDAG", "->", "getCopyToReg", "(", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "SL", ",", "CondReg", ",", "Cond", ")", ";" ]

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

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

[ "}" ]

[ "bool", "AMDGPUInstrInfo", "::", "SubsumesPredicate", "(", "ArrayRef", "<", "MachineOperand", ">", "Pred1", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred2", ")", "const", "{", "return", "false", ";" ]

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

[ "def", "_D", ":", "sve_intx_dot_by_indexed_elem", "<", "<NUM_LIT>", ",", "opc", ",", "asm", ",", "ZPR64", ",", "ZPR16", ",", "ZPR4b16", ",", "VectorIndexD", ">", "{", "bits", "<", "<NUM_LIT>", ">", "iop", ";" ]

[ ")", ";" ]

[ "bool", "isFixed", "=", "MFI", "->", "isFixedObjectIndex", "(", "FI", ")", ";", "FrameReg", "=", "ARM", "::", "SP", ";", "Offset", "+=", "SPAdj", ";", "bool", "hasMovingSP", "=", "!", "hasReservedCallFrame", "(", "MF", ")", ";", "if", "(", "RegInfo", "->", "needsStackRealignment", "(", "MF", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "<STR_LIT>", "dynamic stack realignment without a FP!", "<STR_LIT>", ")", ";", "if", "(", "isFixed", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "Offset", "=", "FPOffset", ";", "}", "else", "if", "(", "hasMovingSP", ")", "{", "assert", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", "&&", "<STR_LIT>", "VLAs and dynamic stack alignment, but missing base pointer!", "<STR_LIT>", ")", ";", "FrameReg", "=", "RegInfo", "->", "getBaseRegister", "(", ")", ";", "}", "return", "Offset", ";", "}", "if", "(", "hasFP", "(", "MF", ")", "&&", "AFI", "->", "hasStackFrame", "(", ")", ")", "{", "if", "(", "isFixed", "||", "(", "hasMovingSP", "&&", "!", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FPOffset", ";", "}", "else", "if", "(", "hasMovingSP", ")", "{", "assert", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", "&&", "<STR_LIT>", "missing base pointer!", "<STR_LIT>", ")", ";", "if", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", "{", "if", "(", "FPOffset", ">=", "-", "<NUM_LIT>", "&&", "FPOffset", "<", "<NUM_LIT>", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FPOffset", ";", "}", "}", "}", "else", "if", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", "{", "if", "(", "Offset", ">=", "<NUM_LIT>", "&&", "(", "Offset", "&", "<NUM_LIT>", ")", "==", "<NUM_LIT>", "&&", "Offset", "<=", "<NUM_LIT>", ")", "return", "Offset", ";", "if", "(", "FPOffset", ">=", "-", "<NUM_LIT>", "&&", "FPOffset", "<", "<NUM_LIT>", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "FPOffset", ";", "}", "}", "else", "if", "(", "Offset", ">", "(", "FPOffset", "<", "<NUM_LIT>", "?", "-", "FPOffset", ":", "FPOffset", ")", ")", "{", "FrameReg", "=", "RegInfo", "->", "getFrameRegister", "(", "MF" ]

[ "int", "mems_ok_for_ldd_peep", "(", "rtx", "mem1", ",", "rtx", "mem2", ",", "rtx", "dependent_reg_rtx", ")", "{", "rtx", "addr1", ",", "addr2", ";", "unsigned", "int", "reg1", ";", "HOST_WIDE_INT", "offset1", ";", "if", "(", "MEM_VOLATILE_P", "(", "mem1", ")", "||", "MEM_VOLATILE_P", "(", "mem2", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "MEM_ALIGN", "(", "mem1", ")", "<", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "addr1", "=", "XEXP", "(", "mem1", ",", "<NUM_LIT>", ")", ";", "addr2", "=", "XEXP", "(", "mem2", ",", "<NUM_LIT>", ")", ";", "if", "(", "GET_CODE", "(", "addr1", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", "!=", "REG", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg1", "=", "REGNO", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", ")", "return", "<NUM_LIT>", ";", "offset1", "=", "INTVAL", "(", "XEXP", "(", "addr1", ",", "<NUM_LIT>", ")", ")", ";", "}", "}", "else", "if", "(", "GET_CODE", "(", "addr1", ")", "!=", "REG", ")", "return", "<NUM_LIT>", ";", "else", "{", "reg1", "=", "REGNO", "(", "addr1", ")", ";", "offset1", "=", "<NUM_LIT>", ";", "}", "if", "(", "GET_CODE", "(", "addr2", ")", "!=", "PLUS", ")", "return", "<NUM_LIT>", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", "!=", "REG", "||", "GET_CODE", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", "!=", "CONST_INT", ")", "return", "<NUM_LIT>", ";", "if", "(", "reg1", "!=", "REGNO", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "dependent_reg_rtx", "!=", "NULL_RTX", "&&", "reg1", "==", "REGNO", "(", "dependent_reg_rtx", ")", ")", "return", "<NUM_LIT>", ";", "if", "(", "offset1", "%", "<NUM_LIT>", "!=", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "addr2", ",", "<NUM_LIT>", ")", ")", "!=", "offset1", "+", "<NUM_LIT>", ")", "return", "<NUM_LIT>", ";", "return", "<NUM_LIT>", ";", "}" ]

[ "Return", "1", "if", "the", "addresses", "in", "mem1", "and", "mem2", "are", "suitable", "for", "use", "in", "an", "ldd", "or", "std", "insn", ".", "This", "can", "only", "happen", "when", "addr1", "and", "addr2", ",", "the", "addresses", "in", "mem1", "and", "mem2", ",", "are", "consecutive", "memory", "locations", "(", "addr1", "+", "4", "==", "addr2", ")", ".", "addr1", "must", "also", "be", "aligned", "on", "a", "64-bit", "boundary", ".", "Also", "iff", "dependent_reg_rtx", "is", "not", "null", "it", "should", "not", "be", "used", "to", "compute", "the", "address", "for", "mem1", ",", "i.e", ".", "we", "can", "not", "optimize", "a", "sequence", "like", ":", "ld", "[", "%", "o0", "]", ",", "%", "o0", "ld", "[", "%", "o0", "+", "4", "]", ",", "%", "o1", "to", "ldd", "[", "%", "o0", "]", ",", "%", "o0", "nor", ":", "ld", "[", "%", "g3", "+", "4", "]", ",", "%", "g3", "ld", "[", "%", "g3", "]", ",", "%", "g2", "to", "ldd", "[", "%", "g3", "]", ",", "%", "g2", "But", ",", "note", "that", "the", "transformation", "from", ":", "ld", "[", "%", "g2", "+", "4", "]", ",", "%", "g3", "ld", "[", "%", "g2", "]", ",", "%", "g2", "to", "ldd", "[", "%", "g2", "]", ",", "%", "g2", "is", "perfectly", "fine", ".", "Thus", ",", "the", "peephole2", "patterns", "always", "pass", "us", "the", "destination", "register", "of", "the", "first", "load", ",", "never", "the", "second", "one", ".", "For", "stores", "we", "do", "n't", "have", "a", "similar", "problem", ",", "so", "dependent_reg_rtx", "is", "NULL_RTX", "." ]

[ "}" ]

[ "virtual", "const", "ARMRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";" ]

[ "if", "(", "!", "(", "imm", "&", "<NUM_LIT>", ")", ")", "return", "MCDisassembler", "::", "Fail", ";" ]

[ "Vd", "|=", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "unsigned", "Vm", "=", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "Vm", "|=", "(", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "<<", "<NUM_LIT>", ")", ";", "unsigned", "imm", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "cmode", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "unsigned", "op", "=", "fieldFromInstruction", "(", "Insn", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "DecodeStatus", "S", "=", "MCDisassembler", "::", "Success", ";", "if", "(", "!", "(", "imm", "&", "<NUM_LIT>", ")", "&&", "cmode", "==", "<NUM_LIT>", ")", "{", "if", "(", "op", "==", "<NUM_LIT>", ")", "return", "MCDisassembler", "::", "Fail", ";", "Inst", ".", "setOpcode", "(", "ARM", "::", "VMOVv2f32", ")", ";", "return", "DecodeNEONModImmInstruction", "(", "Inst", ",", "Insn", ",", "Address", ",", "Decoder", ")", ";", "}" ]

[ "(", "_", "_", "v32qs", ")", "_", "_", "B", ")", ";" ]

[ "extern", "_", "_", "inline", "_", "_", "m256i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm256_cmpgt_epi8", "(", "_", "_", "m256i", "_", "_", "A", ",", "_", "_", "m256i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m256i", ")", "(", "(", "_", "_", "v32qs", ")", "_", "_", "A", ">" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "force_reg", "(", "TImode", ",", "operands", "[", "<NUM_LIT>", "]", ")" ]

[ "(", "match_operand", ":", "TI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "MEM_P", "(", "operands", "[", "<NUM_LIT>", "]", ")", "&", "&", "!", "reg_or_0_operand", "(", "operands", "[", "<NUM_LIT>", "]", ",", "TImode", ")", ")" ]

[ "for", "(", "size_t", "i", "=", "<NUM_LIT>", ";", "i", "<", "ARRAY_SIZE", "(", "data", ")", ";", "++", "i", ")", "aarch64_builtin_decls", "[", "data", "[", "i", "]", ".", "code", "]", "=", "aarch64_general_add_builtin", "(", "data", "[", "i", "]", ".", "name", ",", "data", "[", "i", "]", ".", "type", ",", "data", "[", "i", "]", ".", "code", ")", ";" ]

[ "ls64_builtins_data", "data", "[", "<NUM_LIT>", "]", "=", "{", "{", "<STR_LIT>", "__builtin_aarch64_ld64b", "<STR_LIT>", ",", "AARCH64_LS64_BUILTIN_LD64B", ",", "build_function_type_list", "(", "ls64_arm_data_t", ",", "const_ptr_type_node", ",", "NULL_TREE", ")", "}", ",", "{", "<STR_LIT>", "__builtin_aarch64_st64b", "<STR_LIT>", ",", "AARCH64_LS64_BUILTIN_ST64B", ",", "build_function_type_list", "(", "void_type_node", ",", "ptr_type_node", ",", "ls64_arm_data_t", ",", "NULL_TREE", ")", "}", ",", "{", "<STR_LIT>", "__builtin_aarch64_st64bv", "<STR_LIT>", ",", "AARCH64_LS64_BUILTIN_ST64BV", ",", "build_function_type_list", "(", "uint64_type_node", ",", "ptr_type_node", ",", "ls64_arm_data_t", ",", "NULL_TREE", ")", "}", ",", "{", "<STR_LIT>", "__builtin_aarch64_st64bv0", "<STR_LIT>", ",", "AARCH64_LS64_BUILTIN_ST64BV0", ",", "build_function_type_list", "(", "uint64_type_node", ",", "ptr_type_node", ",", "ls64_arm_data_t", ",", "NULL_TREE", ")", "}", ",", "}", ";" ]

[ "<FIXS>", "def", "ADC64i32", ":", "RIi32", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", "i64i32imm", ":", "$", "src", ")", ",", "<FIXE>" ]

[ "let", "Uses", "=", "[", "EFLAGS", "]", "in", "{", "<BUGS>", "def", "ADC64i32", ":", "RIi32", "<NUM_LIT>", ",", "RawFrm", ",", "(", "outs", ")", ",", "(", "ins", "i32imm", ":", "$", "src", ")", ",", "<BUGE>", "<STR_LIT>", ",", "[", "]", ">", ";", "let", "isTwoAddress", "=", "<NUM_LIT>", "in", "{" ]

[ "}" ]

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

[ "OpNode", ">", "{" ]

[ "def", "Wr", ":", "BaseCondComparisonReg", "<", "op", ",", "GPR32", ",", "mnemonic", "," ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_maskz_unpackhi_epi16", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_punpckhwd128_mask", "(", "(", "_", "_", "v8hi", ")", "_", "_", "A", ",", "(", "_", "_", "v8hi", ")", "_", "_", "B", ",", "(", "_", "_", "v8hi", ")", "_", "mm_avx512_setzero_si128", "(", ")", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "Ops", ".", "push_back", "(", "CLI", ".", "DAG", ".", "getRegisterMask", "(", "Mask", ")", ")", ";" ]

[ "const", "uint32_t", "*", "Mask", "=", "TRI", "->", "getCallPreservedMask", "(", "CLI", ".", "CallConv", ")", ";", "assert", "(", "Mask", "&&", "<STR_LIT>", "Missing call preserved mask for calling convention", "<STR_LIT>", ")", ";", "if", "(", "Subtarget", ".", "inMips16HardFloat", "(", ")", ")", "{", "if", "(", "GlobalAddressSDNode", "*", "G", "=", "dyn_cast", "<", "GlobalAddressSDNode", ">", "(", "CLI", ".", "Callee", ")", ")", "{", "llvm", "::", "StringRef", "Sym", "=", "G", "->", "getGlobal", "(", ")", "->", "getName", "(", ")", ";", "Function", "*", "F", "=", "G", "->", "getGlobal", "(", ")", "->", "getParent", "(", ")", "->", "getFunction", "(", "Sym", ")", ";", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "<STR_LIT>", "__Mips16RetHelper", "<STR_LIT>", ")", ")", "{", "Mask", "=", "MipsRegisterInfo", "::", "getMips16RetHelperMask", "(", ")", ";", "}", "}", "}" ]

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

[ "(", "define_attr", "<STR_LIT>", "<STR_LIT>", "(", "const", "(", "if_then_else", "(" ]

[ "::", "iterator", "MBBI", ")", "const", "{" ]

[ "bool", "HSAILInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock" ]

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

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

[ "<FIXS>", "mem", "=", "gen_frame_mem", "(", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ")", "?", "DFmode", ":", "SFmode", ")", ",", "addr", ")", ";", "<FIXE>", "<FIXS>", "emit_move_insn", "(", "gen_rtx_REG", "(", "(", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_DOUBLE_FLOAT", ")", "?", "DFmode", ":", "SFmode", ")", ",", "<FIXE>" ]

[ "GEN_INT", "(", "info", "->", "fp_save_offset", "<BUGS>", "mem", "=", "gen_frame_mem", "(", "DFmode", ",", "addr", ")", ";", "<BUGE>", "<BUGS>", "emit_move_insn", "(", "gen_rtx_REG", "(", "DFmode", ",", "<BUGE>", "info", "->", "first_fp_reg_save", "+", "i", ")", ",", "mem", ")", ";", "}" ]

[ "<STR_LIT>", ")" ]

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

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

[ "_", "_", "arm_vcvtmq_m_s16_f16", "(", "int16x8_t", "_", "_", "inactive", ",", "float16x8_t", "_", "_", "a", ",", "mve_pred16_t", "_", "_", "p", ")", "{", "return", "_", "_", "builtin_mve_vcvtmq_m_sv8hi", "(", "_", "_", "inactive", ",", "_", "_", "a", ",", "_", "_" ]

[ "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "override", "{", "const", "static", "MCFixupKindInfo", "InfosBE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "<STR_LIT>", "fixup_ppc_br24", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_br24_notoc", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_brcond14", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_br24abs", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_brcond14abs", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_half16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_half16ds", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_pcrel34", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_nofixup", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ";", "const", "static", "MCFixupKindInfo", "InfosLE", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "<STR_LIT>", "fixup_ppc_br24", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_br24_notoc", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_brcond14", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_br24abs", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_brcond14abs", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_half16", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_half16ds", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", ",", "{", "<STR_LIT>", "fixup_ppc_pcrel34", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "<STR_LIT>", "fixup_ppc_nofixup", "<STR_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", "}", "}", ";", "if", "(", "Kind", ">=", "FirstLiteralRelocationKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "FK_NONE", ")", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "<STR_LIT>", "Invalid kind!", "<STR_LIT>", ")", ";", "return", "(", "Endian", "==", "support", "::", "little", "?", "InfosLE", ":", "InfosBE", ")", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ ")", ";" ]

[ "llvm", "::", "for_each", "(", "Changes", ",", "[", "&", "]", "(", "const", "std", "::", "pair", "<", "Change", ",", "std", "::", "string", ">", "&", "v", ")", "{", "printElem", "(", "OS", ",", "v", ".", "first", ")", ";", "OS", "<<", "<STR_LIT>", "; ", "<STR_LIT>", "<<", "v", ".", "second", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", "}" ]

[ "int", "rs6000_store_data_bypass_p", "(", "rtx_insn", "*", "out_insn", ",", "rtx_insn", "*", "in_insn", ")", "{", "rtx", "out_set", ",", "in_set", ";", "rtx", "out_pat", ",", "in_pat", ";", "rtx", "out_exp", ",", "in_exp", ";", "int", "i", ",", "j", ";", "in_set", "=", "single_set", "(", "in_insn", ")", ";", "if", "(", "in_set", ")", "{", "if", "(", "MEM_P", "(", "SET_DEST", "(", "in_set", ")", ")", ")", "{", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "out_set", ")", "{", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "==", "PARALLEL", ")", "{", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "out_pat", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "{", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "<NUM_LIT>", ",", "i", ")", ";", "if", "(", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "out_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "out_exp", ")", "!=", "SET", ")", "return", "false", ";", "}", "}", "}", "}", "}", "else", "{", "in_pat", "=", "PATTERN", "(", "in_insn", ")", ";", "if", "(", "GET_CODE", "(", "in_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "XVECLEN", "(", "in_pat", ",", "<NUM_LIT>", ")", ";", "i", "++", ")", "{", "in_exp", "=", "XVECEXP", "(", "in_pat", ",", "<NUM_LIT>", ",", "i", ")", ";", "if", "(", "(", "GET_CODE", "(", "in_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "in_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "in_exp", ")", "!=", "SET", ")", "return", "false", ";", "if", "(", "MEM_P", "(", "SET_DEST", "(", "in_exp", ")", ")", ")", "{", "out_set", "=", "single_set", "(", "out_insn", ")", ";", "if", "(", "!", "out_set", ")", "{", "out_pat", "=", "PATTERN", "(", "out_insn", ")", ";", "if", "(", "GET_CODE", "(", "out_pat", ")", "!=", "PARALLEL", ")", "return", "false", ";", "for", "(", "j", "=", "<NUM_LIT>", ";", "j", "<", "XVECLEN", "(", "out_pat", ",", "<NUM_LIT>", ")", ";", "j", "++", ")", "{", "out_exp", "=", "XVECEXP", "(", "out_pat", ",", "<NUM_LIT>", ",", "j", ")", ";", "if", "(", "(", "GET_CODE", "(", "out_exp", ")", "==", "CLOBBER", ")", "||", "(", "GET_CODE", "(", "out_exp", ")", "==", "USE", ")", ")", "continue", ";", "else", "if", "(", "GET_CODE", "(", "out_exp", ")", "!=", "SET", ")", "return", "false", ";", "}", "}", "}", "}", "}", "return", "store_data_bypass_p", "(", "out_insn", ",", "in_insn", ")", ";", "}" ]

[ "Given", "that", "there", "exists", "at", "least", "one", "variable", "that", "is", "set", "(", "produced", ")", "by", "OUT_INSN", "and", "read", "(", "consumed", ")", "by", "IN_INSN", ",", "return", "true", "iff", "IN_INSN", "represents", "one", "or", "more", "memory", "store", "operations", "and", "none", "of", "the", "variables", "set", "by", "OUT_INSN", "is", "used", "by", "IN_INSN", "as", "the", "address", "of", "a", "store", "operation", ".", "If", "either", "IN_INSN", "or", "OUT_INSN", "does", "not", "represent", "a", "``", "single", "''", "RTL", "SET", "expression", "(", "as", "loosely", "defined", "by", "the", "implementation", "of", "the", "single_set", "function", ")", "or", "a", "PARALLEL", "with", "only", "SETs", ",", "CLOBBERs", ",", "and", "USEs", "inside", ",", "this", "function", "returns", "false", ".", "This", "rs6000-specific", "version", "of", "store_data_bypass_p", "checks", "for", "certain", "conditions", "that", "result", "in", "assertion", "failures", "(", "and", "internal", "compiler", "errors", ")", "in", "the", "generic", "store_data_bypass_p", "function", "and", "returns", "false", "rather", "than", "calling", "store_data_bypass_p", "if", "one", "of", "the", "problematic", "conditions", "is", "detected", "." ]

[ "<FIXS>", "error", "(", "<STR_LIT>", "invalid protection type (%qs) in %<target(\\\"branch-protection", "<STR_LIT>", "<FIXE>" ]

[ "<STR_LIT>", " attribute", "<STR_LIT>", ")", ";", "break", ";", "case", "AARCH64_PARSE_INVALID_ARG", ":", "<BUGS>", "error", "(", "<STR_LIT>", "invalid protection type (\\\"%s\\\") in %<target(\\\"branch-protection", "<STR_LIT>", "<BUGE>", "<STR_LIT>", "=\\\")%> pragma or attribute", "<STR_LIT>", ",", "err_str", ")", ";", "break", ";", "case", "AARCH64_PARSE_OK", ":" ]

[ "else", "tem", "=", "simplify_gen_subreg", "(", "reg_mode", ",", "x", ",", "BLKmode", ",", "i", "*", "GET_MODE_SIZE", "(", "reg_mode", ")", ")", ";" ]

[ "static", "void", "rs6000_move_block_from_reg", "(", "int", "regno", ",", "rtx", "x", ",", "int", "nregs", ")", "{", "int", "i", ";", "machine_mode", "reg_mode", "=", "TARGET_32BIT", "?", "SImode", ":", "DImode", ";", "if", "(", "nregs", "==", "<NUM_LIT>", ")", "return", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "nregs", ";", "i", "++", ")", "{", "rtx", "tem", "=", "adjust_address_nv", "(", "x", ",", "reg_mode", ",", "i", "*", "GET_MODE_SIZE", "(", "reg_mode", ")", ")", ";", "if", "(", "reload_completed", ")", "{", "if", "(", "!", "strict_memory_address_p", "(", "reg_mode", ",", "XEXP", "(", "tem", ",", "<NUM_LIT>", ")", ")", ")", "tem", "=", "NULL_RTX", ";" ]

[ "void", "MSP430InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FrameIdx", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "<NUM_LIT>", ",", "MFI", ".", "getObjectSize", "(", "FrameIdx", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIdx", ")", ")", ";", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "<STR_LIT>", "Cannot store this register to stack slot!", "<STR_LIT>", ")", ";", "}" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

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

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "_", "TM_non_transactional_store", "(", "void", "*", "const", "addr", ",", "long", "long", "const", "value", ")", "{", "_", "_", "builtin_non_tx_store", "(", "(", "uint64_t", "*", ")", "addr", ",", "(", "uint64_t", ")" ]

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

[ "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips2", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips3", ":", "selectArch", "(", "<STR_LIT>", "mips3", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips3", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips4", ":", "selectArch", "(", "<STR_LIT>", "mips4", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips4", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips5", ":", "selectArch", "(", "<STR_LIT>", "mips5", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips5", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips32", ":", "selectArch", "(", "<STR_LIT>", "mips32", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips32", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips32r2", ":", "selectArch", "(", "<STR_LIT>", "mips32r2", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips32R2", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips32r3", ":", "selectArch", "(", "<STR_LIT>", "mips32r3", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips32R3", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips32r5", ":", "selectArch", "(", "<STR_LIT>", "mips32r5", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips32R5", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips32r6", ":", "selectArch", "(", "<STR_LIT>", "mips32r6", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips32R6", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips64", ":", "selectArch", "(", "<STR_LIT>", "mips64", "<STR_LIT>", ")", ";", "getTargetStreamer", "(", ")", ".", "emitDirectiveSetMips64", "(", ")", ";", "break", ";", "case", "Mips", "::", "FeatureMips64r2", ":", "selectArch", "(", "<STR_LIT>", "mips64r2" ]

[ "}" ]

[ "class", "PrefetchLiteral", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bit", "V", ",", "string", "asm", ",", "list", "<", "dag", ">", "pat", ">", ":", "I", "<", "(", "outs", ")", ",", "(", "ins", "prfop", ":", "$", "Rt", ",", "am_ldrlit", ":", "$", "label", ")", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "pat", ">", ",", "Sched", "<", "[", "WriteLD", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "label", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "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>", "}", "=", "label", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rt", ";" ]

[ "SelectCode", "(", "Node", ")", ";" ]

[ "assert", "(", "Node", "->", "getValueType", "(", "<NUM_LIT>", ")", "==", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "MVT", "::", "i32", ")", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "{", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ";", "return", ";", "}", "ReplaceNode", "(", "Node", ",", "CurDAG", "->", "getMachineNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "i32", ",", "TFI", ",", "CurDAG", "->", "getTargetConstant", "(", "<NUM_LIT>", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ")", ";", "return", ";", "}", "}" ]

[ "<STR_LIT>", ")" ]

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

[ "}" ]

[ "std", "::", "set", "<", "unsigned", ">", "SUColors", ";", "if", "(", "CurrentColoring", "[", "SU", "->", "NodeNum", "]", "<=", "(", "int", ")", "DAGSize", ")", "continue", ";", "for", "(", "SDep", "&", "SuccDep", ":", "SU", "->", "Succs", ")", "{", "SUnit", "*", "Succ", "=", "SuccDep", ".", "getSUnit", "(", ")", ";", "if", "(", "SuccDep", ".", "isWeak", "(", ")", "||", "Succ", "->", "NodeNum", ">=", "DAGSize", ")", "continue", ";", "SUColors", ".", "insert", "(", "CurrentColoring", "[", "Succ", "->", "NodeNum", "]", ")", ";", "}", "if", "(", "SUColors", ".", "size", "(", ")", "==", "<NUM_LIT>", ")", "CurrentColoring", "[", "SU", "->", "NodeNum", "]", "=", "*", "SUColors", ".", "begin", "(", ")", ";" ]

[ "_", "v16hi", ")", "_", "_", "B", ",", "(", "_", "_", "mmask16", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "return", "(", "_", "_", "m256h", ")", "_", "_", "builtin_ia32_vpermi2varhi256_mask", "(", "(", "_", "_", "v16hi", ")", "_", "_", "A", ",", "(", "_", "_", "v16hi", ")", "_", "_", "I", ",", "(", "_" ]

[ "}" ]

[ "vcopy_laneq_p8", "(", "poly8x8_t", "_", "_", "a", ",", "const", "int", "_", "_", "lane1", ",", "poly8x16_t", "_", "_", "b", ",", "const", "int", "_", "_", "lane2", ")", "{", "return", "_", "_", "aarch64_vset_lane_any", "(", "_", "_", "aarch64_vget_lane_any", "(", "_", "_", "b", ",", "_", "_", "lane2", ")", ",", "_", "_", "a", ",", "_", "_", "lane1", ")", ";" ]

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

[ "if", "(", "!", "N", ")", "return", "false", ";", "uint64_t", "TotalOffs", "=", "<NUM_LIT>", ";", "MVT", "VT", "=", "TLI", ".", "getPointerTy", "(", "DL", ")", ";", "for", "(", "gep_type_iterator", "GTI", "=", "gep_type_begin", "(", "I", ")", ",", "E", "=", "gep_type_end", "(", "I", ")", ";", "GTI", "!=", "E", ";", "++", "GTI", ")", "{", "const", "Value", "*", "Idx", "=", "GTI", ".", "getOperand", "(", ")", ";", "if", "(", "auto", "*", "StTy", "=", "GTI", ".", "getStructTypeOrNull", "(", ")", ")", "{", "unsigned", "Field", "=", "cast", "<", "ConstantInt", ">", "(", "Idx", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "Field", ")", "TotalOffs", "+=", "DL", ".", "getStructLayout", "(", "StTy", ")", "->", "getElementOffset", "(", "Field", ")", ";", "}", "else", "{", "Type", "*", "Ty", "=", "GTI", ".", "getIndexedType" ]

[ ")", ")" ]

[ "(", "umax", ":", "GPI", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "GPI", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "{", "if", "(", "aarch64_sve_cnt_immediate", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode", ")", ")", "std", ":", ":", "swap", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", "else", "if", "(", "!", "aarch64_sve_cnt_immediate", "(", "operands", "[", "<NUM_LIT>", "]", ",", "<", "MODE", ">", "mode" ]

[ "const", "char", "*", "pru_output_signed_cbranch_zeroop2", "(", "rtx", "*", "operands", ",", "bool", "is_near", ")", "{", "static", "char", "buf", "[", "<NUM_LIT>", "]", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "int", "regop_sign_bit_pos", "=", "sign_bit_position", "(", "operands", "[", "<NUM_LIT>", "]", ")", ";", "if", "(", "code", "==", "LT", ")", "{", "if", "(", "is_near", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "<STR_LIT>", "qbbs\\t%%l3, %%1, %d\\n\\t", "<STR_LIT>", ",", "regop_sign_bit_pos", ")", ";", "else", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "<STR_LIT>", "qbbc\\t.+8, %%1, %d\\n\\t", "<STR_LIT>", "<STR_LIT>", "jmp\\t%%%%label(%%l3)", "<STR_LIT>", ",", "regop_sign_bit_pos", ")", ";", "}", "else", "if", "(", "code", "==", "GE", ")", "{", "if", "(", "is_near", ")", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "<STR_LIT>", "qbbc\\t%%l3, %%1, %d\\n\\t", "<STR_LIT>", ",", "regop_sign_bit_pos", ")", ";", "else", "snprintf", "(", "buf", ",", "sizeof", "(", "buf", ")", ",", "<STR_LIT>", "qbbs\\t.+8, %%1, %d\\n\\t", "<STR_LIT>", "<STR_LIT>", "jmp\\t%%%%label(%%l3)", "<STR_LIT>", ",", "regop_sign_bit_pos", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "return", "buf", ";", "}" ]

[ "Optimized", "version", "of", "pru_output_signed_cbranch_ubyteop2", "for", "constant", "zero", "second", "operand", "." ]

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

[ "def", "A2_subh_h16_ll", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "IntRegs", ":", "$", "Rt32", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_679309b8", ",", "TypeALU64", ">", ",", "Enc_bd6011", "{", "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", "hasNewValue", "=", "<NUM_LIT>", ";" ]

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

[ "ftype", "=", "ix86_get_builtin_func_type", "(", "FLOAT128_FTYPE_FLOAT128", ")", ";", "decl", "=", "add_builtin_function", "(", "<STR_LIT>", "__builtin_fabsq", "<STR_LIT>", ",", "ftype", ",", "IX86_BUILTIN_FABSQ", ",", "BUILT_IN_MD", ",", "<STR_LIT>", "__fabstf2", "<STR_LIT>", ",", "NULL_TREE", ")", ";", "TREE_READONLY", "(", "decl", ")", "=", "<NUM_LIT>", ";", "ix86_builtins", "[", "(", "int", ")", "IX86_BUILTIN_FABSQ", "]", "=", "decl", ";", "ftype", "=", "ix86_get_builtin_func_type", "(", "FLOAT128_FTYPE_FLOAT128_FLOAT128", ")", ";", "decl", "=", "add_builtin_function", "(", "<STR_LIT>", "__builtin_copysignq", "<STR_LIT>", ",", "ftype", ",", "IX86_BUILTIN_COPYSIGNQ", ",", "BUILT_IN_MD", ",", "<STR_LIT>", "__copysigntf3", "<STR_LIT>" ]

[ "const", "TargetRegisterClass", "*", "SparcRegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "return", "Subtarget", ".", "is64Bit", "(", ")", "?", "&", "<STR_LIT>", "::", "<STR_LIT>", ":", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "}" ]

[ "getPointerRegClass", "-", "Returns", "a", "TargetRegisterClass", "used", "for", "pointer", "values", "." ]

[ "}" ]

[ "switch", "(", "Opcode", ")", "{", "case", "ARM", "::", "VMULS", ":", "case", "ARM", "::", "VMULfd", ":", "case", "ARM", "::", "VMULfq", ":", "case", "ARM", "::", "VMULD", ":", "case", "ARM", "::", "VMULslfd", ":", "case", "ARM", "::", "VMULslfq", ":", "return", "true", ";", "default", ":", "return", "false", ";" ]

[ "Zt", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "nregs", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Pg", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

[ "<FIXS>", "def", ":", "Pat", "(", "atomic_fence", "(", "imm", ")", ",", "(", "imm", ")", ")", ",", "(", "SYNC", "<NUM_LIT>", ")", ">", ",", "Requires", "[", "IsNotBookE", "]", ">", ";", "def", ":", "Pat", "(", "atomic_fence", "(", "imm", ")", ",", "(", "imm", ")", ")", ",", "(", "MSYNC", ")", ">", ",", "Requires", "[", "IsBookE", "]", ">", ";", "<FIXE>" ]

[ "def", ":", "Pat", "(", "f64", "(", "fextend", "f32", ":", "$", "src", ")", ")", ",", "(", "COPY_TO_REGCLASS", "$", "src", ",", "F8RC", ")", ">", ";", "<BUGS>", "def", ":", "Pat", "(", "atomic_fence", "(", "imm", ")", ",", "(", "imm", ")", ")", ",", "(", "SYNC", "<NUM_LIT>", ")", ">", ";", "<BUGE>", "def", ":", "Pat", "(", "fma", "(", "fneg", "f64", ":", "$", "A", ")", ",", "f64", ":", "$", "C", ",", "f64", ":", "$", "B", ")", "," ]