Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ ")", ")", "_", "_", "TM_abort", "(", "void", ")", "{" ]

[ "extern", "_", "_", "inline", "void", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__" ]

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

[ "def", "VLD2q8", ":", "VLD2", "<", "<NUM_LIT>", ",", "{", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "?", ",", "?", "}", ",", "<STR_LIT>", ",", "VecListFourD", ",", "IIC_VLD2x2", ",", "addrmode6align64or128or256", ">", "," ]

[ "<NUM_LIT>", ";" ]

[ "def", "A2_vavguw", ":", "HInst", "<", "(", "outs", "DoubleRegs", ":", "$", "Rdd32", ")", ",", "(", "ins", "DoubleRegs", ":", "$", "Rss32", ",", "DoubleRegs", ":", "$", "Rtt32", ")", ",", "<STR_LIT>", ",", "tc_6132ba3d", ",", "TypeALU64", ">", ",", "Enc_a56825", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=" ]

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

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

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

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

[ "Parser", ".", "Lex", "(", ")", ";" ]

[ "bool", "PreOrPost", "=", "false", ";", "if", "(", "Lexer", ".", "getKind", "(", ")", "==", "Lexer", ".", "peekTok", "(", "true", ")", ".", "getKind", "(", ")", ")", "{", "PreOrPost", "=", "true", ";", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Minus", ")", ")", "*", "OffsetValue", "=", "-", "SizeForSuffix", "(", "Type", ")", ";", "else", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Plus", ")", ")", "*", "OffsetValue", "=", "SizeForSuffix", "(", "Type", ")", ";", "else", "return", "false", ";" ]

[ "uint64_t", "StackSizeBytes", "=", "FrameInfo", "->", "getStackSize", "(", ")", ";" ]

[ "EndCf", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_KILL", ":", "if", "(", "Depth", "==", "<NUM_LIT>", ")", "SkipIfDead", "(", "MI", ")", ";", "else", "HaveKill", "=", "true", ";", "Kill", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "S_BRANCH", ":", "Branch", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_SRC", ":", "IndirectSrc", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V1", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V2", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V4", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V8", ":", "case", "AMDGPU", "::", "SI_INDIRECT_DST_V16", ":", "IndirectDst", "(", "MI", ")", ";", "break", ";", "case", "AMDGPU", "::", "V_INTERP_P1_F32", ":", "case", "AMDGPU", "::", "V_INTERP_P2_F32", ":", "case", "AMDGPU", "::", "V_INTERP_MOV_F32", ":", "NeedWQM", "=", "true", ";", "break", ";", "}", "}", "}", "if", "(", "NeedM0", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "InitM0ForLDS", "(", "MBB", ".", "getFirstNonPHI", "(", ")", ")", ";", "}", "if", "(", "NeedWQM", "&&", "MFI", "->", "getShaderType", "(", ")", "==", "ShaderType", "::", "PIXEL", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "getFirstNonPHI", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_WQM_B64", ")", ",", "AMDGPU", "::", "EXEC", ")", ".", "addReg", "(", "AMDGPU", "::", "EXEC", ")", ";", "}", "if", "(", "NeedFlat", "&&", "MFI", "->", "IsKernel", ")", "{", "const", "MachineFrameInfo", "*", "FrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";" ]

[ "}", "else", "{" ]

[ "MF", "->", "insert", "(", "It", ",", "loopMBB", ")", ";", "MF", "->", "insert", "(", "It", ",", "sinkMBB", ")", ";", "MF", "->", "insert", "(", "It", ",", "exitMBB", ")", ";", "exitMBB", "->", "splice", "(", "exitMBB", "->", "begin", "(", ")", ",", "BB", ",", "llvm", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "exitMBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "loopMBB", "->", "addSuccessor", "(", "loopMBB", ")", ";", "loopMBB", "->", "addSuccessor", "(", "sinkMBB", ")", ";", "sinkMBB", "->", "addSuccessor", "(", "exitMBB", ")", ";", "int64_t", "MaskImm", "=", "(", "Size", "==", "<NUM_LIT>", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "ADDiu", ")", ",", "MaskLSB2", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "-", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "AND", ")", ",", "AlignedAddr", ")", ".", "addReg", "(", "Ptr", ")", ".", "addReg", "(", "MaskLSB2", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "ANDi", ")", ",", "PtrLSB2", ")", ".", "addReg", "(", "Ptr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "SLL", ")", ",", "ShiftAmt", ")", ".", "addReg", "(", "PtrLSB2", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "ORi", ")", ",", "MaskUpper", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addImm", "(", "MaskImm", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "SLLV", ")", ",", "Mask", ")", ".", "addReg", "(", "ShiftAmt", ")", ".", "addReg", "(", "MaskUpper", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "NOR", ")", ",", "Mask2", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addReg", "(", "Mask", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "SLLV", ")", ",", "Incr2", ")", ".", "addReg", "(", "ShiftAmt", ")", ".", "addReg", "(", "Incr", ")", ";", "BB", "=", "loopMBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "LL", ")", ",", "OldVal", ")", ".", "addReg", "(", "AlignedAddr", ")", ".", "addImm", "(", "<NUM_LIT>", ")", ";", "if", "(", "Nand", ")", "{", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "AND", ")", ",", "AndRes", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "Incr2", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "NOR", ")", ",", "BinOpRes", ")", ".", "addReg", "(", "Mips", "::", "ZERO", ")", ".", "addReg", "(", "AndRes", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "AND", ")", ",", "NewVal", ")", ".", "addReg", "(", "BinOpRes", ")", ".", "addReg", "(", "Mask", ")", ";", "}", "else", "if", "(", "BinOpcode", ")", "{", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "BinOpcode", ")", ",", "BinOpRes", ")", ".", "addReg", "(", "OldVal", ")", ".", "addReg", "(", "Incr2", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", "->", "get", "(", "Mips", "::", "AND", ")", ",", "NewVal", ")", ".", "addReg", "(", "BinOpRes", ")", ".", "addReg", "(", "Mask", ")", ";" ]

[ ">", ";" ]

[ "def", "HasPrefetchW", ":", "Predicate", "<", "<STR_LIT>" ]

[ ")" ]

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

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

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

[ "}" ]

[ "O", "<<", "<STR_LIT>", "<NUM_LIT>", "<STR_LIT>", ";", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "case", "'", "U", "'", ":", "case", "'", "X", "'", ":", "{", "assert", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", ";", "return", "false", ";" ]

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

[ "return", "(", "_", "_", "m256i", ")", "_", "_", "builtin_ia32_vcvtph2w256_mask", "(", "_", "_", "A", ",", "(", "_", "_", "v16hi", ")", "_", "mm256_avx512_setzero_si256" ]

[ "<FIXS>", "class", "T_ALU32_2op_Pred", "string", "mnemonic", ",", "bits", "<NUM_LIT>", ">", "minOp", ",", "bit", "isPredNot", ",", "bit", "isPredNew", ">", ":", "ALU32Inst", "(", "outs", "IntRegs", ":", "$", "Rd", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu", ",", "IntRegs", ":", "$", "Rs", ")", ",", "!", "if", "(", "isPredNot", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "!", "if", "(", "isPredNew", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "<STR_LIT>", "#", "mnemonic", "#", "<STR_LIT>", ">", "{", "<FIXE>" ]

[ "let", "hasSideEffects", "=", "<NUM_LIT>", ",", "validSubTargets", "=", "HasV4SubT", ",", "hasNewValue", "=", "<NUM_LIT>", ",", "opNewValue", "=", "<NUM_LIT>", "in", "<BUGS>", "class", "T_ALU32_2op_Pred", "string", "mnemonic", ",", "bits", "<NUM_LIT>", ">", "minOp", ",", "bit", "isPredNot", ",", "bit", "isPredNew", ">", ":", "ALU32Inst", "(", "outs", "IntRegs", ":", "$", "Rd", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu", ",", "IntRegs", ":", "$", "Rs", ")", ",", "!", "if", "(", "isPredNot", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "!", "if", "(", "isPredNew", ",", "<STR_LIT>", ",", "<STR_LIT>", ")", "#", "<STR_LIT>", "#", "mnemonic", "#", "<STR_LIT>", ">", "{", "<BUGE>", "bits", "<NUM_LIT>", ">", "Rd", ";", "bits", "<NUM_LIT>", ">", "Pu", ";", "bits", "<NUM_LIT>", ">", "Rs", ";" ]

[ "cmovpred", ":", "$", "p", ")", ")", "]", ">", ",", "RegConstraint", "<", "<STR_LIT>", ">", ",", "Sched", "<", "[", "WriteALU", "]", ">", ";" ]

[ "def", "MOVCCsi", ":", "ARMPseudoInst", "<", "(", "outs", "GPR", ":", "$", "Rd", ")", ",", "(", "ins", "GPR", ":", "$", "false", ",", "so_reg_imm", ":", "$", "shift", ",", "cmovpred", ":", "$", "p", ")", ",", "<NUM_LIT>", ",", "IIC_iCMOVsr", ",", "[", "(", "set", "GPR", ":", "$", "Rd", ",", "(", "ARMcmov", "GPR", ":", "$", "false", ",", "so_reg_imm", ":", "$", "shift", "," ]

[ "UOps", ";" ]

[ "let", "Latency", "=", "Lat", ";", "let", "ResourceCycles", "=", "Res", ";", "let", "NumMicroOps", "=" ]

[ "const", "TargetRegisterClass", "*", "X86RegisterInfo", "::", "getPointerRegClass", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Kind", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unexpected Kind in getPointerRegClass!", "<STR_LIT>", ")", ";", "case", "<NUM_LIT>", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64RegClass", ";", "return", "&", "X86", "::", "GR32RegClass", ";", "case", "<NUM_LIT>", ":", "if", "(", "Subtarget", ".", "isTarget64BitLP64", "(", ")", ")", "return", "&", "X86", "::", "GR64_NOSPRegClass", ";", "return", "&", "X86", "::", "GR32_NOSPRegClass", ";", "case", "<NUM_LIT>", ":", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsWin64", "||", "(", "F", "&&", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "X86_64_Win64", ")", ")", "return", "&", "X86", "::", "GR64_TCW64RegClass", ";", "else", "if", "(", "Is64Bit", ")", "return", "&", "X86", "::", "GR64_TCRegClass", ";", "bool", "hasHipeCC", "=", "(", "F", "?", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "HiPE", ":", "false", ")", ";", "if", "(", "hasHipeCC", ")", "return", "&", "X86", "::", "GR32RegClass", ";", "return", "&", "X86", "::", "GR32_TCRegClass", ";", "}", "}" ]

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

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

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "CC_CCR", "[", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "CC_CCR", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", "]" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "ENDIAN_LANE_N", "(", "<", "MODE", ">", "mode", ",", "INTVAL", "(", "operands", "[", "<NUM_LIT>", "]", ")", ")", ")" ]

[ "(", "unspec", ":", "VALLDIF", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_VSTRUCTDUMMY", ")", "]", "UNSPEC_LD3_LANE", ")", ")", "]", "<STR_LIT>", "{" ]

[ "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", " ", "<STR_LIT>", ";", "Mov", "->", "dump", "(", ")", ")", ";" ]

[ "MachineOperand", "SILoadStoreOptimizer", "::", "createRegOrImm", "(", "int32_t", "Val", ",", "MachineInstr", "&", "MI", ")", "const", "{", "APInt", "V", "(", "<NUM_LIT>", ",", "Val", ",", "true", ")", ";", "if", "(", "TII", "->", "isInlineConstant", "(", "V", ")", ")", "return", "MachineOperand", "::", "CreateImm", "(", "Val", ")", ";", "Register", "Reg", "=", "MRI", "->", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_32RegClass", ")", ";", "MachineInstr", "*", "Mov", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "MI", ".", "getIterator", "(", ")", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "Reg", ")", ".", "addImm", "(", "Val", ")", ";", "(", "void", ")", "Mov", ";" ]

[ ">", "movs_r6_to", "(", "Ax", "b", ")", "{" ]

[ "std", "::", "vector", "<", "std", "::", "string" ]

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

[ "bits", "<", "<NUM_LIT>", ">", "dst", ";", "bits", "<", "<NUM_LIT>", ">", "src", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>", ">", "pred", ";", "let", "Dest", "=", "dst", ";", "let", "SrcA", "=", "src", ";", "let", "SrcB", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "SrcC", "=", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Switches", "=", "{", "sw", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ",", "<NUM_LIT>", "}", ";" ]

[ "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_msaa_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_msaa_depth_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image3d_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "sampler_t", "<STR_LIT>", ",", "ValueKind", "::", "Sampler", ")", ".", "Case", "(", "<STR_LIT>", "queue_t", "<STR_LIT>", ",", "ValueKind", "::", "Queue", ")", ".", "Default", "(", "isa", "<", "PointerType", ">", "(", "Ty", ")", "?", "(", "Ty", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUASI", ".", "LOCAL_ADDRESS", "?", "ValueKind", "::", "DynamicSharedPointer", ":" ]

[ "return", "StringSwitch", "<", "ValueKind", ">", "(", "BaseTypeName", ")", ".", "Case", "(", "<STR_LIT>", "image1d_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image1d_array_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image1d_buffer_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_depth_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_msaa_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_array_msaa_depth_t", "<STR_LIT>", ",", "ValueKind", "::", "Image", ")", ".", "Case", "(", "<STR_LIT>", "image2d_depth_t", "<STR_LIT>", ",", "ValueKind" ]

[ "_", "a", ";" ]

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

[ "}" ]

[ "vmlsq_u8", "(", "uint8x16_t", "_", "_", "a", ",", "uint8x16_t", "_", "_", "b", ",", "uint8x16_t", "_", "_", "c", ")", "{", "return", "(", "uint8x16_t", ")", "_", "_", "builtin_neon_vmlsv16qi", "(", "(", "int8x16_t", ")", "_", "_", "a", ",", "(", "int8x16_t", ")", "_", "_", "b", ",", "(", "int8x16_t", ")", "_", "_", "c", ")", ";" ]

[ "<FIXS>", "DAG", ".", "getConstant", "(", "CompOpc", ",", "dl", ",", "MVT", "::", "i32", ")", ",", "<FIXE>" ]

[ "}", "return", "DAG", ".", "getNode", "(", "<STR_LIT>", "::", "<STR_LIT>", ",", "dl", ",", "MVT", "::", "Other", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "<BUGS>", "DAG", ".", "getConstant", "(", "CompOpc", ",", "MVT", "::", "i32", ")", ",", "<BUGE>", "DAG", ".", "getRegister", "(", "PPC", "::", "CR6", ",", "MVT", "::", "i32", ")", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "CompNode", ".", "getValue", "(", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "}" ]

[ "MCSymbol", "*", "PPCFunctionInfo", "::", "getLocalEPSymbol", "(", "MachineFunction", "&", "MF", ")", "const", "{", "const", "DataLayout", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "return", "MF", ".", "getContext", "(", ")", ".", "getOrCreateSymbol", "(", "Twine", "(", "DL", ".", "getPrivateGlobalPrefix", "(", ")", ")", "+", "<STR_LIT>", "func_lep", "<STR_LIT>", "+", "Twine", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ")", ";" ]

[ "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "VT", ",", "Vec", ",", "BitMask", ")", ";" ]

[ "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "assert", "(", "NumElts", "==", "SclVT", ".", "getSizeInBits", "(", ")", "&&", "<STR_LIT>", "Unexpected bool vector size", "<STR_LIT>", ")", ";", "if", "(", "NumElts", ">", "EltSizeInBits", ")", "{", "assert", "(", "(", "NumElts", "%", "EltSizeInBits", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected integer scale", "<STR_LIT>", ")", ";", "unsigned", "Scale", "=", "NumElts", "/", "EltSizeInBits", ";", "EVT", "BroadcastVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "SclVT", ",", "EltSizeInBits", ")", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "BroadcastVT", ",", "N00", ")", ";", "Vec", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Vec", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "Scale", ";", "++", "i", ")", "ShuffleMask", ".", "append", "(", "EltSizeInBits", ",", "i", ")", ";", "Vec", "=", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "DL", ",", "Vec", ",", "Vec", ",", "ShuffleMask", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "hasAVX2", "(", ")", "&&", "NumElts", "<", "EltSizeInBits", "&&", "(", "SclVT", "==", "MVT", "::", "i8", "||", "SclVT", "==", "MVT", "::", "i16", "||", "SclVT", "==", "MVT", "::", "i32", ")", ")", "{", "assert", "(", "(", "EltSizeInBits", "%", "NumElts", ")", "==", "<NUM_LIT>", "&&", "<STR_LIT>", "Unexpected integer scale", "<STR_LIT>", ")", ";", "unsigned", "Scale", "=", "EltSizeInBits", "/", "NumElts", ";", "EVT", "BroadcastVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "SclVT", ",", "NumElts", "*", "Scale", ")", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "BroadcastVT", ",", "N00", ")", ";", "ShuffleMask", ".", "append", "(", "NumElts", "*", "Scale", ",", "<NUM_LIT>", ")", ";", "Vec", "=", "DAG", ".", "getVectorShuffle", "(", "BroadcastVT", ",", "DL", ",", "Vec", ",", "Vec", ",", "ShuffleMask", ")", ";", "Vec", "=", "DAG", ".", "getBitcast", "(", "VT", ",", "Vec", ")", ";", "}", "else", "{", "SDValue", "Scl", "=", "DAG", ".", "getAnyExtOrTrunc", "(", "N00", ",", "DL", ",", "SVT", ")", ";", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "DL", ",", "VT", ",", "Scl", ")", ";", "ShuffleMask", ".", "append", "(", "NumElts", ",", "<NUM_LIT>", ")", ";", "Vec", "=", "DAG", ".", "getVectorShuffle", "(", "VT", ",", "DL", ",", "Vec", ",", "Vec", ",", "ShuffleMask", ")", ";", "}", "SmallVector", "<", "SDValue", ",", "<NUM_LIT>", ">", "Bits", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "int", "BitIdx", "=", "(", "i", "%", "EltSizeInBits", ")", ";", "APInt", "Bit", "=", "APInt", "::", "getBitsSet", "(", "EltSizeInBits", ",", "BitIdx", ",", "BitIdx", "+", "<NUM_LIT>", ")", ";", "Bits", ".", "push_back", "(", "DAG", ".", "getConstant", "(", "Bit", ",", "DL", ",", "SVT", ")", ")", ";", "}", "SDValue", "BitMask", "=", "DAG", ".", "getBuildVector", "(", "VT", ",", "DL", ",", "Bits", ")", ";" ]

[ ">", ";" ]

[ "def", "SwiftWriteP01OneCycle3x", ":", "WriteSequence", "<", "[", "SwiftWriteP01OneCycle", "]", ",", "<NUM_LIT>" ]

[ "ParserMatchClass", "=", "Imm0_7Operand", ";" ]

[ "return", "(", "(", "uint64_t", ")", "Imm", ")", "<", "<NUM_LIT>", ";", "}", "]", ">", "{", "let" ]

[ "MO", ":" ]

[ "if", "(", "isDead", "(", "MI", ",", "DeadPhis", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "HW looping will remove: ", "<STR_LIT>", "<<", "*", "MI", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "for", "(", "MachineOperand", "&" ]

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

[ "const", "MachineOperand", "&", "MO2", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ";", "const", "MachineOperand", "&", "MO3", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "<NUM_LIT>", ")", ";", "O", "<<", "<STR_LIT>", "[", "<STR_LIT>", "<<", "getRegisterName", "(", "MO1", ".", "getReg", "(", ")", ")", ";", "assert", "(", "MO2", ".", "getReg", "(", ")", "&&", "<STR_LIT>", "Invalid so_reg load / store address!", "<STR_LIT>", ")", ";", "O", "<<", "<STR_LIT>", ", ", "<STR_LIT>", "<<", "getRegisterName", "(", "MO2", ".", "getReg", "(", ")", ")", ";", "unsigned", "ShAmt", "=", "MO3", ".", "getImm", "(", ")", ";", "if", "(", "ShAmt", ")", "{", "assert", "(", "ShAmt", "<=", "<NUM_LIT>", "&&", "<STR_LIT>", "Not a valid Thumb2 addressing mode!", "<STR_LIT>", ")", ";", "O", "<<", "<STR_LIT>", ", lsl #" ]

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

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

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

[ "ArrayRef", "<", "int", ">", "Mask", "=", "Shuf", "->", "getMask", "(", ")", ";", "if", "(", "!", "isUndefUpperHalf", "(", "Mask", ")", ")", "return", "SDValue", "(", ")", ";", "int", "HalfIdx1", ",", "HalfIdx2", ";", "SmallVector", "<", "int", ",", "<NUM_LIT>", ">", "HalfMask", "(", "Mask", ".", "size", "(", ")", "/", "<NUM_LIT>", ")", ";", "if", "(", "!", "getHalfShuffleMask", "(", "Mask", ",", "HalfMask", ",", "HalfIdx1", ",", "HalfIdx2", ")", "||", "(", "HalfIdx1", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")", "||", "(", "HalfIdx2", "%", "<NUM_LIT>", "==", "<NUM_LIT>", ")" ]

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

[ "return", "<STR_LIT>", "}", "<BUGS>", "[", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "<BUGE>", "(", "set_attr", "<STR_LIT>", "\t", "<STR_LIT>", ")", "(", "set_attr_alternative", "<STR_LIT>", "[", "(", "const_int", "<NUM_LIT>", ")" ]

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

[ "(", "match_operand", ":", "P", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "P", "CA_REGNO", ")", "(", "gtu", ":", "P", "(", "match_dup", "<NUM_LIT>", ")" ]

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

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "rotate", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "(", "set", "(", "reg", ":", "SI", "T_REG", ")", "(", "lshiftrt", ":", "SI", "(", "match_dup", "<NUM_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>" ]

[ "uint64_t", "Binary", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";" ]

[ "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MCFixupKind", "Fixup", "=", "MCFixupKind", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "<NUM_LIT>", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getExpr", "(", ")", ",", "Fixup", ")", ")", ";", "return", ";", "}" ]

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

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

[ "&", "TM", ")", "{" ]

[ "FunctionPass", "*", "llvm", "::", "createPIC16ISelDag", "(", "PIC16TargetMachine" ]

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

[ "if", "(", "Val", "<=", "SGPR_MAX", ")", "{", "assert", "(", "SGPR_MIN", "==", "<NUM_LIT>", ")", ";", "return", "createSRegOperand", "(", "getSgprClassId", "(", "Width", ")", ",", "Val", "-", "SGPR_MIN", ")", ";", "}", "if", "(", "TTMP_MIN", "<=", "Val", "&&", "Val", "<=", "TTMP_MAX", ")", "{", "return", "createSRegOperand", "(", "getTtmpClassId", "(", "Width", ")", ",", "Val", "-", "TTMP_MIN", ")", ";", "}", "if", "(", "INLINE_INTEGER_C_MIN", "<=", "Val", "&&", "Val", "<=", "INLINE_INTEGER_C_MAX", ")", "return", "decodeIntImmed", "(", "Val", ")", ";", "if", "(", "INLINE_FLOATING_C_MIN", "<=", "Val", "&&", "Val", "<=", "INLINE_FLOATING_C_MAX", ")", "return", "decodeFPImmed", "(", "Width", ",", "Val", ")", ";", "if", "(", "Val", "==", "LITERAL_CONST", ")", "return", "decodeLiteralConstant", "(", ")", ";", "switch", "(", "Width", ")", "{", "case", "OPW32", ":", "case", "OPW16", ":", "case", "OPWV216", ":", "return", "decodeSpecialReg32", "(", "Val", ")", ";", "case", "OPW64", ":", "return", "decodeSpecialReg64", "(", "Val", ")", ";", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unexpected immediate type" ]

[ ">", "acc", ";" ]

[ "class", "VpuInstBinSwTA", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "RegisterClass", "Rsrc1", ",", "RegisterClass", "Rsrc2", ",", "string", "asmstr", ",", "bits", "<", "<NUM_LIT>", ">", "optype", ",", "Operand", "Pred", ",", "list", "<", "dag", ">", "pattern", "=", "[", "]", ">", ":", "VectorInstShort", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dest", ")", ";", "let", "InOperandList", "=", "(", "ins", "Rsrc1", ":", "$", "op1", ",", "Rsrc2", ":", "$", "op2", ",", "DataType", ":", "$", "dt", ",", "SwitchSet", ":", "$", "sw", ",", "MacAcc", ":", "$", "acc", ",", "Rdst", ":", "$", "income", ",", "Pred", ":", "$", "pred", ")", ";", "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_VectorOp", ";", "bits", "<", "<NUM_LIT>", ">", "dest", ";", "bits", "<", "<NUM_LIT>", ">", "op1", ";", "bits", "<", "<NUM_LIT>", ">", "op2", ";", "bits", "<", "<NUM_LIT>", ">", "dt", ";", "bits", "<", "<NUM_LIT>", ">", "sw", ";", "bits", "<", "<NUM_LIT>" ]

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m512d", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_maskz_fmadd_pd", "(", "_", "_", "mmask8", "_", "_", "U", ",", "_", "_", "m512d", "_", "_", "A", ",", "_", "_", "m512d", "_", "_", "B", ",", "_", "_", "m512d", "_", "_", "C", ")", "{", "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_vfmaddpd512_maskz", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "_", "C", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "MM_FROUND_CUR_DIRECTION", ")", ";" ]

[ "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "RegNo", ")", ")", ";" ]

[ "TmpInst", ".", "setOpcode", "(", "Mips", "::", "LDI", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "GP", ")", ")", ";", "const", "MCSymbolRefExpr", "*", "LoSym", "=", "MCSymbolRefExpr", "::", "Create", "(", "<STR_LIT>", "_gp_disp", "<STR_LIT>", ",", "MCSymbolRefExpr", "::", "VK_Mips_ABS_LO", ",", "MCA", ".", "getContext", "(", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "LoSym", ")", ")", ";", "getStreamer", "(", ")", ".", "EmitInstruction", "(", "TmpInst", ",", "STI", ")", ";", "TmpInst", ".", "clear", "(", ")", ";", "TmpInst", ".", "setOpcode", "(", "Mips", "::", "LDIHI", ")", ";", "const", "MCSymbolRefExpr", "*", "HiSym", "=", "MCSymbolRefExpr", "::", "Create", "(", "<STR_LIT>", "_gp_disp", "<STR_LIT>", ",", "MCSymbolRefExpr", "::", "VK_Mips_ABS_HI", ",", "MCA", ".", "getContext", "(", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "HiSym", ")", ")", ";", "getStreamer", "(", ")", ".", "EmitInstruction", "(", "TmpInst", ",", "STI", ")", ";", "TmpInst", ".", "clear", "(", ")", ";", "TmpInst", ".", "setOpcode", "(", "Mips", "::", "ADDu", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "GP", ")", ")", ";", "TmpInst", ".", "addOperand", "(", "MCOperand", "::", "CreateReg", "(", "Mips", "::", "GP", ")", ")", ";" ]

[ ":", "DI" ]

[ "(", "plus", ":", "DI", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "sign_extend", ":", "DI", "(", "vec_select", ":", "HI", "(", "match_operand", ":", "V4HI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", ")", "(", "mult", ":", "DI", "(", "sign_extend", ":", "DI", "(", "vec_select", ":", "HI", "(", "match_dup", "<NUM_LIT>", ")", "(", "parallel", "[", "(", "const_int", "<NUM_LIT>", ")", "]", ")", ")", ")", "(", "sign_extend" ]

[ "int", "parity", ")", "{" ]

[ "void", "func_fma_steering", "::", "update_balance", "(" ]

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

[ "static", "bool", "have_compare_and_set_mask", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "TARGET_P9_MINMAX", ";", "case", "E_KFmode", ":", "case", "E_TFmode", ":", "return", "TARGET_POWER10", "&&", "TARGET_FLOAT128_HW", "&&", "FLOAT128_IEEE_P", "(" ]

[ "void", "AArch64FrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "if", "(", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", ";", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "AArch64FunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "unsigned", "UnspilledCSGPR", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "unsigned", "UnspilledCSGPRPaired", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SavedRegs", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "SavedRegs", ".", "set", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "unsigned", "BasePointerReg", "=", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "BasePointerReg", "=", "RegInfo", "->", "getBaseRegister", "(", ")", ";", "bool", "ExtraCSSpill", "=", "false", ";", "const", "MCPhysReg", "*", "CSRegs", "=", "RegInfo", "->", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "<NUM_LIT>", ";", "CSRegs", "[", "i", "]", ";", "++", "i", ")", "{", "const", "unsigned", "Reg", "=", "CSRegs", "[", "i", "]", ";", "if", "(", "Reg", "==", "BasePointerReg", ")", "SavedRegs", ".", "set", "(", "Reg", ")", ";", "bool", "RegUsed", "=", "SavedRegs", ".", "test", "(", "Reg", ")", ";", "unsigned", "PairedReg", "=", "CSRegs", "[", "i", "^", "<NUM_LIT>", "]", ";", "if", "(", "!", "RegUsed", ")", "{", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "Reg", ")", "&&", "!", "RegInfo", "->", "isReservedReg", "(", "MF", ",", "Reg", ")", ")", "{", "UnspilledCSGPR", "=", "Reg", ";", "UnspilledCSGPRPaired", "=", "PairedReg", ";", "}", "continue", ";", "}", "if", "(", "produceCompactUnwindFrame", "(", "MF", ")", "&&", "!", "SavedRegs", ".", "test", "(", "PairedReg", ")", ")", "{", "SavedRegs", ".", "set", "(", "PairedReg", ")", ";", "if", "(", "<STR_LIT>", "::", "<STR_LIT>", ".", "contains", "(", "PairedReg", ")", "&&", "!", "RegInfo", "->", "isReservedReg", "(", "MF", ",", "PairedReg", ")", ")", "ExtraCSSpill", "=", "true", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "*** determineCalleeSaves\\nUsed CSRs:", "<STR_LIT>", ";", "for", "(", "int", "Reg", "=", "SavedRegs", ".", "find_first", "(", ")", ";", "Reg", "!=", "-", "<NUM_LIT>", ";", "Reg", "=", "SavedRegs", ".", "find_next", "(", "Reg", ")", ")", "dbgs", "(", ")", "<<", "'", "'", "<<", "PrintReg", "(", "Reg", ",", "RegInfo", ")", ";", "dbgs", "(", ")", "<<", "<STR_LIT>", "\\n", "<STR_LIT>", ";", ")", ";", "unsigned", "NumRegsSpilled", "=", "SavedRegs", ".", "count", "(", ")", ";", "bool", "CanEliminateFrame", "=", "NumRegsSpilled", "==", "<NUM_LIT>", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "MFI", ".", "estimateStackSize", "(", "MF", ")", "+", "<NUM_LIT>", "*", "NumRegsSpilled", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Estimated stack frame size: ", "<STR_LIT>", "<<", "CFSize", "<<", "<STR_LIT>", " bytes.\\n", "<STR_LIT>", ")", ";", "bool", "BigStack", "=", "(", "CFSize", ">=", "<NUM_LIT>", ")", ";", "if", "(", "BigStack", "||", "!", "CanEliminateFrame", "||", "RegInfo", "->", "cannotEliminateFrame", "(", "MF", ")", ")", "AFI", "->", "setHasStackFrame", "(", "true", ")", ";", "if", "(", "BigStack", "&&", "!", "ExtraCSSpill", ")", "{", "if", "(", "UnspilledCSGPR", "!=", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Spilling ", "<STR_LIT>", "<<", "PrintReg", "(", "UnspilledCSGPR", ",", "RegInfo", ")", "<<", "<STR_LIT>", " to get a scratch register.\\n", "<STR_LIT>", ")", ";", "SavedRegs", ".", "set", "(", "UnspilledCSGPR", ")", ";", "if", "(", "produceCompactUnwindFrame", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "UnspilledCSGPRPaired", ")", ";", "ExtraCSSpill", "=", "true", ";", "NumRegsSpilled", "=", "SavedRegs", ".", "count", "(", ")", ";", "}", "if", "(", "!", "ExtraCSSpill", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "int", "FI", "=", "MFI", ".", "CreateStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "RC", "->", "getAlignment", "(", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "FI", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "No available CS registers, allocated fi#", "<STR_LIT>", "<<", "FI", "<<", "<STR_LIT>", " as the emergency spill slot.\\n", "<STR_LIT>", ")", ";", "}", "}", "AFI", "->", "setCalleeSavedStackSize", "(", "alignTo", "(", "<NUM_LIT>", "*", "NumRegsSpilled", ",", "<NUM_LIT>", ")", ")", ";", "}" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

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

[ "}", "]", ">", "{", "let", "ParserMatchClass", "=", "TBZImm32_63Operand", ";" ]

[ "def", "tbz_imm32_63", ":", "Operand", "<", "i64", ">", ",", "ImmLeaf", "<", "i64", ",", "[", "{", "return", "(", "(", "(", "uint32_t", ")", "Imm", ")", ">", "<NUM_LIT>", ")", "&", "&", "(", "(", "(", "uint32_t", ")", "Imm", ")", "<", "<NUM_LIT>", ")", ";" ]

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

[ "let", "Pattern", "=", "pattern", ";", "let", "Itinerary", "=", "IIC_ScalarOp", ";", "let", "DecoderMethod", "=", "<STR_LIT>", ";", "let", "SrcA", "=", "<NUM_LIT>", ";", "let", "HasImm", "=", "<NUM_LIT>", ";" ]

[ "let", "isRestrictNoSlot1Store", "=", "<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", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";" ]

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

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

[ "<FIXS>", "&&", "!", "rtx_equal_p", "(", "dst", ",", "src1", ")", "&&", "!", "use_ndd", ")", "<FIXE>" ]

[ "if", "(", "reload_completed", "&&", "code", "==", "PLUS", "<BUGS>", "&&", "!", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "<BUGE>", "{", "emit_insn", "(", "op", ")", ";" ]

[ "}" ]

[ "static", "_", "_", "inline", "_", "_", "m128", "_", "_", "attribute__", "(", "(", "_", "_", "always_inline__", ")", ")", "_", "mm_castpd_ps", "(", "_", "_", "m128d", "_", "_", "A", ")", "{", "return", "(", "_", "_", "m128", ")", "_", "_", "A", ";" ]

[ "default", ":" ]

[ "case", "POST_DEC", ":", "case", "POST_INC", ":", "insn", "=", "(", "rtx", ")", "data", ";", "REG_NOTES", "(", "insn", ")", "=", "alloc_EXPR_LIST", "(", "REG_INC", ",", "XEXP", "(", "*", "x", ",", "<NUM_LIT>", ")", ",", "REG_NOTES", "(", "insn", ")", ")", ";", "return", "-", "<NUM_LIT>", ";" ]

[ "}" ]

[ "void", "MCLDInitializeAArch64LDTargetInfo", "(", ")", "{", "mcld", "::", "RegisterTarget", "<", "llvm", "::", "Triple", "::", "aarch64", ">", "X", "(", "TheAArch64Target", ",", "<STR_LIT>", "aarch64", "<STR_LIT>", ")", ";" ]

[ "b", ";" ]

[ "return", "_", "_", "a", "&", "~", "_", "_" ]

[ "static", "void", "pa_asm_output_mi_thunk", "(", "FILE", "*", "file", ",", "tree", "thunk_fndecl", ",", "HOST_WIDE_INT", "delta", ",", "HOST_WIDE_INT", "vcall_offset", "ATTRIBUTE_UNUSED", ",", "tree", "function", ")", "{", "static", "unsigned", "int", "current_thunk_number", ";", "int", "val_14", "=", "VAL_14_BITS_P", "(", "delta", ")", ";", "unsigned", "int", "old_last_address", "=", "last_address", ",", "nbytes", "=", "<NUM_LIT>", ";", "char", "label", "[", "<NUM_LIT>", "]", ";", "rtx", "xoperands", "[", "<NUM_LIT>", "]", ";", "xoperands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "DECL_RTL", "(", "function", ")", ",", "<NUM_LIT>", ")", ";", "xoperands", "[", "<NUM_LIT>", "]", "=", "XEXP", "(", "DECL_RTL", "(", "thunk_fndecl", ")", ",", "<NUM_LIT>", ")", ";", "xoperands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "delta", ")", ";", "final_start_function", "(", "emit_barrier", "(", ")", ",", "file", ",", "<NUM_LIT>", ")", ";", "if", "(", "(", "!", "TARGET_LONG_CALLS", "&&", "TARGET_SOM", "&&", "!", "TARGET_PORTABLE_RUNTIME", "&&", "!", "(", "flag_pic", "&&", "TREE_PUBLIC", "(", "function", ")", ")", "&&", "(", "TARGET_GAS", "||", "last_address", "<", "<NUM_LIT>", ")", ")", "||", "(", "!", "TARGET_LONG_CALLS", "&&", "!", "TARGET_SOM", "&&", "!", "TARGET_PORTABLE_RUNTIME", "&&", "(", "(", "targetm_common", ".", "have_named_sections", "&&", "DECL_SECTION_NAME", "(", "thunk_fndecl", ")", "!=", "NULL", "&&", "(", "(", "!", "TARGET_64BIT", "&&", "(", "DECL_SECTION_NAME", "(", "thunk_fndecl", ")", "!=", "DECL_SECTION_NAME", "(", "function", ")", ")", ")", "||", "(", "(", "DECL_SECTION_NAME", "(", "thunk_fndecl", ")", "==", "DECL_SECTION_NAME", "(", "function", ")", ")", "&&", "last_address", "<", "<NUM_LIT>", ")", ")", ")", "||", "(", "targetm_common", ".", "have_named_sections", "&&", "DECL_SECTION_NAME", "(", "thunk_fndecl", ")", "==", "NULL", "&&", "DECL_SECTION_NAME", "(", "function", ")", "==", "NULL", "&&", "total_code_bytes", "<", "MAX_PCREL17F_OFFSET", ")", "||", "(", "!", "targetm_common", ".", "have_named_sections", "&&", "total_code_bytes", "<", "MAX_PCREL17F_OFFSET", ")", ")", ")", ")", "{", "if", "(", "!", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "b %0", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "!", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "output_asm_insn", "(", "<STR_LIT>", "b,l .+8,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "TARGET_GAS", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "addil L'%0-$PIC_pcrel$0+4,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "else", "{", "xoperands", "[", "<NUM_LIT>", "]", "=", "GEN_INT", "(", "val_14", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "addil L'%0-%1-%3,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "if", "(", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "bv %%r0(%%r1)", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "bv,n %%r0(%%r1)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldil L'%0,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%0(%%r1),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "!", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bv %%r0(%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "else", "if", "(", "TARGET_SOM", "&&", "flag_pic", "&&", "TREE_PUBLIC", "(", "function", ")", ")", "{", "ASM_GENERATE_INTERNAL_LABEL", "(", "label", ",", "<STR_LIT>", "LTHN", "<STR_LIT>", ",", "current_thunk_number", ")", ";", "xoperands", "[", "<NUM_LIT>", "]", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "label", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "addil LT'%3,%%r19", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw RT'%3(%%r1),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw 0(%%sr0,%%r22),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bb,>=,n %%r22,30,.+16", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "depi 0,31,2,%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw 4(%%sr0,%%r22),%%r19", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldw 0(%%sr0,%%r22),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "!", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "if", "(", "TARGET_PA_20", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "bve (%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "if", "(", "TARGET_NO_SPACE_REGS", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "be 0(%%sr4,%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldsid (%%sr0,%%r22),%%r21", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "mtsp %%r21,%%sr0", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "be 0(%%sr0,%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "if", "(", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "{bl|b,l} .+8,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "TARGET_SOM", "||", "!", "TARGET_GAS", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "addil L'%0-%1-8,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%0-%1-8(%%r1),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "addil L'%0-$PIC_pcrel$0+4,%%r1", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "if", "(", "!", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "bv %%r0(%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "else", "{", "if", "(", "!", "val_14", ")", "output_asm_insn", "(", "<STR_LIT>", "addil L'%2,%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "ldil L'%0,%%r22", "<STR_LIT>", ",", "xoperands", ")", ";", "output_asm_insn", "(", "<STR_LIT>", "be R'%0(%%sr4,%%r22)", "<STR_LIT>", ",", "xoperands", ")", ";", "if", "(", "val_14", ")", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo %2(%%r26),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "else", "{", "output_asm_insn", "(", "<STR_LIT>", "ldo R'%2(%%r1),%%r26", "<STR_LIT>", ",", "xoperands", ")", ";", "nbytes", "+=", "<NUM_LIT>", ";", "}", "}", "final_end_function", "(", ")", ";", "if", "(", "TARGET_SOM", "&&", "flag_pic", "&&", "TREE_PUBLIC", "(", "function", ")", ")", "{", "switch_to_section", "(", "data_section", ")", ";", "output_asm_insn", "(", "<STR_LIT>", ".align 4", "<STR_LIT>", ",", "xoperands", ")", ";", "ASM_OUTPUT_LABEL", "(", "file", ",", "label", ")", ";", "output_asm_insn", "(", "<STR_LIT>", ".word P'%0", "<STR_LIT>", ",", "xoperands", ")", ";", "}", "current_thunk_number", "++", ";", "nbytes", "=", "(", "(", "nbytes", "+", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "<NUM_LIT>", ")", "&", "~", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "<NUM_LIT>", ")", ")", ";", "last_address", "+=", "nbytes", ";", "if", "(", "old_last_address", ">", "last_address", ")", "last_address", "=", "UINT_MAX", ";", "update_total_code_bytes", "(", "nbytes", ")", ";", "}" ]

[ "Output", "the", "assembler", "code", "for", "a", "thunk", "function", ".", "THUNK_DECL", "is", "the", "declaration", "for", "the", "thunk", "function", "itself", ",", "FUNCTION", "is", "the", "decl", "for", "the", "target", "function", ".", "DELTA", "is", "an", "immediate", "constant", "offset", "to", "be", "added", "to", "THIS", ".", "If", "VCALL_OFFSET", "is", "nonzero", ",", "the", "word", "at", "*", "(", "*", "this", "+", "vcall_offset", ")", "should", "be", "added", "to", "THIS", "." ]

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

[ "(", "define_mode_iterator", "VDQI", "[", "V8QI", "V16QI", "V4HI", "V8HI", "V2SI" ]

[ ")", ";" ]

[ "unsigned", "HexagonInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "return", "getInstrTimingClassLatency", "(", "ItinData", ",", "MI" ]

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

[ "TargetRegistry", "::", "RegisterMCInstrInfo", "(", "TheBlackfinTarget" ]

[ "unsigned", "ix", ";" ]

[ "static", "int", "no_previous_def", "(", "tree", "function_name", ")", "{", "branch_island", "*", "bi", ";" ]

[ "VPMSUMH", ":" ]

[ "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "if", "(", "Partial", ")", "SwapVector", "[", "VecIdx", "]", ".", "MentionsPartialVR", "=", "<NUM_LIT>", ";", "else", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "XXPERMDI", ":", "{", "int", "immed", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "immed", "==", "<NUM_LIT>", ")", "{", "unsigned", "trueReg1", "=", "lookThruCopyLike", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "VecIdx", ")", ";", "unsigned", "trueReg2", "=", "lookThruCopyLike", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "VecIdx", ")", ";", "if", "(", "trueReg1", "==", "trueReg2", ")", "SwapVector", "[", "VecIdx", "]", ".", "IsSwap", "=", "<NUM_LIT>", ";", "else", "{", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "SpecialHandling", "=", "SHValues", "::", "SH_XXPERMDI", ";", "}", "}", "else", "if", "(", "immed", "==", "<NUM_LIT>", "||", "immed", "==", "<NUM_LIT>", ")", "{", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "SpecialHandling", "=", "SHValues", "::", "SH_XXPERMDI", ";", "unsigned", "trueReg1", "=", "lookThruCopyLike", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "VecIdx", ")", ";", "unsigned", "trueReg2", "=", "lookThruCopyLike", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ",", "VecIdx", ")", ";", "if", "(", "trueReg1", "==", "trueReg2", ")", "SwapVector", "[", "VecIdx", "]", ".", "MentionsPhysVR", "=", "<NUM_LIT>", ";", "}", "else", "{", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "SpecialHandling", "=", "SHValues", "::", "SH_XXPERMDI", ";", "}", "break", ";", "}", "case", "PPC", "::", "LVX", ":", "SwapVector", "[", "VecIdx", "]", ".", "IsLoad", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "LXVD2X", ":", "case", "PPC", "::", "LXVW4X", ":", "SwapVector", "[", "VecIdx", "]", ".", "IsLoad", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "IsSwap", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "LXSDX", ":", "case", "PPC", "::", "LXSSPX", ":", "case", "PPC", "::", "XFLOADf64", ":", "case", "PPC", "::", "XFLOADf32", ":", "SwapVector", "[", "VecIdx", "]", ".", "IsLoad", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "STVX", ":", "SwapVector", "[", "VecIdx", "]", ".", "IsStore", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "STXVD2X", ":", "case", "PPC", "::", "STXVW4X", ":", "SwapVector", "[", "VecIdx", "]", ".", "IsStore", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "IsSwap", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "COPY", ":", "if", "(", "isVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "&&", "isVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "else", "if", "(", "isScalarVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "&&", "isScalarVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "break", ";", "case", "PPC", "::", "SUBREG_TO_REG", ":", "{", "if", "(", "isVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "&&", "isVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "else", "if", "(", "isVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", "&&", "isScalarVecReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ")", "{", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "SpecialHandling", "=", "SHValues", "::", "SH_COPYWIDEN", ";", "}", "break", ";", "}", "case", "PPC", "::", "VSPLTB", ":", "case", "PPC", "::", "VSPLTH", ":", "case", "PPC", "::", "VSPLTW", ":", "case", "PPC", "::", "XXSPLTW", ":", "SwapVector", "[", "VecIdx", "]", ".", "IsSwappable", "=", "<NUM_LIT>", ";", "SwapVector", "[", "VecIdx", "]", ".", "SpecialHandling", "=", "SHValues", "::", "SH_SPLAT", ";", "break", ";", "case", "PPC", "::", "INLINEASM", ":", "case", "PPC", "::", "INLINEASM_BR", ":", "case", "PPC", "::", "EXTRACT_SUBREG", ":", "case", "PPC", "::", "INSERT_SUBREG", ":", "case", "PPC", "::", "COPY_TO_REGCLASS", ":", "case", "PPC", "::", "LVEBX", ":", "case", "PPC", "::", "LVEHX", ":", "case", "PPC", "::", "LVEWX", ":", "case", "PPC", "::", "LVSL", ":", "case", "PPC", "::", "LVSR", ":", "case", "PPC", "::", "LVXL", ":", "case", "PPC", "::", "STVEBX", ":", "case", "PPC", "::", "STVEHX", ":", "case", "PPC", "::", "STVEWX", ":", "case", "PPC", "::", "STVXL", ":", "case", "PPC", "::", "STXSDX", ":", "case", "PPC", "::", "STXSSPX", ":", "case", "PPC", "::", "VCIPHER", ":", "case", "PPC", "::", "VCIPHERLAST", ":", "case", "PPC", "::", "VMRGHB", ":", "case", "PPC", "::", "VMRGHH", ":", "case", "PPC", "::", "VMRGHW", ":", "case", "PPC", "::", "VMRGLB", ":", "case", "PPC", "::", "VMRGLH", ":", "case", "PPC", "::", "VMRGLW", ":", "case", "PPC", "::", "VMULESB", ":", "case", "PPC", "::", "VMULESH", ":", "case", "PPC", "::", "VMULESW", ":", "case", "PPC", "::", "VMULEUB", ":", "case", "PPC", "::", "VMULEUH", ":", "case", "PPC", "::", "VMULEUW", ":", "case", "PPC", "::", "VMULOSB", ":", "case", "PPC", "::", "VMULOSH", ":", "case", "PPC", "::", "VMULOSW", ":", "case", "PPC", "::", "VMULOUB", ":", "case", "PPC", "::", "VMULOUH", ":", "case", "PPC", "::", "VMULOUW", ":", "case", "PPC", "::", "VNCIPHER", ":", "case", "PPC", "::", "VNCIPHERLAST", ":", "case", "PPC", "::", "VPERM", ":", "case", "PPC", "::", "VPERMXOR", ":", "case", "PPC", "::", "VPKPX", ":", "case", "PPC", "::", "VPKSHSS", ":", "case", "PPC", "::", "VPKSHUS", ":", "case", "PPC", "::", "VPKSDSS", ":", "case", "PPC", "::", "VPKSDUS", ":", "case", "PPC", "::", "VPKSWSS", ":", "case", "PPC", "::", "VPKSWUS", ":", "case", "PPC", "::", "VPKUDUM", ":", "case", "PPC", "::", "VPKUDUS", ":", "case", "PPC", "::", "VPKUHUM", ":", "case", "PPC", "::", "VPKUHUS", ":", "case", "PPC", "::", "VPKUWUM", ":", "case", "PPC", "::", "VPKUWUS", ":", "case", "PPC", "::", "VPMSUMB", ":", "case", "PPC", "::", "VPMSUMD", ":", "case", "PPC", "::" ]

[ "assert", "(", "(", "Kind", ".", "isReadOnly", "(", ")", "||", "Kind", ".", "isReadOnlyWithRel", "(", ")", ")", "&&", "<STR_LIT>", "Unknown section kind", "<STR_LIT>", ")", ";" ]

[ "const", "MCSection", "*", "XCoreTargetObjectFile", "::", "getSectionForConstant", "(", "SectionKind", "Kind", ")", "const", "{", "if", "(", "Kind", ".", "isMergeableConst4", "(", ")", ")", "return", "MergeableConst4Section", ";", "if", "(", "Kind", ".", "isMergeableConst8", "(", ")", ")", "return", "MergeableConst8Section", ";", "if", "(", "Kind", ".", "isMergeableConst16", "(", ")", ")", "return", "MergeableConst16Section", ";" ]

[ "}" ]

[ "SDValue", "InVec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SCALAR_TO_VECTOR", ",", "dl", ",", "VecInVT", ",", "Src", ")", ";", "if", "(", "IsStrict", ")", "{", "SDValue", "CvtVec", "=", "DAG", ".", "getNode", "(", "Op", ".", "getOpcode", "(", ")", ",", "dl", ",", "{", "VecVT", ",", "MVT", "::", "Other", "}", ",", "{", "Op", ".", "getOperand", "(", "<NUM_LIT>", ")", ",", "InVec", "}", ")", ";", "SDValue", "Chain", "=", "CvtVec", ".", "getValue", "(", "<NUM_LIT>", ")", ";", "SDValue", "Value", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "VT", ",", "CvtVec", ",", "DAG", ".", "getIntPtrConstant", "(", "<NUM_LIT>", ",", "dl", ")", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "{", "Value", ",", "Chain", "}", ",", "dl", ")", ";" ]

[ "<", "[", "WriteVLD4", "]", ">", ";" ]

[ "def", "VLD1d64QPseudoWB_fixed", ":", "VLDQQWBfixedPseudo", "<", "IIC_VLD1x4", ">", ",", "Sched" ]

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

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isNewValue", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "int", "NumOps", "=", "<NUM_LIT>", ";", "int", "Ops", "[", "<NUM_LIT>", "]", ";", "for", "(", "int", "OpName", ":", "{", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ",", "AMDGPU", "::", "OpName", "::", "src2_modifiers", "}", ")", "{", "int", "Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "Opc", ",", "OpName", ")", ";", "if", "(", "Idx", "==", "-", "<NUM_LIT>", ")", "break", ";", "Ops", "[", "NumOps", "++", "]", "=", "MI", "->", "getOperand", "(", "Idx", ")", ".", "getImm", "(", ")", ";", "}", "const", "bool", "HasDstSel", "=", "NumOps", ">", "<NUM_LIT>", "&&", "Mod", "==", "<STR_LIT>", "::", "<STR_LIT>", "&&", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "const", "bool", "IsPacked", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "<STR_LIT>", "::", "<STR_LIT>", ";", "if", "(", "allOpsDefaultValue", "(", "Ops", ",", "NumOps", ",", "Mod", ",", "IsPacked", ",", "HasDstSel", ")", ")", "return", ";", "O", "<<", "Name", ";", "for", "(", "int", "I", "=", "<NUM_LIT>", ";", "I", "<", "NumOps", ";", "++", "I", ")", "{", "if", "(", "I", "!=", "<NUM_LIT>", ")", "O", "<<", "'", ",", "'", ";", "O", "<<", "!", "!", "(", "Ops", "[", "I", "]", "&", "Mod", ")", ";", "}", "if", "(", "HasDstSel", ")", "{", "O", "<<", "'", ",", "'", "<<", "!", "!", "(", "Ops", "[", "<NUM_LIT>", "]", "&", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "O", "<<", "'", "]", "'", ";" ]

[ "}" ]

[ "IntExt", "=", "ISD", "::", "NON_EXTLOAD", ";", "break", ";", "default", ":", "IntExt", "=", "ISD", "::", "SEXTLOAD", ";", "break", ";", "}", "if", "(", "N", "->", "getExtensionType", "(", ")", "!=", "IntExt", ")", "return", "nullptr", ";", "if", "(", "C", "->", "getNumOperands", "(", ")", "<", "<NUM_LIT>", "||", "Loc", ".", "getNode", "(", ")", "!=", "C", "->", "getOperand", "(", "<NUM_LIT>", ")", ".", "getNode", "(", ")", ")", "return", "nullptr", ";", "if", "(", "MachineSDNode", "*", "L", "=", "LoadInstrForLoadIntrinsic", "(", "C", ")", ")", "{", "SDNode", "*", "S", "=", "StoreInstrForLoadIntrinsic", "(", "L", ",", "C", ")", ";", "SDValue", "F", "[", "]", "=", "{", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "C", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "C", ",", "<NUM_LIT>", ")", "}", ";", "SDValue", "T", "[", "]", "=", "{", "SDValue", "(", "L", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "S", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "L", ",", "<NUM_LIT>", ")", ",", "SDValue", "(", "S", ",", "<NUM_LIT>", ")", "}", ";", "ReplaceUses", "(", "F", ",", "T", ",", "array_lengthof", "(", "T", ")", ")", ";", "CurDAG", "->", "RemoveDeadNodes", "(", ")", ";", "return", "L", ";", "}", "return", "nullptr", ";" ]

[ "static", "rtx", "s390_execute_label", "(", "rtx", "insn", ")", "{", "if", "(", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ")", "==", "UNSPEC_EXECUTE", ")", "return", "XVECEXP", "(", "XVECEXP", "(", "PATTERN", "(", "insn", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "return", "NULL_RTX", ";", "}" ]

[ "Check", "whether", "INSN", "is", "an", "execute", ".", "Return", "the", "label_ref", "to", "its", "execute", "target", "template", "if", "so", ",", "NULL_RTX", "otherwise", "." ]

[ ",", "-", "(", "_", "_", "v8sf", ")", "_", "_", "C", ")", ";" ]

[ "return", "(", "_", "_", "m256", ")", "_", "_", "builtin_ia32_vfmaddsubps256", "(", "(", "_", "_", "v8sf", ")", "_", "_", "A", ",", "(", "_", "_", "v8sf", ")", "_", "_", "B" ]

[ "default", ":" ]

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

[ "<FIXS>", "#", "include", "<STR_LIT>", "llvm/Support/Debug.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/ADT/Statistic.h", "<STR_LIT>", "<FIXE>" ]

[ "#", "include", "<STR_LIT>", "llvm/Target/TargetMachine.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/GetElementPtrTypeIterator.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "llvm/Support/InstVisitor.h", "<STR_LIT>", "<BUGS>", "#", "include", "<STR_LIT>", "Support/Debug.h", "<STR_LIT>", "#", "include", "<STR_LIT>", "Support/Statistic.h", "<STR_LIT>", "<BUGE>", "#", "include", "vector", ">", "using", "namespace", "llvm", ";" ]

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

[ "{", "rtx", "p", "=", "aarch64_simd_vect_par_cnst_half", "(", "<", "MODE", ">", "mode", ",", "<", "nunits", ">", ",", "true", ")", "emit_insn", "(", "gen_aarch64_sqdml", "<", "SBINQOPS", ":", "as", ">", "l2_lane", "<", "mode", ">", "_internal", "(", "operands", "[", "<NUM_LIT>", "]", "," ]

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

[ "def", "_register", ":", "NLdSt", "<", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ",", "op7_4", ",", "(", "outs", "VecListDPair", ":", "$", "Vd", ",", "GPR", ":", "$", "wb", ")", ",", "(", "ins", "AddrMode", ":", "$", "Rn", ",", "rGPR", ":", "$", "Rm", ")", ",", "IIC_VLD1x2u", ",", "<STR_LIT>", ",", "Dt", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVLD2", "]", ">", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";" ]

[ "}", ")" ]

[ "emit_insn", "(", "gen_xorsi3", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ")", ")", "DONE" ]

[ "}" ]

[ "if", "(", "ST", "->", "getDarwinDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "return", "true", ";", "return", "LoopHasReductions", ";" ]

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

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

[ "MRI", ".", "replaceRegWith", "(", "Dest", ".", "getReg", "(", ")", ",", "FullDestReg", ")", ";" ]

[ "MachineBasicBlock", "::", "iterator", "MII", "=", "Inst", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "get", "(", "Opcode", ")", ";", "const", "TargetRegisterClass", "*", "Src0RC", "=", "Src0", ".", "isReg", "(", ")", "?", "MRI", ".", "getRegClass", "(", "Src0", ".", "getReg", "(", ")", ")", ":", "&", "AMDGPU", "::", "SGPR_32RegClass", ";", "const", "TargetRegisterClass", "*", "Src0SubRC", "=", "RI", ".", "getSubRegClass", "(", "Src0RC", ",", "AMDGPU", "::", "sub0", ")", ";", "MachineOperand", "SrcReg0Sub0", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub0", ",", "Src0SubRC", ")", ";", "const", "TargetRegisterClass", "*", "DestRC", "=", "MRI", ".", "getRegClass", "(", "Dest", ".", "getReg", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "DestSubRC", "=", "RI", ".", "getSubRegClass", "(", "DestRC", ",", "AMDGPU", "::", "sub0", ")", ";", "unsigned", "DestSub0", "=", "MRI", ".", "createVirtualRegister", "(", "DestRC", ")", ";", "MachineInstr", "*", "LoHalf", "=", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub0", ")", ".", "addOperand", "(", "SrcReg0Sub0", ")", ";", "MachineOperand", "SrcReg0Sub1", "=", "buildExtractSubRegOrImm", "(", "MII", ",", "MRI", ",", "Src0", ",", "Src0RC", ",", "AMDGPU", "::", "sub1", ",", "Src0SubRC", ")", ";", "unsigned", "DestSub1", "=", "MRI", ".", "createVirtualRegister", "(", "DestSubRC", ")", ";", "MachineInstr", "*", "HiHalf", "=", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "InstDesc", ",", "DestSub1", ")", ".", "addOperand", "(", "SrcReg0Sub1", ")", ";", "unsigned", "FullDestReg", "=", "MRI", ".", "createVirtualRegister", "(", "DestRC", ")", ";", "BuildMI", "(", "MBB", ",", "MII", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "REG_SEQUENCE", ")", ",", "FullDestReg", ")", ".", "addReg", "(", "DestSub0", ")", ".", "addImm", "(", "AMDGPU", "::", "sub0", ")", ".", "addReg", "(", "DestSub1", ")", ".", "addImm", "(", "AMDGPU", "::", "sub1", ")", ";" ]

[ "static", "bool", "find_alignment_op", "(", "rtx_insn", "*", "insn", ",", "rtx", "base_reg", ",", "vec", "<", "rtx_insn", "*", ">", "*", "and", "_", "insns", ",", "vec", "<", "rtx", ">", "*", "and", "_", "ops", ")", "{", "df_ref", "base_use", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "rtx", "and", "_", "operation", "=", "<NUM_LIT>", ";", "FOR_EACH_INSN_INFO_USE", "(", "base_use", ",", "insn_info", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "DF_REF_REG", "(", "base_use", ")", ",", "base_reg", ")", ")", "continue", ";", "struct", "df_link", "*", "base_def_link", "=", "DF_REF_CHAIN", "(", "base_use", ")", ";", "if", "(", "!", "base_def_link", ")", "return", "false", ";", "while", "(", "base_def_link", ")", "{", "if", "(", "DF_REF_IS_ARTIFICIAL", "(", "base_def_link", "->", "ref", ")", ")", "return", "false", ";", "rtx_insn", "*", "and", "_", "insn", "=", "DF_REF_INSN", "(", "base_def_link", "->", "ref", ")", ";", "and", "_", "operation", "=", "alignment_mask", "(", "and", "_", "insn", ")", ";", "if", "(", "!", "and", "_", "operation", ")", "return", "false", ";", "and", "_", "insns", "->", "safe_push", "(", "and", "_", "insn", ")", ";", "and", "_", "ops", "->", "safe_push", "(", "and", "_", "operation", ")", ";", "base_def_link", "=", "base_def_link", "->", "next", ";", "}", "}", "return", "and", "_", "operation", ";", "}" ]

[ "Given", "INSN", "that", "'s", "a", "load", "or", "store", "based", "at", "BASE_REG", ",", "check", "if", "all", "of", "its", "feeding", "computations", "align", "its", "address", "on", "a", "16-byte", "boundary", ".", "If", "so", ",", "return", "true", "and", "add", "all", "definition", "insns", "into", "AND_INSNS", "and", "their", "corresponding", "fully-expanded", "rtxes", "for", "the", "masking", "operations", "into", "AND_OPS", "." ]

[ "}" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";" ]

[ ";" ]

[ "gcc_assert", "(", "XVECLEN", "(", "src", ",", "<NUM_LIT>", ")", "==", "<NUM_LIT>", ")", ";", "rtx", "p0", "=", "XVECEXP", "(", "src", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "src", ")", "==", "UNSPEC", "&&", "XINT", "(", "src", ",", "<NUM_LIT>", ")", "==", "UNSPEC_EMBEDDED_ROUNDING", ")", ";", "rtx", "res", "=", "gen_rtx_SET", "(", "SET_DEST", "(", "pat", ")", ",", "p0", ")", ";", "return", "res" ]

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

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

[ "MBB", ".", "push_back", "(", "Waitcnt", ")", ";" ]

[ "return", ";", "}", "MachineBasicBlock", "::", "iterator", "It", "=", "MBB", ".", "end", "(", ")", ";", "MachineInstr", "*", "MI", "=", "&", "*", "(", "--", "It", ")", ";", "if", "(", "MI", "->", "isBranch", "(", ")", ")", "{", "MBB", ".", "insert", "(", "It", ",", "Waitcnt", ")", ";", "}", "else", "{" ]

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

[ "def", "rr", ":", "ALUInst", "<", "<NUM_LIT>", ",", "(", "outs", "GRRegs", ":", "$", "dst", ")", ",", "(", "ins", "GRRegs", ":", "$", "src1", ",", "GRRegs", ":", "$", "src2", ")", ",", "!", "strconcat", "(", "opstr", ",", "<STR_LIT>", ")", ",", "[", "(", "set", "i32", ":", "$", "dst", ",", "(", "opnode", "i32", ":", "$", "src1", ",", "i32", ":", "$", "src2", ")", ")", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "dst", ";" ]

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

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

[ ")", ";" ]

[ "case", "AsmToken", "::", "Identifier", ":", "StringRef", "Name", "=", "getLexer", "(", ")", ".", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "unsigned", "RegNo", "=", "MatchRegisterName", "(", "Name", ")", ";", "if", "(", "RegNo", "==", "<NUM_LIT>", ")", "{", "RegNo", "=", "MatchRegisterAltName", "(", "Name", ")", ";", "if", "(", "RegNo", "==", "<NUM_LIT>", ")", "return", "MatchOperand_NoMatch", ";", "}", "getLexer", "(", ")", ".", "Lex", "(" ]

[ "<NUM_LIT>", ";" ]

[ "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[", "PC", "]", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=" ]

[ "if", "(", "SRI", "->", "isVGPR", "(", "MRI", ",", "Reg", ")", ")", "VGPRs", "+=", "NewRegs", ";" ]

[ "int", "NewRegs", "=", "countPopulation", "(", "NewMask", ".", "getAsInteger", "(", ")", ")", "-", "countPopulation", "(", "PrevMask", ".", "getAsInteger", "(", ")", ")", ";", "if", "(", "SRI", "->", "isSGPRReg", "(", "MRI", ",", "Reg", ")", ")", "SGPRs", "+=", "NewRegs", ";" ]

[ "<FIXS>", "F", ",", "WebAssembly", "::", "WasmEnableEmEH", "||", "WebAssembly", "::", "WasmEnableEmSjLj", ",", "Signature", ".", "get", "(", ")", ",", "InvokeDetected", ")", ";", "<FIXE>" ]

[ "bool", "InvokeDetected", "=", "false", ";", "auto", "*", "WasmSym", "=", "Printer", ".", "getMCSymbolForFunction", "(", "<BUGS>", "F", ",", "WasmEnableEmEH", "||", "WasmEnableEmSjLj", ",", "Signature", ".", "get", "(", ")", ",", "InvokeDetected", ")", ";", "<BUGE>", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "WasmSym", "->", "setType", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";" ]

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

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

[ "}" ]

[ "if", "(", "I", "->", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "Opnds", ".", "push_back", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "Opnds", ".", "push_back", "(", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ")", ";", "e", "+=", "<NUM_LIT>", ";", "continue", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "EXTRACT_VECTOR_ELT", ")", "return", "SDValue", "(", ")", ";", "SDValue", "Idx", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "if", "(", "!", "isa", "<", "ConstantSDNode", ">", "(", "Idx", ")", ")", "return", "SDValue", "(", ")", ";", "SDValue", "ExtractedFromVec", "=", "I", "->", "getOperand", "(", "<NUM_LIT>", ")", ";", "DenseMap", "<", "SDValue", ",", "unsigned", ">", "::", "iterator", "M", "=", "VecInMap", ".", "find", "(", "ExtractedFromVec", ")", ";", "if", "(", "M", "==", "VecInMap", ".", "end", "(", ")", ")", "{", "VT", "=", "ExtractedFromVec", ".", "getValueType", "(", ")", ";", "if", "(", "!", "VT", ".", "is128BitVector", "(", ")", "&&", "!", "VT", ".", "is256BitVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "VecInMap", ".", "begin", "(", ")", "!=", "VecInMap", ".", "end", "(", ")", "&&", "VT", "!=", "VecInMap", ".", "begin", "(", ")", "->", "first", ".", "getValueType", "(", ")", ")", "return", "SDValue", "(", ")", ";", "M", "=", "VecInMap", ".", "insert", "(", "std", "::", "make_pair", "(", "ExtractedFromVec", ",", "<NUM_LIT>", ")", ")", ".", "first", ";" ]

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

[ "ZeroReg", "=", "Mips", "::", "ZERO", ";", "}", "else", "if", "(", "(", "MI", ".", "getOpcode", "(", ")", "==", "Mips", "::", "DADDiu", ")", "&&", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", "==", "Mips", "::", "ZERO_64", ")", "&&", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", "==", "<NUM_LIT>", ")", ")", "{", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "ZeroReg", "=", "Mips", "::", "ZERO_64", ";", "}", "if", "(", "!", "DstReg", ")", "return", "false", ";", "for", "(", "MachineRegisterInfo", "::", "use_iterator", "U", "=", "MRI", "->", "use_begin", "(", "DstReg", ")", ",", "E", "=", "MRI", "->", "use_end", "(", ")", ";", "U", "!=", "E", ";", ")", "{", "MachineOperand", "&", "MO", "=", "U", ".", "getOperand", "(", ")", ";", "unsigned", "OpNo", "=", "U", ".", "getOperandNo", "(", ")", ";", "MachineInstr", "*", "MI", "=", "MO", ".", "getParent", "(", ")", ";", "++", "U", ";", "if", "(", "MI", "->", "isPHI", "(", ")", "||", "MI", "->", "isRegTiedToDefOperand", "(", "OpNo", ")", "||", "MI", "->", "isPseudo", "(", ")", ")", "continue", ";", "MO", ".", "setReg", "(" ]

[ "}" ]

[ "if", "(", "(", "IsA16", "&&", "!", "IsG16Supported", ")", "||", "BaseOpcode", "->", "G16", ")", "AddrWords", "+=", "alignTo", "<", "<NUM_LIT>", ">", "(", "Dim", "->", "NumGradients", "/", "<NUM_LIT>", ")", ";", "else", "AddrWords", "+=", "Dim", "->", "NumGradients", ";" ]

[ "}" ]

[ "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "C", ",", "const", "int", "_", "_", "R", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m512h", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm512_mask_fmsubadd_round_ph", "(", "_", "_", "m512h", "_", "_", "A", ",", "_", "_", "mmask32", "_", "_", "U", ",", "_", "_", "m512h", "_", "_", "B", ",", "_", "_", "m512h", "_", "_" ]

[ "->", "m_fpu_balance", ";" ]

[ "return", "this" ]

[ "}" ]

[ "if", "(", "!", "(", "I", "->", "isBranch", "(", ")", ")", "&&", "!", "(", "I", "->", "isCall", "(", ")", ")", "&&", "!", "(", "I", "->", "isReturn", "(", ")", ")", "&&", "!", "(", "I", "->", "isCompare", "(", ")", ")", "&&", "!", "(", "I", "->", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "(", "I", "->", "getOpcode", "(", ")", ">", "<NUM_LIT>", "&&", "I", "->", "getOpcode", "(", ")", "<", "<NUM_LIT>", ")", ")", ")", "{", "MachineInstr", "*", "slaveinst", "=", "MF", ".", "CloneMachineInstr", "(", "&", "*", "I", ")", ";", "slaveinst", "->", "setFlags", "(", "<NUM_LIT>", ")", ";", "for", "(", "unsigned", "int", "opcount", "=", "<NUM_LIT>", ";", "opcount", "<", "I", "->", "getNumOperands", "(", ")", ";", "opcount", "++", ")", "{", "if", "(", "I", "->", "getOperand", "(", "opcount", ")", ".", "isReg", "(", ")", ")", "{", "slaveinst", "->", "getOperand", "(", "opcount", ")", ".", "setReg", "(", "getSlaveReg", "(", "I", "->", "getOperand", "(", "opcount", ")", ".", "getReg", "(", ")", ")", ")", ";", "}", "else", "if", "(", "I", "->", "getOperand", "(", "opcount", ")", ".", "isImm", "(", ")", "&&", "(", "I", "->", "mayStore", "(", ")", "||", "I", "->", "mayLoad", "(", ")", ")", ")", "{", "slaveinst", "->", "getOperand", "(", "opcount", ")", ".", "setImm", "(", "I", "->", "getOperand", "(", "opcount", ")", ".", "getImm", "(", ")", "-", "MEMZDC_OFFSET", ")", ";", "}", "}", "MBB", "->", "insert", "(", "I", ",", "slaveinst", ")", ";", "}", "}" ]

[ "void", "ix86_split_idivmod", "(", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ",", "bool", "unsigned_p", ")", "{", "rtx_code_label", "*", "end_label", ",", "*", "qimode_label", ";", "rtx", "div", ",", "mod", ";", "rtx_insn", "*", "insn", ";", "rtx", "scratch", ",", "tmp0", ",", "tmp1", ",", "tmp2", ";", "rtx", "(", "*", "gen_divmod4_1", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_SImode", ":", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SImode", ")", "{", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "==", "SImode", ")", "gen_divmod4_1", "=", "unsigned_p", "?", "gen_udivmodsi4_1", ":", "gen_divmodsi4_1", ";", "else", "gen_divmod4_1", "=", "unsigned_p", "?", "gen_udivmodsi4_zext_2", ":", "gen_divmodsi4_zext_2", ";", "}", "else", "gen_divmod4_1", "=", "unsigned_p", "?", "gen_udivmodsi4_zext_1", ":", "gen_divmodsi4_zext_1", ";", "break", ";", "case", "E_DImode", ":", "gen_divmod4_1", "=", "unsigned_p", "?", "gen_udivmoddi4_1", ":", "gen_divmoddi4_1", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "end_label", "=", "gen_label_rtx", "(", ")", ";", "qimode_label", "=", "gen_label_rtx", "(", ")", ";", "scratch", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_move_insn", "(", "scratch", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "scratch", "=", "expand_simple_binop", "(", "mode", ",", "IOR", ",", "scratch", ",", "operands", "[", "<NUM_LIT>", "]", ",", "scratch", ",", "<NUM_LIT>", ",", "OPTAB_DIRECT", ")", ";", "emit_insn", "(", "gen_test_ccno_1", "(", "mode", ",", "scratch", ",", "GEN_INT", "(", "-", "<NUM_LIT>", ")", ")", ")", ";", "tmp0", "=", "gen_rtx_REG", "(", "CCNOmode", ",", "FLAGS_REG", ")", ";", "tmp0", "=", "gen_rtx_EQ", "(", "VOIDmode", ",", "tmp0", ",", "const0_rtx", ")", ";", "tmp0", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "tmp0", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "qimode_label", ")", ",", "pc_rtx", ")", ";", "insn", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "tmp0", ")", ")", ";", "predict_jump", "(", "REG_BR_PROB_BASE", "*", "<NUM_LIT>", "/", "<NUM_LIT>", ")", ";", "JUMP_LABEL", "(", "insn", ")", "=", "qimode_label", ";", "emit_insn", "(", "gen_divmod4_1", "(", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ")", ";", "emit_jump_insn", "(", "gen_jump", "(", "end_label", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "qimode_label", ")", ";", "tmp0", "=", "lowpart_subreg", "(", "HImode", ",", "scratch", ",", "mode", ")", ";", "tmp1", "=", "lowpart_subreg", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ";", "tmp2", "=", "lowpart_subreg", "(", "QImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "mode", ")", ";", "emit_insn", "(", "gen_udivmodhiqi3", "(", "tmp0", ",", "tmp1", ",", "tmp2", ")", ")", ";", "if", "(", "unsigned_p", ")", "{", "div", "=", "gen_rtx_UDIV", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "mod", "=", "gen_rtx_UMOD", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "else", "{", "div", "=", "gen_rtx_DIV", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "mod", "=", "gen_rtx_MOD", "(", "mode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "operands", "[", "<NUM_LIT>", "]", ")", ";", "}", "if", "(", "mode", "==", "SImode", ")", "{", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!=", "SImode", ")", "div", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "div", ")", ";", "if", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", "!=", "SImode", ")", "mod", "=", "gen_rtx_ZERO_EXTEND", "(", "DImode", ",", "mod", ")", ";", "}", "scratch", "=", "gen_lowpart", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "scratch", ")", ";", "tmp1", "=", "gen_rtx_ZERO_EXTRACT", "(", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "scratch", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ";", "insn", "=", "emit_move_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "tmp1", ")", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "mod", ")", ";", "tmp1", "=", "gen_lowpart", "(", "QImode", ",", "tmp0", ")", ";", "insn", "=", "emit_insn", "(", "gen_extend_insn", "(", "operands", "[", "<NUM_LIT>", "]", ",", "tmp1", ",", "GET_MODE", "(", "operands", "[", "<NUM_LIT>", "]", ")", ",", "QImode", ",", "<NUM_LIT>", ")", ")", ";", "set_unique_reg_note", "(", "insn", ",", "REG_EQUAL", ",", "div", ")", ";", "emit_label", "(", "end_label", ")", ";", "}" ]

[ "Split", "32bit/64bit", "divmod", "with", "8bit", "unsigned", "divmod", "if", "dividend", "and", "divisor", "are", "within", "the", "range", "[", "0-255", "]", "." ]