Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "SIInstrInfo", "::", "isOperandLegal", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ",", "const", "MachineOperand", "*", "MO", ")", "const", "{", "const", "MachineRegisterInfo", "&", "MRI", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "MCInstrDesc", "&", "InstDesc", "=", "MI", ".", "getDesc", "(", ")", ";", "const", "MCOperandInfo", "&", "OpInfo", "=", "InstDesc", ".", "OpInfo", "[", "OpIdx", "]", ";", "const", "TargetRegisterClass", "*", "DefinedRC", "=", "OpInfo", ".", "RegClass", "!=", "-", "1", "?", "RI", ".", "getRegClass", "(", "OpInfo", ".", "RegClass", ")", ":", "nullptr", ";", "if", "(", "!", "MO", ")", "MO", "=", "&", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "if", "(", "isVALU", "(", "MI", ")", "&&", "usesConstantBus", "(", "MRI", ",", "*", "MO", ",", "DefinedRC", "->", "getSize", "(", ")", ")", ")", "{", "RegSubRegPair", "SGPRUsed", ";", "if", "(", "MO", "->", "isReg", "(", ")", ")", "SGPRUsed", "=", "RegSubRegPair", "(", "MO", "->", "getReg", "(", ")", ",", "MO", "->", "getSubReg", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", ".", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "if", "(", "i", "==", "OpIdx", ")", "continue", ";", "const", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "i", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", ")", "{", "if", "(", "(", "Op", ".", "getReg", "(", ")", "!=", "SGPRUsed", ".", "Reg", "||", "Op", ".", "getSubReg", "(", ")", "!=", "SGPRUsed", ".", "SubReg", ")", "&&", "usesConstantBus", "(", "MRI", ",", "Op", ",", "getOpSize", "(", "MI", ",", "i", ")", ")", ")", "{", "return", "false", ";", "}", "}", "else", "if", "(", "InstDesc", ".", "OpInfo", "[", "i", "]", ".", "OperandType", "==", "AMDGPU", "::", "OPERAND_KIMM32", ")", "{", "return", "false", ";", "}", "}", "}", "if", "(", "MO", "->", "isReg", "(", ")", ")", "{", "assert", "(", "DefinedRC", ")", ";", "return", "isLegalRegOperand", "(", "MRI", ",", "OpInfo", ",", "*", "MO", ")", ";", "}", "assert", "(", "MO", "->", "isImm", "(", ")", "||", "MO", "->", "isTargetIndex", "(", ")", "||", "MO", "->", "isFI", "(", ")", ")", ";", "if", "(", "!", "DefinedRC", ")", "{", "return", "true", ";", "}", "return", "isImmOperandLegal", "(", "MI", ",", "OpIdx", ",", "*", "MO", ")", ";", "}", "</s>" ]

[ "Check", "if", "MO", "is", "a", "legal", "operand", "if", "it", "was", "the", "OpIdx", "Operand", "for", "MI", "." ]

[ "AMDGPU", "SI", "1", "0", "AMDGPU::OPERAND_KIMM32" ]

[]

[ "<s>", "static", "int", "arc_restore_callee_saves", "(", "unsigned", "int", "gmask", ",", "bool", "restore_blink", ",", "bool", "restore_fp", ",", "HOST_WIDE_INT", "offset", ",", "HOST_WIDE_INT", "allocated", ")", "{", "rtx", "reg", ";", "int", "frame_deallocated", "=", "0", ";", "HOST_WIDE_INT", "offs", "=", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ";", "bool", "early_blink_restore", ";", "if", "(", "arc_frame_pointer_needed", "(", ")", "&&", "offset", ")", "{", "frame_move", "(", "stack_pointer_rtx", ",", "hard_frame_pointer_rtx", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "if", "(", "restore_fp", ")", "{", "gcc_assert", "(", "offset", "==", "0", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "hard_frame_pointer_rtx", ",", "0", ")", ";", "}", "if", "(", "offset", ")", "{", "frame_stack_add", "(", "offset", ")", ";", "frame_deallocated", "+=", "offset", ";", "offset", "=", "0", ";", "}", "early_blink_restore", "=", "restore_blink", "&&", "!", "optimize_size", "&&", "offs", ";", "if", "(", "early_blink_restore", ")", "{", "rtx", "addr", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offs", ")", ";", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "rtx", "insn", "=", "frame_move_inc", "(", "reg", ",", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "stack_pointer_rtx", ",", "NULL_RTX", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "reg", ")", ";", "restore_blink", "=", "false", ";", "}", "if", "(", "gmask", ")", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "GMASK_LEN", ";", "i", "++", ")", "{", "machine_mode", "restore_mode", "=", "SImode", ";", "if", "(", "TARGET_LL64", "&&", "(", "(", "i", "%", "2", ")", "==", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1L", "<<", "i", ")", ")", "!=", "0", ")", "&&", "(", "(", "gmask", "&", "(", "1L", "<<", "(", "i", "+", "1", ")", ")", ")", "!=", "0", ")", ")", "restore_mode", "=", "DImode", ";", "else", "if", "(", "(", "gmask", "&", "(", "1L", "<<", "i", ")", ")", "==", "0", ")", "continue", ";", "reg", "=", "gen_rtx_REG", "(", "restore_mode", ",", "i", ")", ";", "offs", "=", "0", ";", "switch", "(", "restore_mode", ")", "{", "case", "E_DImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clz", "(", "gmask", ")", ")", "==", "(", "i", "+", "1", ")", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "case", "E_SImode", ":", "if", "(", "(", "GMASK_LEN", "-", "__builtin_clz", "(", "gmask", ")", ")", "==", "i", "&&", "early_blink_restore", ")", "offs", "=", "4", ";", "break", ";", "default", ":", "offs", "=", "0", ";", "}", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "offs", ")", ";", "offset", "=", "0", ";", "if", "(", "restore_mode", "==", "DImode", ")", "i", "++", ";", "}", "if", "(", "restore_blink", ")", "{", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "frame_deallocated", "+=", "frame_restore_reg", "(", "reg", ",", "allocated", "-", "frame_deallocated", "-", "UNITS_PER_WORD", ")", ";", "}", "return", "frame_deallocated", ";", "}", "</s>" ]

[ "ARC", "'s", "epilogue", ",", "restore", "any", "required", "call-saved", "regs", "(", "and", "call-used", "if", "it", "is", "for", "an", "interrupt", "handler", ")", "using", "LD/LDD", "instructions", "." ]

[ "arc", "0", "0", "0", "0", "0", "0", "2", "0", "1L", "0", "1L", "1", "0", "1L", "0", "0", "1", "4", "4", "0", "0" ]

[]

[ "<s>", "static", "int", "nds32_register_move_cost", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "reg_class_t", "from", ",", "reg_class_t", "to", ")", "{", "if", "(", "(", "from", "==", "FP_REGS", "&&", "to", "!=", "FP_REGS", ")", "||", "(", "from", "!=", "FP_REGS", "&&", "to", "==", "FP_REGS", ")", ")", "return", "9", ";", "else", "if", "(", "from", "==", "HIGH_REGS", "||", "to", "==", "HIGH_REGS", ")", "return", "optimize_size", "?", "6", ":", "2", ";", "else", "return", "2", ";", "}", "</s>" ]

[ "Describing", "Relative", "Costs", "of", "Operations", "." ]

[ "nds32", "9", "6", "2", "2" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "fitsReadPortLimitations", "(", "const", "std", "::", "vector", "<", "MachineInstr", "*", ">", "&", "IG", ",", "const", "DenseMap", "<", "unsigned", ",", "unsigned", ">", "&", "PV", ",", "std", "::", "vector", "<", "BankSwizzle", ">", "&", "ValidSwizzle", ",", "bool", "isLastAluTrans", ")", "const", "{", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", ">", "IGSrcs", ";", "ValidSwizzle", ".", "clear", "(", ")", ";", "unsigned", "ConstCount", "=", "0", ";", "BankSwizzle", "TransBS", "=", "ALU_VEC_012_SCL_210", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "IG", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "IGSrcs", ".", "push_back", "(", "ExtractSrcs", "(", "*", "IG", "[", "i", "]", ",", "PV", ",", "ConstCount", ")", ")", ";", "unsigned", "Op", "=", "getOperandIdx", "(", "IG", "[", "i", "]", "->", "getOpcode", "(", ")", ",", "R600", "::", "OpName", "::", "bank_swizzle", ")", ";", "ValidSwizzle", ".", "push_back", "(", "(", "R600InstrInfo", "::", "BankSwizzle", ")", "IG", "[", "i", "]", "->", "getOperand", "(", "Op", ")", ".", "getImm", "(", ")", ")", ";", "}", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", "TransOps", ";", "if", "(", "!", "isLastAluTrans", ")", "return", "FindSwizzleForVectorSlot", "(", "IGSrcs", ",", "ValidSwizzle", ",", "TransOps", ",", "TransBS", ")", ";", "TransOps", "=", "std", "::", "move", "(", "IGSrcs", ".", "back", "(", ")", ")", ";", "IGSrcs", ".", "pop_back", "(", ")", ";", "ValidSwizzle", ".", "pop_back", "(", ")", ";", "static", "const", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", "[", "]", "=", "{", "ALU_VEC_012_SCL_210", ",", "ALU_VEC_021_SCL_122", ",", "ALU_VEC_120_SCL_212", ",", "ALU_VEC_102_SCL_221", "}", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "TransBS", "=", "TransSwz", "[", "i", "]", ";", "if", "(", "!", "isConstCompatible", "(", "TransBS", ",", "TransOps", ",", "ConstCount", ")", ")", "continue", ";", "bool", "Result", "=", "FindSwizzleForVectorSlot", "(", "IGSrcs", ",", "ValidSwizzle", ",", "TransOps", ",", "TransBS", ")", ";", "if", "(", "Result", ")", "{", "ValidSwizzle", ".", "push_back", "(", "TransBS", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "the", "order", "VEC_012", "<", "VEC_021", "<", "VEC_120", "<", "VEC_102", "<", "VEC_201", "<", "VEC_210", "returns", "true", "and", "the", "first", "(", "in", "lexical", "order", ")", "BankSwizzle", "affectation", "starting", "from", "the", "one", "already", "provided", "in", "the", "Instruction", "Group", "MIs", "that", "fits", "Read", "Port", "limitations", "in", "BS", "if", "available", "." ]

[ "AMDGPU", "R600", "0", "0", "R600::OpName", "R600", "R600", "0", "4" ]

[]

[ "<s>", "void", "alpha_split_atomic_op", "(", "enum", "rtx_code", "code", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "before", ",", "rtx", "after", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "scratch", ")", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "label", ")", ";", "if", "(", "before", "==", "NULL", ")", "before", "=", "scratch", ";", "emit_load_locked", "(", "mode", ",", "before", ",", "mem", ")", ";", "if", "(", "code", "==", "NOT", ")", "x", "=", "gen_rtx_AND", "(", "mode", ",", "gen_rtx_NOT", "(", "mode", ",", "before", ")", ",", "val", ")", ";", "else", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "before", ",", "val", ")", ";", "if", "(", "after", ")", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "after", ",", "copy_rtx", "(", "x", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "scratch", ",", "x", ")", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "}", "</s>" ]

[ "Expand", "an", "an", "atomic", "fetch-and-operate", "pattern", ".", "CODE", "is", "the", "binary", "operation", "to", "perform", ".", "MEM", "is", "the", "memory", "on", "which", "to", "operate", ".", "VAL", "is", "the", "second", "operand", "of", "the", "binary", "operator", ".", "BEFORE", "and", "AFTER", "are", "optional", "locations", "to", "return", "the", "value", "of", "MEM", "either", "before", "of", "after", "the", "operation", ".", "SCRATCH", "is", "a", "scratch", "register", "." ]

[ "alpha" ]

[]

[ "<s>", "void", "Z80oldFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "int", "StackSize", "=", "int", "(", "MFI", ".", "getStackSize", "(", ")", ")", ";", "const", "TargetRegisterClass", "*", "ScratchRC", "=", "&", "Z80old", "::", "AIR16RegClass", ";", "TargetRegisterClass", "::", "iterator", "ScratchReg", "=", "ScratchRC", "->", "begin", "(", ")", ";", "for", "(", ";", "MI", "->", "readsRegister", "(", "TRI", "->", "getSubReg", "(", "*", "ScratchReg", ",", "Z80old", "::", "sub_low", ")", ",", "TRI", ")", ";", "++", "ScratchReg", ")", "assert", "(", "ScratchReg", "!=", "ScratchRC", "->", "end", "(", ")", "&&", "\"Could not allocate a scratch register!\"", ")", ";", "assert", "(", "(", "hasFP", "(", "MF", ")", "||", "*", "ScratchReg", "!=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ")", "&&", "\"Cannot allocate csr as scratch register!\"", ")", ";", "while", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", ")", "if", "(", "!", "(", "--", "MI", ")", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "{", "++", "MI", ";", "break", ";", "}", "while", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "std", "::", "prev", "(", "MI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "Z80old", "::", "POP16r", "&&", "PI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ")", "{", "StackSize", "+=", "SlotSize", ";", "}", "else", "if", "(", "Opc", "==", "Z80old", "::", "LD16SP", ")", "{", "unsigned", "Reg", "=", "PI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "PI", "==", "MBB", ".", "begin", "(", ")", ")", "{", "break", ";", "}", "MachineBasicBlock", "::", "iterator", "AI", "=", "std", "::", "prev", "(", "PI", ")", ";", "Opc", "=", "AI", "->", "getOpcode", "(", ")", ";", "if", "(", "AI", "==", "MBB", ".", "begin", "(", ")", "||", "Opc", "!=", "Z80old", "::", "ADD16SP", "||", "AI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "!=", "Reg", "||", "AI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "Reg", ")", "{", "break", ";", "}", "MachineBasicBlock", "::", "iterator", "LI", "=", "std", "::", "prev", "(", "AI", ")", ";", "Opc", "=", "LI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "Z80old", "::", "LD16ri", "||", "LI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", "!=", "Reg", ")", "{", "break", ";", "}", "StackSize", "+=", "LI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "LI", "->", "removeFromParent", "(", ")", ";", "AI", "->", "removeFromParent", "(", ")", ";", "}", "else", "{", "break", ";", "}", "PI", "->", "removeFromParent", "(", ")", ";", "}", "bool", "HasFP", "=", "hasFP", "(", "MF", ")", ";", "BuildStackAdjustment", "(", "MF", ",", "MBB", ",", "MI", ",", "DL", ",", "StackSize", ",", "HasFP", "?", "StackSize", ":", "-", "1", ",", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", ";", "if", "(", "HasFP", ")", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Z80old", "::", "POP16r", ")", ",", "TRI", "->", "getFrameRegister", "(", "MF", ")", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "Z80old", "Z80old", "Z80old::AIR16RegClass", "Z80old::sub_low", "\"Could not allocate a scratch register!\"", "\"Cannot allocate csr as scratch register!\"", "Z80old::POP16r", "0", "Z80old::LD16SP", "0", "Z80old::ADD16SP", "0", "1", "Z80old::LD16ri", "0", "1", "1", "Z80old::POP16r" ]

[]

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "ShouldCombineAggressively", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "<=", "CodeGenOpt", "::", "Default", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "PotentiallyNewifiableTFR", ".", "clear", "(", ")", ";", "findPotentialNewifiableTFRs", "(", "*", "BI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "BI", "->", "begin", "(", ")", ",", "End", "=", "BI", "->", "end", "(", ")", ";", "MI", "!=", "End", ";", ")", "{", "MachineInstr", "*", "I1", "=", "MI", "++", ";", "if", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "I2", ",", "MI", ",", "DoInsertAtI1", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "int", "m32c_push_rounding", "(", "int", "n", ")", "{", "if", "(", "TARGET_R8C", "||", "TARGET_M16C", ")", "return", "n", ";", "return", "(", "n", "+", "1", ")", "&", "~", "1", ";", "}", "</s>" ]

[ "Implements", "PUSH_ROUNDING", ".", "The", "R8C", "and", "M16C", "have", "byte", "stacks", ",", "the", "M32C", "has", "word", "stacks", "." ]

[ "m32c", "1", "1" ]

[]

[ "<s>", "static", "bool", "v850_pass_by_reference", "(", "cumulative_args_t", "cum", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "unsigned", "HOST_WIDE_INT", "size", ";", "if", "(", "!", "TARGET_GCC_ABI", ")", "return", "0", ";", "if", "(", "type", ")", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "return", "size", ">", "8", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_PASS_BY_REFERENCE", "target", "hook", ".", "Specify", "whether", "to", "pass", "the", "argument", "by", "reference", "." ]

[ "v850", "0", "8" ]

[]

[ "<s>", "SDValue", "ARMTargetLowering", "::", "BuildSDIVPow2", "(", "SDNode", "*", "N", ",", "const", "APInt", "&", "Divisor", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDNode", "*", ">", "&", "Created", ")", "const", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SDIV", ")", "return", "SDValue", "(", ")", ";", "const", "auto", "&", "ST", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "DAG", ".", "getSubtarget", "(", ")", ")", ";", "const", "bool", "MinSize", "=", "ST", ".", "hasMinSize", "(", ")", ";", "const", "bool", "HasDivide", "=", "ST", ".", "isThumb", "(", ")", "?", "ST", ".", "hasDivideInThumbMode", "(", ")", ":", "ST", ".", "hasDivideInARMMode", "(", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getValueType", "(", ")", ".", "isVector", "(", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "(", "MinSize", "&&", "HasDivide", ")", ")", "return", "SDValue", "(", ")", ";", "if", "(", "!", "ST", ".", "isThumb", "(", ")", ")", "return", "SDValue", "(", "N", ",", "0", ")", ";", "if", "(", "Divisor", ".", "sgt", "(", "128", ")", ")", "return", "SDValue", "(", ")", ";", "return", "SDValue", "(", "N", ",", "0", ")", ";", "}", "</s>" ]

[ "Targets", "may", "override", "this", "function", "to", "provide", "custom", "SDIV", "lowering", "for", "power-of-2", "denominators", "." ]

[ "ARM", "ARM", "ISD::SDIV", "ARM", "ARM", "0", "0", "128", "0" ]

[]

[ "<s>", "bool", "WebAssemblyPrepareForLiveIntervals", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Prepare For LiveIntervals **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineBasicBlock", "&", "Entry", "=", "*", "MF", ".", "begin", "(", ")", ";", "assert", "(", "!", "mustPreserveAnalysisID", "(", "LiveIntervalsID", ")", "&&", "\"LiveIntervals shouldn't be active yet!\"", ")", ";", "MRI", ".", "leaveSSA", "(", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "<", "E", ";", "++", "I", ")", "{", "unsigned", "Reg", "=", "TargetRegisterInfo", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "MRI", ".", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "if", "(", "hasArgumentDef", "(", "Reg", ",", "MRI", ")", ")", "continue", ";", "BuildMI", "(", "Entry", ",", "Entry", ".", "begin", "(", ")", ",", "DebugLoc", "(", ")", ",", "TII", ".", "get", "(", "WebAssembly", "::", "IMPLICIT_DEF", ")", ",", "Reg", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "auto", "MII", "=", "Entry", ".", "begin", "(", ")", ",", "MIE", "=", "Entry", ".", "end", "(", ")", ";", "MII", "!=", "MIE", ";", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", "++", ";", "if", "(", "WebAssembly", "::", "isArgument", "(", "MI", ")", ")", "{", "MI", ".", "removeFromParent", "(", ")", ";", "Entry", ".", "insert", "(", "Entry", ".", "begin", "(", ")", ",", "&", "MI", ")", ";", "}", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "TracksLiveness", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Prepare For LiveIntervals **********\\n\"", "\"********** Function: \"", "WebAssembly", "\"LiveIntervals shouldn't be active yet!\"", "0", "WebAssembly::IMPLICIT_DEF", "WebAssembly::isArgument" ]

[]

[ "<s>", "static", "std", "::", "unique_ptr", "<", "X86Operand", ">", "CreateMem", "(", "unsigned", "ModeSize", ",", "unsigned", "SegReg", ",", "const", "MCExpr", "*", "Disp", ",", "unsigned", "BaseReg", ",", "unsigned", "IndexReg", ",", "unsigned", "Scale", ",", "SMLoc", "StartLoc", ",", "SMLoc", "EndLoc", ",", "unsigned", "Size", "=", "0", ",", "unsigned", "DefaultBaseReg", "=", "X86", "::", "NoRegister", ",", "StringRef", "SymName", "=", "StringRef", "(", ")", ",", "void", "*", "OpDecl", "=", "nullptr", ",", "unsigned", "FrontendSize", "=", "0", ",", "bool", "UseUpRegs", "=", "false", ",", "bool", "MaybeDirectBranchDest", "=", "true", ")", "{", "assert", "(", "(", "SegReg", "||", "BaseReg", "||", "IndexReg", "||", "DefaultBaseReg", ")", "&&", "\"Invalid memory operand!\"", ")", ";", "assert", "(", "(", "(", "Scale", "==", "1", "||", "Scale", "==", "2", "||", "Scale", "==", "4", "||", "Scale", "==", "8", ")", ")", "&&", "\"Invalid scale!\"", ")", ";", "auto", "Res", "=", "std", "::", "make_unique", "<", "X86Operand", ">", "(", "Memory", ",", "StartLoc", ",", "EndLoc", ")", ";", "Res", "->", "Mem", ".", "SegReg", "=", "SegReg", ";", "Res", "->", "Mem", ".", "Disp", "=", "Disp", ";", "Res", "->", "Mem", ".", "BaseReg", "=", "BaseReg", ";", "Res", "->", "Mem", ".", "DefaultBaseReg", "=", "DefaultBaseReg", ";", "Res", "->", "Mem", ".", "IndexReg", "=", "IndexReg", ";", "Res", "->", "Mem", ".", "Scale", "=", "Scale", ";", "Res", "->", "Mem", ".", "Size", "=", "Size", ";", "Res", "->", "Mem", ".", "ModeSize", "=", "ModeSize", ";", "Res", "->", "Mem", ".", "FrontendSize", "=", "FrontendSize", ";", "Res", "->", "Mem", ".", "MaybeDirectBranchDest", "=", "MaybeDirectBranchDest", ";", "Res", "->", "UseUpRegs", "=", "UseUpRegs", ";", "Res", "->", "SymName", "=", "SymName", ";", "Res", "->", "OpDecl", "=", "OpDecl", ";", "Res", "->", "AddressOf", "=", "false", ";", "return", "Res", ";", "}", "</s>" ]

[ "Create", "a", "generalized", "memory", "operand", "." ]

[ "X86", "X86", "0", "X86::NoRegister", "0", "\"Invalid memory operand!\"", "1", "2", "4", "8", "\"Invalid scale!\"", "X86" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"X86 Maximal Stack Alignment Calculator\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "X86", "\"X86 Maximal Stack Alignment Calculator\"" ]

[]

[ "<s>", "static", "void", "real_line_pos", "(", "int", "diagpos", ",", "int", "*", "real_line", ",", "int", "*", "real_pos", ")", "{", "*", "real_line", "=", "line", "-", "lastline", ";", "*", "real_pos", "=", "diagpos", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "MAXLINES", ";", "i", "++", ")", "{", "int", "len", "=", "strlen", "(", "lines", "[", "i", "]", ")", ";", "if", "(", "*", "real_pos", "<=", "len", ")", "break", ";", "(", "*", "real_line", ")", "++", ";", "*", "real_pos", "-=", "len", "-", "2", ";", "}", "(", "*", "real_pos", ")", "++", ";", "}", "</s>" ]

[ "From", "a", "possibly", "extended", "line", "with", "a", "virtual", "position", ",", "calculate", "the", "current", "line", "and", "character", "position", "." ]

[ "rs6000", "0", "2" ]

[]

[ "<s>", "rtx", "arc_return_addr_rtx", "(", "int", "count", ",", "ATTRIBUTE_UNUSED", "rtx", "frame", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "}", "</s>" ]

[ "Returns", "the", "return", "address", "that", "is", "used", "by", "builtin_return_address", "." ]

[ "arc", "0" ]

[]

[ "<s>", "bool", "RISCVAsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "SMLoc", "IDLoc", ",", "MCStreamer", "&", "Out", ")", "{", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoLI", ")", "{", "unsigned", "Reg", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "const", "MCOperand", "&", "Op1", "=", "Inst", ".", "getOperand", "(", "1", ")", ";", "if", "(", "Op1", ".", "isExpr", "(", ")", ")", "{", "emitToStreamer", "(", "Out", ",", "MCInstBuilder", "(", "RISCV", "::", "ADDI", ")", ".", "addReg", "(", "Reg", ")", ".", "addReg", "(", "RISCV", "::", "X0", ")", ".", "addExpr", "(", "Op1", ".", "getExpr", "(", ")", ")", ")", ";", "return", "false", ";", "}", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "isRV64", "(", ")", ")", "Imm", "=", "SignExtend64", "<", "32", ">", "(", "Imm", ")", ";", "emitLoadImm", "(", "Reg", ",", "Imm", ",", "Out", ")", ";", "return", "false", ";", "}", "else", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoLLA", ")", "{", "emitLoadLocalAddress", "(", "Inst", ",", "IDLoc", ",", "Out", ")", ";", "return", "false", ";", "}", "emitToStreamer", "(", "Out", ",", "Inst", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Process", "a", "single", "instruction", "and", "collect", "debug", "info", "anchors", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoLI", "0", "1", "RISCV::ADDI", "RISCV::X0", "1", "32", "RISCV::PseudoLLA" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "getNegatedExpression", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ",", "bool", "LegalOps", ",", "bool", "OptForSize", ",", "NegatibleCost", "&", "Cost", ",", "unsigned", "Depth", ")", "const", "{", "if", "(", "Depth", ">", "SelectionDAG", "::", "MaxRecursionDepth", ")", "return", "SDValue", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDNodeFlags", "Flags", "=", "Op", ".", "getNode", "(", ")", "->", "getFlags", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "PPCISD", "::", "FNMSUB", ":", "if", "(", "!", "Op", ".", "hasOneUse", "(", ")", "||", "!", "isTypeLegal", "(", "VT", ")", "||", "Subtarget", ".", "hasQPX", "(", ")", ")", "break", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "SDValue", "N0", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Op", ".", "getOperand", "(", "1", ")", ";", "SDValue", "N2", "=", "Op", ".", "getOperand", "(", "2", ")", ";", "SDLoc", "Loc", "(", "Op", ")", ";", "NegatibleCost", "N2Cost", "=", "NegatibleCost", "::", "Expensive", ";", "SDValue", "NegN2", "=", "getNegatedExpression", "(", "N2", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "N2Cost", ",", "Depth", "+", "1", ")", ";", "if", "(", "!", "NegN2", ")", "return", "SDValue", "(", ")", ";", "if", "(", "Flags", ".", "hasNoSignedZeros", "(", ")", "||", "Options", ".", "NoSignedZerosFPMath", ")", "{", "NegatibleCost", "N0Cost", "=", "NegatibleCost", "::", "Expensive", ";", "SDValue", "NegN0", "=", "getNegatedExpression", "(", "N0", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "N0Cost", ",", "Depth", "+", "1", ")", ";", "NegatibleCost", "N1Cost", "=", "NegatibleCost", "::", "Expensive", ";", "SDValue", "NegN1", "=", "getNegatedExpression", "(", "N1", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "N1Cost", ",", "Depth", "+", "1", ")", ";", "if", "(", "NegN0", "&&", "N0Cost", "<=", "N1Cost", ")", "{", "Cost", "=", "std", "::", "min", "(", "N0Cost", ",", "N2Cost", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "Loc", ",", "VT", ",", "NegN0", ",", "N1", ",", "NegN2", ",", "Flags", ")", ";", "}", "else", "if", "(", "NegN1", ")", "{", "Cost", "=", "std", "::", "min", "(", "N1Cost", ",", "N2Cost", ")", ";", "return", "DAG", ".", "getNode", "(", "Opc", ",", "Loc", ",", "VT", ",", "N0", ",", "NegN1", ",", "NegN2", ",", "Flags", ")", ";", "}", "}", "if", "(", "isOperationLegal", "(", "ISD", "::", "FMA", ",", "VT", ")", ")", "{", "Cost", "=", "N2Cost", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "FMA", ",", "Loc", ",", "VT", ",", "N0", ",", "N1", ",", "NegN2", ",", "Flags", ")", ";", "}", "break", ";", "}", "return", "TargetLowering", "::", "getNegatedExpression", "(", "Op", ",", "DAG", ",", "LegalOps", ",", "OptForSize", ",", "Cost", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Return", "the", "newly", "negated", "expression", "if", "the", "cost", "is", "not", "expensive", "and", "set", "the", "cost", "in", "Cost", "to", "indicate", "that", "if", "it", "is", "cheaper", "or", "neutral", "to", "do", "the", "negation", "." ]

[ "PowerPC", "PPC", "PPCISD::FNMSUB", "0", "1", "2", "1", "1", "1", "ISD::FMA", "ISD::FMA" ]

[]

[ "<s>", "bool", "isInterruptOrSignalHandler", "(", ")", "const", "{", "return", "isInterruptHandler", "(", ")", "||", "isSignalHandler", "(", ")", ";", "}", "</s>" ]

[ "Checks", "if", "the", "function", "is", "some", "form", "of", "interrupt", "service", "routine", "." ]

[ "MCS51" ]

[]

[ "<s>", "static", "int", "arm_first_cycle_multipass_dfa_lookahead", "(", "void", ")", "{", "int", "issue_rate", "=", "arm_issue_rate", "(", ")", ";", "return", "issue_rate", ">", "1", "&&", "!", "sched_fusion", "?", "issue_rate", ":", "0", ";", "}", "</s>" ]

[ "Return", "how", "many", "instructions", "should", "scheduler", "lookahead", "to", "choose", "the", "best", "one", "." ]

[ "arm", "1", "0" ]

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createMicroMipsSizeReductionPass", "(", ")", ")", ";", "addPass", "(", "createMipsDelaySlotFillerPass", "(", ")", ")", ";", "addPass", "(", "createMipsLongBranchPass", "(", ")", ")", ";", "addPass", "(", "createMipsHazardSchedule", "(", ")", ")", ";", "addPass", "(", "createMipsConstantIslandPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips", "Mips", "Mips" ]

[]

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

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

[ "AMDGPU", "AMDGPU", "AMDGPUISD::NodeType", "AMDGPUISD::FIRST_NUMBER", "SI", "AMDGPUISD::FIRST_MEM_OPCODE_NUMBER", "AMDGPUISD::LAST_AMDGPU_ISD_NUMBER" ]

[]

[ "<s>", "static", "rtx", "loongarch_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "struct", "loongarch_arg_info", "info", ";", "if", "(", "arg", ".", "end_marker_p", "(", ")", ")", "return", "NULL", ";", "return", "loongarch_get_arg_info", "(", "&", "info", ",", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ",", "false", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "loongarch" ]

[]

[ "<s>", "void", "BPFInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "BPF", "BPF" ]

[]

[ "<s>", "void", "HexagonPassConfig", "::", "addPreEmitPass", "(", ")", "{", "const", "HexagonTargetMachine", "&", "TM", "=", "getHexagonTargetMachine", "(", ")", ";", "bool", "NoOpt", "=", "(", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", ";", "if", "(", "!", "NoOpt", ")", "addPass", "(", "createHexagonNewValueJump", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonExpandPredSpillCode", "(", "TM", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonSplitTFRCondSets", "(", "TM", ")", ",", "false", ")", ";", "if", "(", "!", "NoOpt", ")", "{", "if", "(", "!", "DisableHardwareLoops", ")", "addPass", "(", "createHexagonFixupHwLoops", "(", ")", ",", "false", ")", ";", "addPass", "(", "createHexagonPacketizer", "(", ")", ",", "false", ")", ";", "}", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon" ]

[]

[ "<s>", "SDValue", "PPCTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "unsigned", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "{", "if", "(", "PPCSubTarget", ".", "isSVR4ABI", "(", ")", "&&", "!", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "LowerFormalArguments_SVR4", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "else", "{", "return", "LowerFormalArguments_Darwin", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "PowerPC", "PPC", "ISD::InputArg", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "unsigned", "ValVReg", ",", "unsigned", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "llvm_unreachable", "(", "\"not implemented\"", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "AMDGPU", "\"not implemented\"" ]

[]

[ "<s>", "bool", "c6x_mem_operand", "(", "rtx", "op", ",", "enum", "reg_class", "c", ",", "bool", "small_offset", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "rtx", "base", "=", "XEXP", "(", "op", ",", "0", ")", ";", "switch", "(", "GET_CODE", "(", "base", ")", ")", "{", "case", "REG", ":", "break", ";", "case", "PLUS", ":", "if", "(", "small_offset", "&&", "(", "XEXP", "(", "base", ",", "0", ")", "==", "stack_pointer_rtx", "||", "XEXP", "(", "base", ",", "0", ")", "==", "pic_offset_table_rtx", ")", ")", "{", "if", "(", "!", "c6x_legitimate_address_p_1", "(", "mode", ",", "base", ",", "true", ",", "true", ")", ")", "return", "false", ";", "}", "case", "PRE_INC", ":", "case", "PRE_DEC", ":", "case", "PRE_MODIFY", ":", "case", "POST_INC", ":", "case", "POST_DEC", ":", "case", "POST_MODIFY", ":", "base", "=", "XEXP", "(", "base", ",", "0", ")", ";", "break", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "gcc_assert", "(", "sdata_symbolic_operand", "(", "base", ",", "Pmode", ")", ")", ";", "return", "!", "small_offset", "&&", "c", "==", "B_REGS", ";", "default", ":", "return", "false", ";", "}", "return", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "(", "int", ")", "(", "c", ")", "]", ",", "REGNO", "(", "base", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "OP", "is", "a", "valid", "memory", "address", "with", "a", "base", "register", "of", "class", "C.", "If", "SMALL_OFFSET", "is", "true", ",", "we", "disallow", "memory", "references", "which", "would", "require", "a", "long", "offset", "with", "B14/B15", "." ]

[ "c6x", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "&", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "unsigned", "Opcode", "=", "Orig", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "&", "Orig", ")", ";", "MI", "->", "substituteRegister", "(", "Orig", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "break", ";", "}", "case", "ARM", "::", "tLDRpci_pic", ":", "case", "ARM", "::", "t2LDRpci_pic", ":", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "CPI", "=", "Orig", ".", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "unsigned", "PCLabelId", "=", "duplicateCPV", "(", "MF", ",", "CPI", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "Orig", ".", "getDebugLoc", "(", ")", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addConstantPoolIndex", "(", "CPI", ")", ".", "addImm", "(", "PCLabelId", ")", ".", "cloneMemRefs", "(", "Orig", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "ARM", "ARM", "0", "ARM::tLDRpci_pic", "ARM::t2LDRpci_pic", "1" ]

[]

[ "<s>", "virtual", "void", "initializePass", "(", ")", "override", "{", "pushTTIStack", "(", "this", ")", ";", "}", "</s>" ]

[ "initializePass", "-", "This", "method", "may", "be", "overriden", "by", "immutable", "passes", "to", "allow", "them", "to", "perform", "various", "initialization", "actions", "they", "require", "." ]

[ "PowerPC" ]

[]

[ "<s>", "static", "tree", "handle_aarch64_vector_pcs_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "FUNC_OR_METHOD_TYPE_P", "(", "*", "node", ")", ")", ";", "switch", "(", "(", "arm_pcs", ")", "fntype_abi", "(", "*", "node", ")", ".", "id", "(", ")", ")", "{", "case", "ARM_PCS_AAPCS64", ":", "case", "ARM_PCS_SIMD", ":", "return", "NULL_TREE", ";", "case", "ARM_PCS_SVE", ":", "error", "(", "\"the %qE attribute cannot be applied to an SVE function type\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "return", "NULL_TREE", ";", "case", "ARM_PCS_TLSDESC", ":", "case", "ARM_PCS_UNKNOWN", ":", "break", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Check", "whether", "an", "'aarch64_vector_pcs", "'", "attribute", "is", "valid", "." ]

[ "aarch64", "\"the %qE attribute cannot be applied to an SVE function type\"" ]

[]

[ "<s>", "bool", "Z80oldPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createZ80oldISelDag", "(", "getZ80oldTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "Z80old", "Z80old", "Z80old", "Z80old" ]

[]

[ "<s>", "PPCSubtarget", "::", "PPCSubtarget", "(", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "PPCTargetMachine", "&", "TM", ")", ":", "PPCGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "TargetTriple", "(", "TT", ")", ",", "DL", "(", "getDataLayoutString", "(", "TargetTriple", ")", ")", ",", "IsPPC64", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", "||", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64le", ")", ",", "TargetABI", "(", "PPC_ABI_UNKNOWN", ")", ",", "FrameLowering", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ")", ",", "TSInfo", "(", "&", "DL", ")", "{", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "bpick_ra_rb_dep_p", "(", "rtx", "insn", ",", "rtx", "def_reg", ")", "{", "rtx", "ior_rtx", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "rtx", "and1_rtx", "=", "XEXP", "(", "ior_rtx", ",", "0", ")", ";", "rtx", "and2_rtx", "=", "XEXP", "(", "ior_rtx", ",", "1", ")", ";", "rtx", "reg1_0", "=", "XEXP", "(", "and1_rtx", ",", "0", ")", ";", "rtx", "reg1_1", "=", "XEXP", "(", "and1_rtx", ",", "1", ")", ";", "rtx", "reg2_0", "=", "XEXP", "(", "and2_rtx", ",", "0", ")", ";", "rtx", "reg2_1", "=", "XEXP", "(", "and2_rtx", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "reg1_0", ")", "==", "NOT", ")", "{", "if", "(", "rtx_equal_p", "(", "reg1_0", ",", "reg2_0", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg1_1", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg2_1", ")", ";", "if", "(", "rtx_equal_p", "(", "reg1_0", ",", "reg2_1", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg1_1", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg2_0", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg1_1", ")", "==", "NOT", ")", "{", "if", "(", "rtx_equal_p", "(", "reg1_1", ",", "reg2_0", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg1_0", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg2_1", ")", ";", "if", "(", "rtx_equal_p", "(", "reg1_1", ",", "reg2_1", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg1_0", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg2_0", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg2_0", ")", "==", "NOT", ")", "{", "if", "(", "rtx_equal_p", "(", "reg2_0", ",", "reg1_0", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg2_1", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg1_1", ")", ";", "if", "(", "rtx_equal_p", "(", "reg2_0", ",", "reg1_1", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg2_1", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg1_0", ")", ";", "}", "if", "(", "GET_CODE", "(", "reg2_1", ")", "==", "NOT", ")", "{", "if", "(", "rtx_equal_p", "(", "reg2_1", ",", "reg1_0", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg2_0", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg1_1", ")", ";", "if", "(", "rtx_equal_p", "(", "reg2_1", ",", "reg1_1", ")", ")", "return", "reg_overlap_p", "(", "def_reg", ",", "reg2_0", ")", "||", "reg_overlap_p", "(", "def_reg", ",", "reg1_0", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Check", "if", "INSN", "is", "a", "bpick", "insn", "consuming", "DEF_REG", "." ]

[ "nds32", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "SIAnnotateControlFlow", "::", "push", "(", "BasicBlock", "*", "BB", ",", "Value", "*", "Saved", ")", "{", "Stack", ".", "push_back", "(", "std", "::", "make_pair", "(", "BB", ",", "Saved", ")", ")", ";", "}", "</s>" ]

[ "Push", "the", "current", "solver", "state", "." ]

[ "R600", "SI" ]

[]

[ "<s>", "static", "rtx", "rs6000_complex_function_value", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "regno", ";", "rtx", "r1", ",", "r2", ";", "machine_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "int", "inner_bytes", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "if", "(", "TARGET_FLOAT128_TYPE", "&&", "(", "mode", "==", "KCmode", "||", "(", "mode", "==", "TCmode", "&&", "TARGET_IEEEQUAD", ")", ")", ")", "regno", "=", "ALTIVEC_ARG_RETURN", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_HARD_FLOAT", ")", "regno", "=", "FP_ARG_RETURN", ";", "else", "{", "regno", "=", "GP_ARG_RETURN", ";", "if", "(", "TARGET_32BIT", "&&", "inner_bytes", ">=", "4", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "if", "(", "inner_bytes", ">=", "8", ")", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "r1", "=", "gen_rtx_EXPR_LIST", "(", "inner", ",", "gen_rtx_REG", "(", "inner", ",", "regno", ")", ",", "const0_rtx", ")", ";", "r2", "=", "gen_rtx_EXPR_LIST", "(", "inner", ",", "gen_rtx_REG", "(", "inner", ",", "regno", "+", "1", ")", ",", "GEN_INT", "(", "inner_bytes", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "mode", ",", "gen_rtvec", "(", "2", ",", "r1", ",", "r2", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "RTX", "representing", "where", "to", "find", "the", "function", "value", "of", "a", "function", "returning", "MODE", "." ]

[ "rs6000", "4", "8", "1", "2" ]

[]

[ "<s>", "unsigned", "AMDGPUAsmParser", "::", "checkTargetMatchPredicate", "(", "MCInst", "&", "Inst", ")", "{", "uint64_t", "TSFlags", "=", "MII", ".", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", ";", "if", "(", "(", "getForcedEncodingSize", "(", ")", "==", "32", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "getForcedEncodingSize", "(", ")", "==", "64", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", ")", "||", "(", "isForcedDPP", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "DPP", ")", ")", "||", "(", "isForcedSDWA", "(", ")", "&&", "!", "(", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", ")", ")", "return", "Match_InvalidOperand", ";", "if", "(", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOP3", ")", "&&", "(", "TSFlags", "&", "SIInstrFlags", "::", "VOPAsmPrefer32Bit", ")", "&&", "getForcedEncodingSize", "(", ")", "!=", "64", ")", "return", "Match_PreferE32", ";", "return", "Match_Success", ";", "}", "</s>" ]

[ "checkTargetMatchPredicate", "-", "Validate", "the", "instruction", "match", "against", "any", "complex", "target", "predicates", "not", "expressible", "via", "match", "classes", "." ]

[ "AMDGPU", "AMDGPU", "32", "SIInstrFlags::VOP3", "64", "SIInstrFlags::VOP3", "SIInstrFlags::DPP", "SIInstrFlags::SDWA", "SIInstrFlags::VOP3", "SIInstrFlags::VOPAsmPrefer32Bit", "64" ]

[]

[ "<s>", "static", "bool", "mips_valid_offset_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "const_arith_operand", "(", "x", ",", "Pmode", ")", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", "&&", "!", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "UNITS_PER_WORD", ")", ")", "return", "false", ";", "if", "(", "MSA_SUPPORTED_MODE_P", "(", "mode", ")", "&&", "!", "mips_signed_immediate_p", "(", "INTVAL", "(", "x", ")", ",", "10", ",", "mips_ldst_scaled_shift", "(", "mode", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", ",", "for", "every", "base", "register", "BASE_REG", ",", "(", "plus", "BASE_REG", "X", ")", "can", "address", "a", "value", "of", "mode", "MODE", "." ]

[ "mips", "10" ]

[]

[ "<s>", "void", "ARMBaseInstrInfo", "::", "buildOutlinedFrame", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineFunction", "&", "MF", ",", "const", "outliner", "::", "OutlinedFunction", "&", "OF", ")", "const", "{", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "{", "MachineInstr", "*", "Call", "=", "&", "*", "--", "MBB", ".", "instr_end", "(", ")", ";", "bool", "isThumb", "=", "Subtarget", ".", "isThumb", "(", ")", ";", "unsigned", "FuncOp", "=", "isThumb", "?", "2", ":", "0", ";", "unsigned", "Opc", "=", "Call", "->", "getOperand", "(", "FuncOp", ")", ".", "isReg", "(", ")", "?", "isThumb", "?", "ARM", "::", "tTAILJMPr", ":", "ARM", "::", "TAILJMPr", ":", "isThumb", "?", "Subtarget", ".", "isTargetMachO", "(", ")", "?", "ARM", "::", "tTAILJMPd", ":", "ARM", "::", "tTAILJMPdND", ":", "ARM", "::", "TAILJMPd", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "add", "(", "Call", "->", "getOperand", "(", "FuncOp", ")", ")", ";", "if", "(", "isThumb", "&&", "!", "Call", "->", "getOperand", "(", "FuncOp", ")", ".", "isReg", "(", ")", ")", "MIB", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "Call", "->", "eraseFromParent", "(", ")", ";", "}", "auto", "IsNonTailCall", "=", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCall", "(", ")", "&&", "!", "MI", ".", "isReturn", "(", ")", ";", "}", ";", "if", "(", "llvm", "::", "any_of", "(", "MBB", ".", "instrs", "(", ")", ",", "IsNonTailCall", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "It", "=", "MBB", ".", "begin", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "Et", "=", "MBB", ".", "end", "(", ")", ";", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerTailCall", "||", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "Et", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "MBB", ".", "isLiveIn", "(", "ARM", "::", "LR", ")", ")", "MBB", ".", "addLiveIn", "(", "ARM", "::", "LR", ")", ";", "saveLROnStack", "(", "MBB", ",", "It", ")", ";", "emitCFIForLRSaveOnStack", "(", "MBB", ",", "It", ")", ";", "restoreLRFromStack", "(", "MBB", ",", "Et", ")", ";", "emitCFIForLRRestoreFromStack", "(", "MBB", ",", "Et", ")", ";", "}", "if", "(", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerTailCall", "||", "OF", ".", "FrameConstructionID", "==", "MachineOutlinerThunk", ")", "return", ";", "BuildMI", "(", "MBB", ",", "MBB", ".", "end", "(", ")", ",", "DebugLoc", "(", ")", ",", "get", "(", "Subtarget", ".", "getReturnOpcode", "(", ")", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "custom", "frame", "for", "outlined", "functions", "." ]

[ "ARM", "ARM", "2", "0", "ARM::tTAILJMPr", "ARM::TAILJMPr", "ARM::tTAILJMPd", "ARM::tTAILJMPdND", "ARM::TAILJMPd", "ARMCC::AL", "ARM::LR", "ARM::LR", "ARMCC::AL" ]

[]

[ "<s>", "void", "neon_disambiguate_copy", "(", "rtx", "*", "operands", ",", "rtx", "*", "dest", ",", "rtx", "*", "src", ",", "unsigned", "int", "count", ")", "{", "unsigned", "int", "i", ";", "if", "(", "!", "reg_overlap_mentioned_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", "||", "REGNO", "(", "operands", "[", "0", "]", ")", "<", "REGNO", "(", "operands", "[", "1", "]", ")", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "operands", "[", "2", "*", "i", "]", "=", "dest", "[", "i", "]", ";", "operands", "[", "2", "*", "i", "+", "1", "]", "=", "src", "[", "i", "]", ";", "}", "}", "else", "{", "for", "(", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "operands", "[", "2", "*", "i", "]", "=", "dest", "[", "count", "-", "i", "-", "1", "]", ";", "operands", "[", "2", "*", "i", "+", "1", "]", "=", "src", "[", "count", "-", "i", "-", "1", "]", ";", "}", "}", "}", "</s>" ]

[ "Set", "up", "OPERANDS", "for", "a", "register", "copy", "from", "SRC", "to", "DEST", ",", "taking", "care", "not", "to", "early-clobber", "SRC", "registers", "in", "the", "process", ".", "We", "assume", "that", "the", "operands", "described", "by", "SRC", "and", "DEST", "represent", "a", "decomposed", "copy", "of", "OPERANDS", "[", "1", "]", "into", "OPERANDS", "[", "0", "]", ".", "COUNT", "is", "the", "number", "of", "components", "into", "which", "the", "copy", "has", "been", "decomposed", "." ]

[ "arm", "0", "1", "0", "1", "0", "2", "2", "1", "0", "2", "1", "2", "1", "1" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "isLegalToSplitMBBAt", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "for", "(", "MachineInstr", "::", "const_mop_iterator", "I", "=", "MBBI", "->", "operands_begin", "(", ")", ",", "E", "=", "MBBI", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isReg", "(", ")", "&&", "!", "I", "->", "getReg", "(", ")", ".", "isVirtual", "(", ")", "&&", "I", "->", "isUse", "(", ")", "&&", "RI", ".", "isPhysRegLiveAcrossClauses", "(", "I", "->", "getReg", "(", ")", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "legal", "to", "split", "the", "given", "basic", "block", "at", "the", "specified", "instruction", "(", "i.e", "." ]

[ "AMDGPU", "R600" ]

[]

[ "<s>", "void", "output_addr_const_pdp11", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "char", "buf", "[", "256", "]", ";", "int", "i", ";", "restart", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "PC", ":", "gcc_assert", "(", "flag_pic", ")", ";", "putc", "(", "'.'", ",", "file", ")", ";", "break", ";", "case", "SYMBOL_REF", ":", "assemble_name", "(", "file", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "LABEL_REF", ":", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "break", ";", "case", "CODE_LABEL", ":", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "x", ")", ")", ";", "assemble_name", "(", "file", ",", "buf", ")", ";", "break", ";", "case", "CONST_INT", ":", "i", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "i", "<", "0", ")", "{", "i", "=", "-", "i", ";", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "}", "if", "(", "TARGET_DEC_ASM", ")", "fprintf", "(", "file", ",", "\"%o\"", ",", "i", "&", "0xffff", ")", ";", "else", "fprintf", "(", "file", ",", "\"%#o\"", ",", "i", "&", "0xffff", ")", ";", "break", ";", "case", "CONST", ":", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "case", "PLUS", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "CONST_INT", ")", "{", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "0", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "}", "else", "{", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"+\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "}", "break", ";", "case", "MINUS", ":", "x", "=", "simplify_subtraction", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "MINUS", ")", "goto", "restart", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", "||", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">=", "0", ")", "fprintf", "(", "file", ",", "\"-\"", ")", ";", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "break", ";", "case", "ZERO_EXTEND", ":", "case", "SIGN_EXTEND", ":", "output_addr_const_pdp11", "(", "file", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "break", ";", "default", ":", "output_operand_lossage", "(", "\"invalid expression as operand\"", ")", ";", "}", "}", "</s>" ]

[ "A", "copy", "of", "output_addr_const", "modified", "for", "pdp11", "expression", "syntax", ".", "output_addr_const", "also", "gets", "called", "for", "%", "cDIGIT", "and", "%", "nDIGIT", ",", "which", "we", "do", "n't", "use", ",", "and", "for", "debugging", "output", ",", "which", "we", "do", "n't", "support", "with", "this", "port", "either", ".", "So", "this", "copy", "should", "get", "called", "whenever", "needed", "." ]

[ "pdp11", "256", "0", "\"L\"", "0", "\"L\"", "0", "\"-\"", "\"%o\"", "0xffff", "\"%#o\"", "0xffff", "0", "0", "1", "0", "0", "\"+\"", "0", "0", "1", "0", "\"+\"", "1", "0", "1", "1", "0", "\"-\"", "1", "0", "\"invalid expression as operand\"" ]

[]

[ "<s>", "void", "GBZ80RegisterInfo", "::", "splitReg", "(", "unsigned", "Reg", ",", "unsigned", "&", "LoReg", ",", "unsigned", "&", "HiReg", ")", "const", "{", "assert", "(", "GB", "::", "R16RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"can only split 16-bit registers\"", ")", ";", "LoReg", "=", "getSubReg", "(", "Reg", ",", "GB", "::", "sub_lo", ")", ";", "HiReg", "=", "getSubReg", "(", "Reg", ",", "GB", "::", "sub_hi", ")", ";", "}", "</s>" ]

[ "Splits", "a", "16-bit", "DREGS", "register", "into", "the", "lo/hi", "register", "pair", "." ]

[ "GBZ80", "GB", "GB::R16RegClass", "\"can only split 16-bit registers\"", "GB::sub_lo", "GB::sub_hi" ]

[]

[ "<s>", "bool", "SystemZTargetLowering", "::", "splitValueIntoRegisterParts", "(", "SelectionDAG", "&", "DAG", ",", "const", "SDLoc", "&", "DL", ",", "SDValue", "Val", ",", "SDValue", "*", "Parts", ",", "unsigned", "NumParts", ",", "MVT", "PartVT", ",", "Optional", "<", "CallingConv", "::", "ID", ">", "CC", ")", "const", "{", "EVT", "ValueVT", "=", "Val", ".", "getValueType", "(", ")", ";", "assert", "(", "(", "ValueVT", "!=", "MVT", "::", "i128", "||", "(", "(", "NumParts", "==", "1", "&&", "PartVT", "==", "MVT", "::", "Untyped", ")", "||", "(", "NumParts", "==", "2", "&&", "PartVT", "==", "MVT", "::", "i64", ")", ")", ")", "&&", "\"Unknown handling of i128 value.\"", ")", ";", "if", "(", "ValueVT", "==", "MVT", "::", "i128", "&&", "NumParts", "==", "1", ")", "{", "Parts", "[", "0", "]", "=", "lowerI128ToGR128", "(", "DAG", ",", "Val", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Target-specific", "splitting", "of", "values", "into", "parts", "that", "fit", "a", "register", "storing", "a", "legal", "type", "." ]

[ "SystemZ", "SystemZ", "MVT::i128", "1", "MVT::Untyped", "2", "MVT::i64", "\"Unknown handling of i128 value.\"", "MVT::i128", "1", "0" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "cs", ")", "const", "{", "DecodeStatus", "Result", "=", "DecodeStatus", "::", "Success", ";", "bool", "Complete", "=", "false", ";", "Size", "=", "0", ";", "*", "CurrentBundle", "=", "&", "MI", ";", "MI", ".", "setOpcode", "(", "Hexagon", "::", "BUNDLE", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "0", ")", ")", ";", "while", "(", "Result", "==", "Success", "&&", "!", "Complete", ")", "{", "if", "(", "Bytes", ".", "size", "(", ")", "<", "HEXAGON_INSTR_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "MCInst", "*", "Inst", "=", "new", "(", "getContext", "(", ")", ")", "MCInst", ";", "Result", "=", "getSingleInstruction", "(", "*", "Inst", ",", "MI", ",", "Bytes", ",", "Address", ",", "cs", ",", "Complete", ")", ";", "MI", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Inst", ")", ")", ";", "Size", "+=", "HEXAGON_INSTR_SIZE", ";", "Bytes", "=", "Bytes", ".", "slice", "(", "HEXAGON_INSTR_SIZE", ")", ";", "}", "if", "(", "Result", "==", "MCDisassembler", "::", "Fail", ")", "return", "Result", ";", "if", "(", "Size", ">", "HEXAGON_MAX_PACKET_SIZE", ")", "return", "MCDisassembler", "::", "Fail", ";", "HexagonMCChecker", "Checker", "(", "getContext", "(", ")", ",", "*", "MCII", ",", "STI", ",", "MI", ",", "*", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ",", "false", ")", ";", "if", "(", "!", "Checker", ".", "check", "(", ")", ")", "return", "MCDisassembler", "::", "Fail", ";", "remapInstruction", "(", "MI", ")", ";", "return", "MCDisassembler", "::", "Success", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "Hexagon::BUNDLE", "0", "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "output_move_multiple", "(", "rtx", "*", "operands", ")", "{", "rtx", "exops", "[", "4", "]", "[", "2", "]", ";", "pdp11_action", "action", "[", "2", "]", ";", "int", "i", ",", "words", ";", "words", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "/", "16", ";", "pdp11_expand_operands", "(", "operands", ",", "exops", ",", "2", ",", "action", ",", "either", ")", ";", "if", "(", "action", "[", "0", "]", "==", "dec_before", ")", "{", "operands", "[", "0", "]", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "output_asm_insn", "(", "\"sub $4,%0\"", ",", "operands", ")", ";", "}", "if", "(", "action", "[", "1", "]", "==", "dec_before", ")", "{", "operands", "[", "1", "]", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "output_asm_insn", "(", "\"sub $4,%1\"", ",", "operands", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "i", "++", ")", "output_asm_insn", "(", "singlemove_string", "(", "exops", "[", "i", "]", ")", ",", "exops", "[", "i", "]", ")", ";", "if", "(", "action", "[", "0", "]", "==", "inc_after", ")", "{", "operands", "[", "0", "]", "=", "XEXP", "(", "operands", "[", "0", "]", ",", "0", ")", ";", "output_asm_insn", "(", "\"add $4,%0\"", ",", "operands", ")", ";", "}", "if", "(", "action", "[", "1", "]", "==", "inc_after", ")", "{", "operands", "[", "1", "]", "=", "XEXP", "(", "operands", "[", "1", "]", ",", "0", ")", ";", "output_asm_insn", "(", "\"add $4,%1\"", ",", "operands", ")", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "perform", "a", "multiple-word", "move", "insn", "with", "operands", "OPERANDS", ".", "This", "moves", "2", "or", "4", "words", "depending", "on", "the", "machine", "mode", "of", "the", "operands", "." ]

[ "pdp11", "4", "2", "2", "0", "16", "2", "0", "0", "0", "0", "\"sub $4,%0\"", "1", "1", "1", "0", "\"sub $4,%1\"", "0", "0", "0", "0", "0", "\"add $4,%0\"", "1", "1", "1", "0", "\"add $4,%1\"", "\"\"" ]

[]

[ "<s>", "MachineBasicBlock", "*", "MSP430TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "assert", "(", "(", "MI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Select16", "||", "MI", "->", "getOpcode", "(", ")", "==", "MSP430", "::", "Select8", ")", "&&", "\"Unexpected instr type to insert\"", ")", ";", "const", "BasicBlock", "*", "LLVM_BB", "=", "BB", "->", "getBasicBlock", "(", ")", ";", "MachineFunction", "::", "iterator", "I", "=", "BB", ";", "++", "I", ";", "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "JCC", ")", ")", ".", "addMBB", "(", "copy1MBB", ")", ".", "addImm", "(", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", ";", "F", "->", "insert", "(", "I", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy1MBB", ")", ";", "copy1MBB", "->", "transferSuccessors", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy1MBB", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "MSP430", "::", "PHI", ")", ",", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";", "F", "->", "DeleteMachineInstr", "(", "MI", ")", ";", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "MSP430", "MSP430", "MSP430::Select16", "MSP430::Select8", "\"Unexpected instr type to insert\"", "MSP430::JCC", "3", "MSP430::PHI", "0", "2", "1" ]

[]

[ "<s>", "void", "BPFAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "if", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_4", "||", "Fixup", ".", "getKind", "(", ")", "==", "FK_SecRel_8", ")", "{", "assert", "(", "Value", "==", "0", ")", ";", "return", ";", "}", "assert", "(", "Fixup", ".", "getKind", "(", ")", "==", "FK_PCRel_2", ")", ";", "*", "(", "uint16_t", "*", ")", "&", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "2", "]", "=", "(", "uint16_t", ")", "(", "(", "Value", "-", "8", ")", "/", "8", ")", ";", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "BPF", "BPF", "0", "2", "8", "8" ]

[]

[ "<s>", "static", "bool", "bfin_valid_add", "(", "machine_mode", "mode", ",", "HOST_WIDE_INT", "value", ")", "{", "unsigned", "HOST_WIDE_INT", "v", "=", "value", ">", "0", "?", "value", ":", "-", "value", ";", "int", "sz", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "int", "shift", "=", "sz", "==", "1", "?", "0", ":", "sz", "==", "2", "?", "1", ":", "2", ";", "if", "(", "value", ">", "0", "&&", "sz", "==", "8", ")", "v", "+=", "4", ";", "return", "(", "v", "&", "~", "(", "0x7fff", "<<", "shift", ")", ")", "==", "0", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "legitimate", "memory", "address", "for", "a", "memory", "operand", "of", "mode", "MODE", ".", "Return", "false", "if", "not", "." ]

[ "bfin", "0", "1", "0", "2", "1", "2", "0", "8", "4", "0x7fff", "0" ]

[]

[ "<s>", "static", "void", "moxie_print_operand", "(", "FILE", "*", "file", ",", "rtx", "x", ",", "int", "code", ")", "{", "rtx", "operand", "=", "x", ";", "switch", "(", "code", ")", "{", "case", "0", ":", "break", ";", "default", ":", "LOSE_AND_RETURN", "(", "\"invalid operand modifier letter\"", ",", "x", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operand", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "operand", ")", ">", "MOXIE_R13", ")", "internal_error", "(", "\"internal error: bad register: %d\"", ",", "REGNO", "(", "operand", ")", ")", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "operand", ")", "]", ")", ";", "return", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "XEXP", "(", "operand", ",", "0", ")", ")", ",", "XEXP", "(", "operand", ",", "0", ")", ")", ";", "return", ";", "default", ":", "if", "(", "CONSTANT_P", "(", "operand", ")", ")", "{", "output_addr_const", "(", "file", ",", "operand", ")", ";", "return", ";", "}", "LOSE_AND_RETURN", "(", "\"unexpected operand\"", ",", "x", ")", ";", "}", "}", "</s>" ]

[ "The", "PRINT_OPERAND", "worker", "." ]

[ "moxie", "0", "\"invalid operand modifier letter\"", "\"internal error: bad register: %d\"", "\"%s\"", "0", "0", "\"unexpected operand\"" ]

[]

[ "<s>", "static", "bool", "riscv_classify_address", "(", "struct", "riscv_address_info", "*", "info", ",", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "x", ";", "info", "->", "offset", "=", "const0_rtx", ";", "return", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", ";", "case", "PLUS", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "riscv_valid_offset_p", "(", "info", "->", "offset", ",", "mode", ")", ")", ";", "case", "LO_SUM", ":", "info", "->", "type", "=", "ADDRESS_LO_SUM", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "info", "->", "symbol_type", "=", "riscv_classify_symbolic_expression", "(", "info", "->", "offset", ")", ";", "return", "(", "riscv_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "riscv_valid_lo_sum_p", "(", "info", "->", "symbol_type", ",", "mode", ")", ")", ";", "case", "CONST_INT", ":", "info", "->", "type", "=", "ADDRESS_CONST_INT", ";", "return", "SMALL_OPERAND", "(", "INTVAL", "(", "x", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "address", "for", "machine", "mode", "MODE", ".", "If", "it", "is", ",", "fill", "in", "INFO", "appropriately", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "riscv", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "Cpu0FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "void", "fixup_addr_diff_vecs", "(", "rtx_insn", "*", "first", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "first", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "vec_lab", ",", "pat", ",", "prevpat", ",", "x", ",", "braf_label", ";", "rtx_insn", "*", "prev", ";", "if", "(", "!", "JUMP_TABLE_DATA_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "vec_lab", "=", "XEXP", "(", "XEXP", "(", "pat", ",", "0", ")", ",", "0", ")", ";", "for", "(", "prev", "=", "as_a", "<", "rtx_insn", "*", ">", "(", "vec_lab", ")", ";", ";", "prev", "=", "PREV_INSN", "(", "prev", ")", ")", "{", "if", "(", "!", "JUMP_P", "(", "prev", ")", ")", "continue", ";", "prevpat", "=", "PATTERN", "(", "prev", ")", ";", "if", "(", "GET_CODE", "(", "prevpat", ")", "!=", "PARALLEL", "||", "XVECLEN", "(", "prevpat", ",", "0", ")", "!=", "2", ")", "continue", ";", "x", "=", "XVECEXP", "(", "prevpat", ",", "0", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "USE", ")", "continue", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "&&", "XEXP", "(", "x", ",", "0", ")", "==", "vec_lab", ")", "break", ";", "}", "if", "(", "!", "prev", ")", "continue", ";", "braf_label", "=", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "XVECEXP", "(", "prevpat", ",", "0", ",", "0", ")", ")", ",", "1", ")", ",", "0", ")", ";", "emit_label_after", "(", "as_a", "<", "rtx_insn", "*", ">", "(", "braf_label", ")", ",", "prev", ")", ";", "XEXP", "(", "XEXP", "(", "pat", ",", "0", ")", ",", "0", ")", "=", "braf_label", ";", "}", "}", "</s>" ]

[ "Fix", "up", "ADDR_DIFF_VECs", "." ]

[ "sh", "0", "0", "0", "2", "0", "1", "0", "0", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "void", "RISCVInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "O", ",", "unsigned", "RegNo", ")", "const", "{", "O", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "ExpandMOVSZX_RR", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "IsSigned", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to \"", ")", ";", "unsigned", "Move", ";", "if", "(", "MVTDst", "==", "MVT", "::", "i16", ")", "Move", "=", "M68k", "::", "MOV16rr", ";", "else", "Move", "=", "M68k", "::", "MOV32rr", ";", "unsigned", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "Src", "=", "MIB", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Dst", "!=", "Src", "&&", "\"You cannot use the same Regs with MOVSX_RR\"", ")", ";", "const", "auto", "&", "TRI", "=", "getRegisterInfo", "(", ")", ";", "const", "auto", "*", "RCDst", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Dst", ",", "MVTDst", ")", ";", "const", "auto", "*", "RCSrc", "=", "TRI", ".", "getMaximalPhysRegClass", "(", "Src", ",", "MVTSrc", ")", ";", "assert", "(", "RCDst", "&&", "RCSrc", "&&", "\"Wrong use of MOVSX_RR\"", ")", ";", "assert", "(", "RCDst", "!=", "RCSrc", "&&", "\"You cannot use the same Reg Classes with MOVSX_RR\"", ")", ";", "unsigned", "SSrc", "=", "RI", ".", "getMatchingMegaReg", "(", "Src", ",", "RCDst", ")", ";", "assert", "(", "SSrc", "&&", "\"No viable MEGA register available\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "Dst", "!=", "SSrc", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Move and \"", "<<", "'\\n'", ")", ";", "BuildMI", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "get", "(", "Move", ")", ",", "Dst", ")", ".", "addReg", "(", "SSrc", ")", ";", "}", "if", "(", "IsSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "MIB", ".", "getInstr", "(", ")", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "MIB", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Move", "from", "register", "and", "extend", "." ]

[ "M68k", "M68k", "\"Expand \"", "\" to \"", "MVT::i16", "M68k::MOV16rr", "M68k::MOV32rr", "0", "1", "\"You cannot use the same Regs with MOVSX_RR\"", "\"Wrong use of MOVSX_RR\"", "\"You cannot use the same Reg Classes with MOVSX_RR\"", "\"No viable MEGA register available\"", "\"Move and \"", "\"Sign Extend\"", "\"Zero Extend\"" ]

[]

[ "<s>", "bool", "MipsTargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ")", "{", "PM", ".", "add", "(", "createMipsDelaySlotFillerPass", "(", "*", "this", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Mips", "Mips", "Mips" ]

[]

[ "<s>", "unsigned", "int", "rs6000_special_adjust_field_align", "(", "tree", "type", ",", "unsigned", "int", "computed", ")", "{", "if", "(", "computed", "<=", "32", ")", "return", "computed", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "while", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", "||", "DECL_FIELD_ABI_IGNORED", "(", "field", ")", ")", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "!", "field", ")", "break", ";", "if", "(", "DECL_PACKED", "(", "field", ")", ")", "return", "computed", ";", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "}", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "type", "!=", "error_mark_node", "&&", "(", "TYPE_MODE", "(", "type", ")", "==", "DFmode", "||", "TYPE_MODE", "(", "type", ")", "==", "DCmode", ")", ")", "computed", "=", "MIN", "(", "computed", ",", "32", ")", ";", "return", "computed", ";", "}", "</s>" ]

[ "AIX", "word-aligns", "FP", "doubles", "but", "doubleword-aligns", "64-bit", "ints", "." ]

[ "rs6000", "32", "32" ]

[]

[ "<s>", "int", "riscv_load_store_insns", "(", "rtx", "mem", ",", "rtx_insn", "*", "insn", ")", "{", "enum", "machine_mode", "mode", ";", "bool", "might_split_p", ";", "rtx", "set", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "might_split_p", "=", "true", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "32", ")", "might_split_p", "=", "false", ";", "else", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "64", ")", "{", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "riscv_split_64bit_move_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "set", ")", ")", ")", "might_split_p", "=", "false", ";", "}", "return", "riscv_address_insns", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "mode", ",", "might_split_p", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "implement", "INSN", ",", "given", "that", "it", "loads", "from", "or", "stores", "to", "MEM", "." ]

[ "riscv", "32", "64", "0" ]

[]

[ "<s>", "const", "VERegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "static", "unsigned", "int", "move_elim_pass", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "ninsn", ";", "rtx", "prev", "=", "NULL_RTX", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "ninsn", ")", "{", "rtx", "set", ";", "ninsn", "=", "next_nonnote_nondebug_insn", "(", "insn", ")", ";", "if", "(", "(", "set", "=", "single_set", "(", "insn", ")", ")", "==", "NULL_RTX", ")", "{", "prev", "=", "NULL_RTX", ";", "continue", ";", "}", "if", "(", "prev", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "prev", ")", ",", "SET_SRC", "(", "set", ")", ")", "&&", "rtx_equal_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_SRC", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_DEST", "(", "prev", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_SRC", "(", "set", ")", ")", "&&", "!", "volatile_refs_p", "(", "SET_DEST", "(", "set", ")", ")", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\" Delete insn %d because it is redundant\\n\"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "delete_insn", "(", "insn", ")", ";", "prev", "=", "NULL_RTX", ";", "}", "else", "prev", "=", "set", ";", "}", "if", "(", "dump_file", ")", "print_rtl_with_bb", "(", "dump_file", ",", "get_insns", "(", ")", ",", "0", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Redundant", "move", "elimination", "pass", ".", "Must", "be", "run", "after", "the", "basic", "block", "reordering", "pass", "for", "the", "best", "effect", "." ]

[ "rl78", "\" Delete insn %d because it is redundant\\n\"", "0", "0" ]

[]

[ "<s>", "SDValue", "X86TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedBits", ",", "const", "APInt", "&", "DemandedElts", ",", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "int", "NumElts", "=", "DemandedElts", ".", "getBitWidth", "(", ")", ";", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "X86ISD", "::", "PINSRB", ":", "case", "X86ISD", "::", "PINSRW", ":", "{", "SDValue", "Vec", "=", "Op", ".", "getOperand", "(", "0", ")", ";", "auto", "*", "CIdx", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ".", "getOperand", "(", "2", ")", ")", ";", "MVT", "VecVT", "=", "Vec", ".", "getSimpleValueType", "(", ")", ";", "if", "(", "CIdx", "&&", "CIdx", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "VecVT", ".", "getVectorNumElements", "(", ")", ")", "&&", "!", "DemandedElts", "[", "CIdx", "->", "getZExtValue", "(", ")", "]", ")", "return", "Vec", ";", "break", ";", "}", "}", "SmallVector", "<", "int", ",", "16", ">", "ShuffleMask", ";", "SmallVector", "<", "SDValue", ",", "2", ">", "ShuffleOps", ";", "if", "(", "getTargetShuffleInputs", "(", "Op", ",", "ShuffleOps", ",", "ShuffleMask", ",", "DAG", ",", "Depth", ")", ")", "{", "int", "NumOps", "=", "ShuffleOps", ".", "size", "(", ")", ";", "if", "(", "ShuffleMask", ".", "size", "(", ")", "==", "(", "unsigned", ")", "NumElts", "&&", "llvm", "::", "all_of", "(", "ShuffleOps", ",", "[", "VT", "]", "(", "SDValue", "V", ")", "{", "return", "VT", ".", "getSizeInBits", "(", ")", "==", "V", ".", "getValueSizeInBits", "(", ")", ";", "}", ")", ")", "{", "APInt", "IdentityOp", "=", "APInt", "::", "getAllOnesValue", "(", "NumOps", ")", ";", "bool", "AllUndef", "=", "true", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "NumElts", ";", "++", "i", ")", "{", "int", "M", "=", "ShuffleMask", "[", "i", "]", ";", "if", "(", "SM_SentinelUndef", "==", "M", "||", "!", "DemandedElts", "[", "i", "]", ")", "continue", ";", "AllUndef", "=", "false", ";", "int", "Op", "=", "M", "/", "NumElts", ";", "int", "Index", "=", "M", "%", "NumElts", ";", "if", "(", "M", "<", "0", "||", "Index", "!=", "i", ")", "{", "IdentityOp", ".", "clearAllBits", "(", ")", ";", "break", ";", "}", "IdentityOp", "&=", "APInt", "::", "getOneBitSet", "(", "NumOps", ",", "Op", ")", ";", "if", "(", "IdentityOp", "==", "0", ")", "break", ";", "}", "if", "(", "AllUndef", ")", "return", "DAG", ".", "getUNDEF", "(", "VT", ")", ";", "assert", "(", "(", "IdentityOp", "==", "0", "||", "IdentityOp", ".", "countPopulation", "(", ")", "==", "1", ")", "&&", "\"Multiple identity shuffles detected\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "NumOps", ";", "++", "i", ")", "if", "(", "IdentityOp", "[", "i", "]", ")", "return", "DAG", ".", "getBitcast", "(", "VT", ",", "ShuffleOps", "[", "i", "]", ")", ";", "}", "}", "return", "TargetLowering", "::", "SimplifyMultipleUseDemandedBitsForTargetNode", "(", "Op", ",", "DemandedBits", ",", "DemandedElts", ",", "DAG", ",", "Depth", ")", ";", "}", "</s>" ]

[ "More", "limited", "version", "of", "SimplifyDemandedBits", "that", "can", "be", "used", "to", "``", "look", "through", "''", "ops", "that", "do", "n't", "contribute", "to", "the", "DemandedBits/DemandedElts", "-", "bitwise", "ops", "etc", "." ]

[ "X86", "X86", "X86ISD::PINSRB", "X86ISD::PINSRW", "0", "2", "16", "2", "0", "0", "0", "0", "1", "\"Multiple identity shuffles detected\"", "0" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getInlineAsmLength", "(", "const", "char", "*", "Str", ",", "const", "MCAsmInfo", "&", "MAI", ",", "const", "TargetSubtargetInfo", "*", "STI", ")", "const", "{", "StringRef", "AStr", "(", "Str", ")", ";", "bool", "atInsnStart", "=", "true", ";", "unsigned", "Length", "=", "0", ";", "const", "unsigned", "MaxInstLength", "=", "MAI", ".", "getMaxInstLength", "(", "STI", ")", ";", "for", "(", ";", "*", "Str", ";", "++", "Str", ")", "{", "if", "(", "*", "Str", "==", "'\\n'", "||", "strncmp", "(", "Str", ",", "MAI", ".", "getSeparatorString", "(", ")", ",", "strlen", "(", "MAI", ".", "getSeparatorString", "(", ")", ")", ")", "==", "0", ")", "atInsnStart", "=", "true", ";", "if", "(", "atInsnStart", "&&", "!", "std", "::", "isspace", "(", "static_cast", "<", "unsigned", "char", ">", "(", "*", "Str", ")", ")", ")", "{", "Length", "+=", "MaxInstLength", ";", "atInsnStart", "=", "false", ";", "}", "if", "(", "atInsnStart", "&&", "strncmp", "(", "Str", ",", "MAI", ".", "getCommentString", "(", ")", ".", "data", "(", ")", ",", "MAI", ".", "getCommentString", "(", ")", ".", "size", "(", ")", ")", "==", "0", ")", "atInsnStart", "=", "false", ";", "}", "StringRef", "Occ", "(", "\"##\"", ")", ";", "Length", "+=", "AStr", ".", "count", "(", "Occ", ")", "*", "4", ";", "return", "Length", ";", "}", "</s>" ]

[ "Measure", "the", "specified", "inline", "asm", "to", "determine", "an", "approximation", "of", "its", "length", "." ]

[ "Hexagon", "Hexagon", "0", "0", "0", "\"##\"", "4" ]

[]

[ "<s>", "static", "void", "rs6000_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "switch", "(", "size", ")", "{", "case", "4", ":", "fputs", "(", "\"\\t.long\\t\"", ",", "file", ")", ";", "break", ";", "case", "8", ":", "fputs", "(", "DOUBLE_INT_ASM_OP", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "output_addr_const", "(", "file", ",", "x", ")", ";", "if", "(", "TARGET_ELF", ")", "fputs", "(", "\"@dtprel+0x8000\"", ",", "file", ")", ";", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.c", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "rs6000", "4", "\"\\t.long\\t\"", "8", "\"@dtprel+0x8000\"" ]

[]

[ "<s>", "int", "mn10300_get_live_callee_saved_regs", "(", "void", ")", "{", "int", "mask", ";", "int", "i", ";", "mask", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "LAST_EXTENDED_REGNUM", ";", "i", "++", ")", "if", "(", "regs_ever_live", "[", "i", "]", "&&", "!", "call_used_regs", "[", "i", "]", ")", "mask", "|=", "(", "1", "<<", "i", ")", ";", "if", "(", "(", "mask", "&", "0x3c000", ")", "!=", "0", ")", "mask", "|=", "0x3c000", ";", "return", "mask", ";", "}", "</s>" ]

[ "Returns", "the", "set", "of", "live", ",", "callee-saved", "registers", "as", "a", "bitmask", ".", "The", "callee-saved", "extended", "registers", "can", "not", "be", "stored", "individually", ",", "so", "all", "of", "them", "will", "be", "included", "in", "the", "mask", "if", "any", "one", "of", "them", "is", "used", "." ]

[ "mn10300", "0", "0", "1", "0x3c000", "0", "0x3c000" ]

[]

[ "<s>", "static", "rtx", "emit_memmov", "(", "rtx", "destmem", ",", "rtx", "*", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "HOST_WIDE_INT", "size_to_move", ")", "{", "rtx", "dst", "=", "destmem", ",", "src", "=", "*", "srcmem", ",", "tempreg", ";", "enum", "insn_code", "code", ";", "machine_mode", "move_mode", ";", "int", "piece_size", ",", "i", ";", "piece_size", "=", "1", "<<", "floor_log2", "(", "size_to_move", ")", ";", "while", "(", "!", "int_mode_for_size", "(", "piece_size", "*", "BITS_PER_UNIT", ",", "0", ")", ".", "exists", "(", "&", "move_mode", ")", "||", "(", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ")", "==", "CODE_FOR_nothing", ")", "{", "gcc_assert", "(", "piece_size", ">", "1", ")", ";", "piece_size", ">>=", "1", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "move_mode", ")", ">", "GET_MODE_SIZE", "(", "word_mode", ")", ")", "{", "int", "nunits", "=", "GET_MODE_SIZE", "(", "move_mode", ")", "/", "GET_MODE_SIZE", "(", "word_mode", ")", ";", "if", "(", "!", "mode_for_vector", "(", "word_mode", ",", "nunits", ")", ".", "exists", "(", "&", "move_mode", ")", "||", "(", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ")", "==", "CODE_FOR_nothing", ")", "{", "move_mode", "=", "word_mode", ";", "piece_size", "=", "GET_MODE_SIZE", "(", "move_mode", ")", ";", "code", "=", "optab_handler", "(", "mov_optab", ",", "move_mode", ")", ";", "}", "}", "gcc_assert", "(", "code", "!=", "CODE_FOR_nothing", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "0", ")", ";", "src", "=", "adjust_automodify_address_nv", "(", "src", ",", "move_mode", ",", "srcptr", ",", "0", ")", ";", "gcc_assert", "(", "size_to_move", "%", "piece_size", "==", "0", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "size_to_move", ";", "i", "+=", "piece_size", ")", "{", "tempreg", "=", "gen_reg_rtx", "(", "move_mode", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "code", ")", "(", "tempreg", ",", "src", ")", ")", ";", "emit_insn", "(", "GEN_FCN", "(", "code", ")", "(", "dst", ",", "tempreg", ")", ")", ";", "emit_move_insn", "(", "destptr", ",", "plus_constant", "(", "Pmode", ",", "copy_rtx", "(", "destptr", ")", ",", "piece_size", ")", ")", ";", "emit_move_insn", "(", "srcptr", ",", "plus_constant", "(", "Pmode", ",", "copy_rtx", "(", "srcptr", ")", ",", "piece_size", ")", ")", ";", "dst", "=", "adjust_automodify_address_nv", "(", "dst", ",", "move_mode", ",", "destptr", ",", "piece_size", ")", ";", "src", "=", "adjust_automodify_address_nv", "(", "src", ",", "move_mode", ",", "srcptr", ",", "piece_size", ")", ";", "}", "*", "srcmem", "=", "src", ";", "return", "dst", ";", "}", "</s>" ]

[ "This", "function", "emits", "moves", "to", "copy", "SIZE_TO_MOVE", "bytes", "from", "SRCMEM", "to", "DESTMEM", ".", "SRC", "is", "passed", "by", "pointer", "to", "be", "updated", "on", "return", ".", "Return", "value", "is", "updated", "DST", "." ]

[ "i386", "1", "0", "1", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "Cpu0AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "PrintDebugValueComment", "(", "MI", ",", "OS", ")", ";", "return", ";", "}", "MCInst", "TmpInst0", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst0", ")", ";", "OutStreamer", ".", "EmitInstruction", "(", "TmpInst0", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Cpu0", "Cpu0", "128" ]

[]

[ "<s>", "void", "P2AsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "P2", "P2" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addMachineSSAOptimization", "(", ")", "{", "TargetPassConfig", "::", "addMachineSSAOptimization", "(", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "addPass", "(", "&", "SILoadStoreOptimizerID", ")", ";", "if", "(", "EnableSDWAPeephole", ")", "{", "addPass", "(", "&", "SIPeepholeSDWAID", ")", ";", "addPass", "(", "&", "EarlyMachineLICMID", ")", ";", "addPass", "(", "&", "MachineCSEID", ")", ";", "addPass", "(", "&", "SIFoldOperandsID", ")", ";", "addPass", "(", "&", "DeadMachineInstructionElimID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Methods", "with", "trivial", "inline", "returns", "are", "convenient", "points", "in", "the", "common", "codegen", "pass", "pipeline", "where", "targets", "may", "insert", "passes", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "void", "SparcRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "const", "SparcFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "unsigned", "FrameReg", ";", "int", "Offset", ";", "Offset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "FrameReg", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", "||", "!", "Subtarget", ".", "hasHardQuad", "(", ")", ")", "{", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "STQFri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "Register", "SrcReg", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "Register", "SrcEvenReg", "=", "getSubReg", "(", "SrcReg", ",", "SP", "::", "sub_even64", ")", ";", "Register", "SrcOddReg", "=", "getSubReg", "(", "SrcReg", ",", "SP", "::", "sub_odd64", ")", ";", "MachineInstr", "*", "StMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcEvenReg", ")", ";", "replaceFI", "(", "MF", ",", "*", "StMI", ",", "*", "StMI", ",", "dl", ",", "0", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "SP", "::", "STDFri", ")", ")", ";", "MI", ".", "getOperand", "(", "2", ")", ".", "setReg", "(", "SrcOddReg", ")", ";", "Offset", "+=", "8", ";", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "SP", "::", "LDQFri", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "Register", "DestReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "Register", "DestEvenReg", "=", "getSubReg", "(", "DestReg", ",", "SP", "::", "sub_even64", ")", ";", "Register", "DestOddReg", "=", "getSubReg", "(", "DestReg", ",", "SP", "::", "sub_odd64", ")", ";", "MachineInstr", "*", "LdMI", "=", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestEvenReg", ")", ".", "addReg", "(", "FrameReg", ")", ".", "addImm", "(", "0", ")", ";", "replaceFI", "(", "MF", ",", "*", "LdMI", ",", "*", "LdMI", ",", "dl", ",", "1", ",", "Offset", ",", "FrameReg", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "SP", "::", "LDDFri", ")", ")", ";", "MI", ".", "getOperand", "(", "0", ")", ".", "setReg", "(", "DestOddReg", ")", ";", "Offset", "+=", "8", ";", "}", "}", "replaceFI", "(", "MF", ",", "II", ",", "MI", ",", "dl", ",", "FIOperandNum", ",", "Offset", ",", "FrameReg", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "Sparc", "Sparc", "SP", "SP", "0", "\"Unexpected\"", "Sparc", "Sparc", "Sparc", "1", "SP::STQFri", "2", "SP::sub_even64", "SP::sub_odd64", "SP::STDFri", "0", "0", "SP::STDFri", "2", "8", "SP::LDQFri", "0", "SP::sub_even64", "SP::sub_odd64", "SP::LDDFri", "0", "1", "SP::LDDFri", "0", "8" ]

[]

[ "<s>", "static", "void", "emit_store_conditional", "(", "machine_mode", "mode", ",", "rtx", "res", ",", "rtx", "mem", ",", "rtx", "val", ")", "{", "rtx", "(", "*", "fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "NULL", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "fn", "=", "gen_store_conditionalqi", ";", "break", ";", "case", "E_HImode", ":", "fn", "=", "gen_store_conditionalhi", ";", "break", ";", "case", "E_SImode", ":", "fn", "=", "gen_store_conditionalsi", ";", "break", ";", "case", "E_DImode", ":", "fn", "=", "gen_store_conditionaldi", ";", "break", ";", "case", "E_TImode", ":", "fn", "=", "gen_store_conditionalti", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "PPC405_ERRATUM77", ")", "emit_insn", "(", "gen_hwsync", "(", ")", ")", ";", "emit_insn", "(", "fn", "(", "res", ",", "mem", ",", "val", ")", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "the", "atomic", "operation", "splitters", ".", "Emit", "a", "store-conditional", "instruction", "in", "MODE", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "TargetPassConfig", "*", "RV16KTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "RV16KPassConfig", "(", "*", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "RV16K", "RV16K", "RV16K" ]

[]

[ "<s>", "bool", "nonpic_symbol_mentioned_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "PC", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTPLT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTTPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_DTPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TPOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PLT", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PCREL", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_SYMOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PCREL_SYMOFF", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTFUNCDESC", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_GOTOFFFUNCDESC", ")", ")", "return", "false", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "nonpic_symbol_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "nonpic_symbol_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "references", "a", "SYMBOL_REF", "or", "LABEL_REF", "whose", "symbol", "is", "n't", "protected", "by", "a", "PIC", "unspec", "." ]

[ "sh", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "isVarArg", ",", "bool", "isCalleeStructRet", ",", "bool", "isCallerStructRet", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "Function", "*", "CallerF", "=", "DAG", ".", "getMachineFunction", "(", ")", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", "->", "getCallingConv", "(", ")", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "!", "(", "isa", "<", "GlobalAddressSDNode", ">", "(", "Callee", ")", ")", "&&", "!", "(", "isa", "<", "ExternalSymbolSDNode", ">", "(", "Callee", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "CCMatch", ")", "return", "false", ";", "if", "(", "isVarArg", ")", "return", "false", ";", "if", "(", "isCalleeStructRet", "||", "isCallerStructRet", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

[ "Hexagon", "Hexagon", "ISD::OutputArg", "ISD::InputArg" ]

[]

[ "<s>", "static", "bool", "is_interrupt_func", "(", "tree", "decl", "=", "current_function_decl", ")", "{", "return", "has_attr", "(", "ATTR_INTR", ",", "decl", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "provided", "function", "has", "the", "``", "interrupt", "''", "attribute", "." ]

[ "msp430" ]

[]

[ "<s>", "bool", "microblaze_tls_symbol_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "!=", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "a", "thread-local", "symbol", "." ]

[ "microblaze", "0" ]

[]

[ "<s>", "void", "PPCOperand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "Immediate", ":", "case", "ContextImmediate", ":", "OS", "<<", "getImm", "(", ")", ";", "break", ";", "case", "Expression", ":", "OS", "<<", "*", "getExpr", "(", ")", ";", "break", ";", "case", "TLSRegister", ":", "OS", "<<", "*", "getTLSReg", "(", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "PowerPC", "PPC", "\"'\"", "\"'\"" ]

[]

[ "<s>", "enum", "reg_class", "vfp_secondary_reload_class", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "arm_coproc_mem_operand", "(", "x", ",", "FALSE", ")", "||", "s_register_operand", "(", "x", ",", "mode", ")", ")", "return", "NO_REGS", ";", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "GENERAL_REGS", "if", "a", "scratch", "register", "required", "to", "reload", "x", "to/from", "VFP", "registers", ".", "Otherwise", "return", "NO_REGS", "." ]

[ "arm" ]

[]

[ "<s>", "static", "bool", "insn_terminates_group_p", "(", "rtx_insn", "*", "insn", ",", "enum", "group_termination", "which_group", ")", "{", "bool", "first", ",", "last", ";", "if", "(", "!", "insn", ")", "return", "false", ";", "first", "=", "insn_must_be_first_in_group", "(", "insn", ")", ";", "last", "=", "insn_must_be_last_in_group", "(", "insn", ")", ";", "if", "(", "first", "&&", "last", ")", "return", "true", ";", "if", "(", "which_group", "==", "current_group", ")", "return", "last", ";", "else", "if", "(", "which_group", "==", "previous_group", ")", "return", "first", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "the", "presence", "of", "INSN", "causes", "a", "dispatch", "group", "termination", "of", "group", "WHICH_GROUP", ".", "If", "WHICH_GROUP", "==", "current_group", ",", "this", "function", "will", "return", "true", "if", "INSN", "causes", "the", "termination", "of", "the", "current", "group", "(", "i.e", ",", "the", "dispatch", "group", "to", "which", "INSN", "belongs", ")", ".", "This", "means", "that", "INSN", "will", "be", "the", "last", "insn", "in", "the", "group", "it", "belongs", "to", ".", "If", "WHICH_GROUP", "==", "previous_group", ",", "this", "function", "will", "return", "true", "if", "INSN", "causes", "the", "termination", "of", "the", "previous", "group", "(", "i.e", ",", "the", "dispatch", "group", "that", "precedes", "the", "group", "to", "which", "INSN", "belongs", ")", ".", "This", "means", "that", "INSN", "will", "be", "the", "first", "insn", "in", "the", "group", "it", "belongs", "to", ")", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "Initialize", "(", "MCContext", "&", "ctx", ",", "const", "TargetMachine", "&", "TM", ")", "override", "{", "TargetLoweringObjectFile", "::", "Initialize", "(", "ctx", ",", "TM", ")", ";", "TextSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getText", "(", ")", ")", ";", "DataSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getData", "(", ")", ")", ";", "BSSSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "ReadOnlySection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getReadOnly", "(", ")", ")", ";", "StaticCtorSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "StaticDtorSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "LSDASection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "EHFrameSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfAbbrevSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfInfoSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLineSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfFrameSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfPubTypesSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfDebugInlineSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfStrSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfLocSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfARangesSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "DwarfRangesSection", "=", "new", "NVPTXSection", "(", "MCSection", "::", "SV_ELF", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "XCoreFrameInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "DisableFramePointerElim", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedVGPRs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedVGPRs", ",", "RS", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "SavedVGPRs", ".", "clearBitsNotInMask", "(", "TRI", "->", "getAllVGPRRegMask", "(", ")", ")", ";", "const", "bool", "WillHaveFP", "=", "FrameInfo", ".", "hasCalls", "(", ")", "&&", "(", "SavedVGPRs", ".", "any", "(", ")", "||", "!", "allStackObjectsAreDead", "(", "FrameInfo", ")", ")", ";", "for", "(", "auto", "SSpill", ":", "MFI", "->", "getSGPRSpillVGPRs", "(", ")", ")", "SavedVGPRs", ".", "reset", "(", "SSpill", ".", "VGPR", ")", ";", "const", "bool", "HasFP", "=", "WillHaveFP", "||", "hasFP", "(", "MF", ")", ";", "if", "(", "!", "HasFP", ")", "return", ";", "if", "(", "MFI", "->", "haveFreeLanesForSGPRSpill", "(", "MF", ",", "1", ")", ")", "{", "int", "NewFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "4", ",", "4", ",", "true", ",", "nullptr", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "!", "MFI", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "NewFI", ")", ")", "llvm_unreachable", "(", "\"allocate SGPR spill should have worked\"", ")", ";", "MFI", "->", "FramePointerSaveIndex", "=", "NewFI", ";", "LLVM_DEBUG", "(", "auto", "Spill", "=", "MFI", "->", "getSGPRToVGPRSpills", "(", "NewFI", ")", ".", "front", "(", ")", ";", "dbgs", "(", ")", "<<", "\"Spilling FP to \"", "<<", "printReg", "(", "Spill", ".", "VGPR", ",", "TRI", ")", "<<", "':'", "<<", "Spill", ".", "Lane", "<<", "'\\n'", ")", ";", "return", ";", "}", "MFI", "->", "SGPRForFPSaveRestoreCopy", "=", "findUnusedSGPRNonCalleeSaved", "(", "MF", ".", "getRegInfo", "(", ")", ")", ";", "if", "(", "!", "MFI", "->", "SGPRForFPSaveRestoreCopy", ")", "{", "int", "NewFI", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "CreateStackObject", "(", "4", ",", "4", ",", "true", ",", "nullptr", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "if", "(", "!", "MFI", "->", "allocateSGPRSpillToVGPR", "(", "MF", ",", "NewFI", ")", ")", "llvm_unreachable", "(", "\"allocate SGPR spill should have worked\"", ")", ";", "MFI", "->", "FramePointerSaveIndex", "=", "NewFI", ";", "LLVM_DEBUG", "(", "auto", "Spill", "=", "MFI", "->", "getSGPRToVGPRSpills", "(", "NewFI", ")", ".", "front", "(", ")", ";", "dbgs", "(", ")", "<<", "\"FP requires fallback spill to \"", "<<", "printReg", "(", "Spill", ".", "VGPR", ",", "TRI", ")", "<<", "':'", "<<", "Spill", ".", "Lane", "<<", "'\\n'", ";", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Saving FP with copy to \"", "<<", "printReg", "(", "MFI", "->", "SGPRForFPSaveRestoreCopy", ",", "TRI", ")", "<<", "'\\n'", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "SI", "1", "4", "4", "\"allocate SGPR spill should have worked\"", "\"Spilling FP to \"", "4", "4", "\"allocate SGPR spill should have worked\"", "\"FP requires fallback spill to \"", "\"Saving FP with copy to \"" ]

[]

[ "<s>", "static", "bool", "empty_asm_p", "(", "rtx", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "const", "char", "*", "templ", ";", "if", "(", "GET_CODE", "(", "body", ")", "==", "ASM_INPUT", ")", "templ", "=", "XSTR", "(", "body", ",", "0", ")", ";", "else", "if", "(", "asm_noperands", "(", "body", ")", ">=", "0", ")", "templ", "=", "decode_asm_operands", "(", "body", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ",", "NULL", ")", ";", "else", "templ", "=", "NULL", ";", "return", "(", "templ", "&&", "templ", "[", "0", "]", "==", "'\\0'", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "INSN", "is", "an", "empty", "asm", "instruction", "." ]

[ "visium", "0", "0", "0" ]

[]

[ "<s>", "static", "enum", "aarch64_parse_opt_result", "aarch64_parse_cpu", "(", "const", "char", "*", "to_parse", ",", "const", "struct", "processor", "*", "*", "res", ",", "unsigned", "long", "*", "isa_flags", ")", "{", "char", "*", "ext", ";", "const", "struct", "processor", "*", "cpu", ";", "char", "*", "str", "=", "(", "char", "*", ")", "alloca", "(", "strlen", "(", "to_parse", ")", "+", "1", ")", ";", "size_t", "len", ";", "strcpy", "(", "str", ",", "to_parse", ")", ";", "ext", "=", "strchr", "(", "str", ",", "'+'", ")", ";", "if", "(", "ext", "!=", "NULL", ")", "len", "=", "ext", "-", "str", ";", "else", "len", "=", "strlen", "(", "str", ")", ";", "if", "(", "len", "==", "0", ")", "return", "AARCH64_PARSE_MISSING_ARG", ";", "for", "(", "cpu", "=", "all_cores", ";", "cpu", "->", "name", "!=", "NULL", ";", "cpu", "++", ")", "{", "if", "(", "strlen", "(", "cpu", "->", "name", ")", "==", "len", "&&", "strncmp", "(", "cpu", "->", "name", ",", "str", ",", "len", ")", "==", "0", ")", "{", "unsigned", "long", "isa_temp", "=", "cpu", "->", "flags", ";", "if", "(", "ext", "!=", "NULL", ")", "{", "enum", "aarch64_parse_opt_result", "ext_res", "=", "aarch64_parse_extension", "(", "ext", ",", "&", "isa_temp", ")", ";", "if", "(", "ext_res", "!=", "AARCH64_PARSE_OK", ")", "return", "ext_res", ";", "}", "*", "res", "=", "cpu", ";", "*", "isa_flags", "=", "isa_temp", ";", "return", "AARCH64_PARSE_OK", ";", "}", "}", "return", "AARCH64_PARSE_INVALID_ARG", ";", "}", "</s>" ]

[ "Parse", "the", "TO_PARSE", "string", "and", "put", "the", "result", "tuning", "in", "RES", "and", "the", "architecture", "flags", "in", "ISA_FLAGS", ".", "Return", "an", "aarch64_parse_opt_result", "describing", "the", "parse", "result", ".", "If", "there", "is", "an", "error", "parsing", ",", "RES", "and", "ISA_FLAGS", "are", "left", "unchanged", "." ]

[ "aarch64", "1", "0", "0" ]

[]

[ "<s>", "unsigned", "Z80InstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", "&&", "!", "MI", ".", "getOperand", "(", "2", ")", ".", "getSubReg", "(", ")", "&&", "isFrameOperand", "(", "MI", ",", "0", ",", "FrameIndex", ")", ")", "return", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Z80", "Z80", "2", "0", "2", "0" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********* Hexagon Hardware Loops *********\\n\"", ")", ";", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "HexagonSubtarget", "&", "HST", "=", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ";", "TII", "=", "HST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "HST", ".", "getRegisterInfo", "(", ")", ";", "for", "(", "auto", "&", "L", ":", "*", "MLI", ")", "if", "(", "!", "L", "->", "getParentLoop", "(", ")", ")", "{", "bool", "L0Used", "=", "false", ";", "bool", "L1Used", "=", "false", ";", "Changed", "|=", "convertToHardwareLoop", "(", "L", ",", "L0Used", ",", "L1Used", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "Hexagon", "Hexagon", "\"********* Hexagon Hardware Loops *********\\n\"", "Hexagon", "Hexagon" ]

[]

[ "<s>", "void", "TL45AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "TmpInst", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "if", "(", "LowerTL45MachineOperandToMCOperand", "(", "MO", ",", "MCOp", ",", "*", "this", ")", ")", "TmpInst", ".", "addOperand", "(", "MCOp", ")", ";", "}", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "TL45", "TL45", "TL45" ]

[]

[ "<s>", "bool", "isCollapsed", "(", ")", "const", "{", "return", "Instrs", ".", "empty", "(", ")", ";", "}", "</s>" ]

[ "A", "collapsed", "DomainValue", "has", "no", "instructions", "to", "twiddle", "-", "it", "simply", "keeps", "track", "of", "the", "domains", "where", "the", "registers", "are", "already", "available", "." ]

[ "X86" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"C64x+ cluster assignment\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "TMS320C64X", "\"C64x+ cluster assignment\"" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"AArch64 branch fixup pass\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "AArch64", "\"AArch64 branch fixup pass\"" ]

[]

[ "<s>", "const", "SICMCExpr", "*", "SICMCExpr", "::", "create", "(", "const", "MCSymbol", "*", "Symbol", ",", "SICMCExpr", "::", "SICExprKind", "Kind", ",", "MCContext", "&", "Ctx", ")", "{", "const", "MCSymbolRefExpr", "*", "MCSym", "=", "MCSymbolRefExpr", "::", "create", "(", "Symbol", ",", "MCSymbolRefExpr", "::", "VK_None", ",", "Ctx", ")", ";", "return", "new", "(", "Ctx", ")", "SICMCExpr", "(", "Kind", ",", "MCSym", ")", ";", "}", "</s>" ]

[ "This", "creates", "an", "identified", "struct", "." ]

[ "SIC", "SIC", "SIC", "SIC", "SIC", "SIC" ]

[]

[ "<s>", "unsigned", "MBlazeInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", "->", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MBlazeFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "MBlaze", "::", "GPRRegClass", ")", ";", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "MBlaze", "::", "R20", ")", ";", "RegInfo", ".", "addLiveIn", "(", "MBlaze", "::", "R20", ")", ";", "MBlazeFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze::GPRRegClass", "MBlaze::R20", "MBlaze::R20", "MBlaze" ]

[]

[ "<s>", "bool", "X86CmovConverterPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableCmovConverter", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MLI", "=", "&", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TSchedModel", ".", "init", "(", "&", "STI", ")", ";", "if", "(", "ForceMemOperand", ")", "{", "CmovGroups", "AllCmovGroups", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "4", ">", "Blocks", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Blocks", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "collectCmovCandidates", "(", "Blocks", ",", "AllCmovGroups", ",", "true", ")", ")", "{", "for", "(", "auto", "&", "Group", ":", "AllCmovGroups", ")", "{", "if", "(", "llvm", "::", "none_of", "(", "Group", ",", "[", "&", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "I", "->", "mayLoad", "(", ")", ";", "}", ")", ")", "continue", ";", "Changed", "=", "true", ";", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "}", "}", "SmallVector", "<", "MachineLoop", "*", ",", "4", ">", "Loops", "(", "MLI", "->", "begin", "(", ")", ",", "MLI", "->", "end", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "int", ")", "Loops", ".", "size", "(", ")", ";", "++", "i", ")", "for", "(", "MachineLoop", "*", "Child", ":", "Loops", "[", "i", "]", "->", "getSubLoops", "(", ")", ")", "Loops", ".", "push_back", "(", "Child", ")", ";", "for", "(", "MachineLoop", "*", "CurrLoop", ":", "Loops", ")", "{", "if", "(", "!", "CurrLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "continue", ";", "CmovGroups", "CmovInstGroups", ";", "if", "(", "!", "collectCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "if", "(", "!", "checkForProfitableCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "&", "Group", ":", "CmovInstGroups", ")", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86", "\"********** \"", "\" : \"", "\"**********\\n\"", "4", "4", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "X86FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "bool", "reserveCallFrame", "=", "hasReservedCallFrame", "(", "MF", ")", ";", "unsigned", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reserveCallFrame", "?", "TII", ".", "getFrameSize", "(", "*", "I", ")", ":", "0", ";", "uint64_t", "InternalAmt", "=", "(", "isDestroy", "||", "Amount", ")", "?", "TII", ".", "getFrameAdjustment", "(", "*", "I", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "auto", "InsertPos", "=", "skipDebugInstructionsForward", "(", "I", ",", "MBB", ".", "end", "(", ")", ")", ";", "if", "(", "!", "reserveCallFrame", ")", "{", "unsigned", "StackAlign", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "StackAlign", ")", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "Function", "*", "Fn", "=", "MF", ".", "getFunction", "(", ")", ";", "bool", "WindowsCFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "usesWindowsCFI", "(", ")", ";", "bool", "DwarfCFI", "=", "!", "WindowsCFI", "&&", "(", "MMI", ".", "hasDebugInfo", "(", ")", "||", "Fn", "->", "needsUnwindTableEntry", "(", ")", ")", ";", "bool", "HasDwarfEHHandlers", "=", "!", "WindowsCFI", "&&", "!", "MF", ".", "getLandingPads", "(", ")", ".", "empty", "(", ")", ";", "if", "(", "HasDwarfEHHandlers", "&&", "!", "isDestroy", "&&", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "getHasPushSequences", "(", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createGnuArgsSize", "(", "nullptr", ",", "Amount", ")", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "I", ";", "Amount", "-=", "InternalAmt", ";", "if", "(", "isDestroy", "&&", "InternalAmt", "&&", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "-", "InternalAmt", ")", ")", ";", "int64_t", "StackAdjustment", "=", "isDestroy", "?", "Amount", ":", "-", "Amount", ";", "int64_t", "CfaAdjustment", "=", "-", "StackAdjustment", ";", "if", "(", "StackAdjustment", ")", "{", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "true", ")", ";", "StackAdjustment", "+=", "mergeSPUpdates", "(", "MBB", ",", "InsertPos", ",", "false", ")", ";", "if", "(", "StackAdjustment", ")", "{", "if", "(", "!", "(", "Fn", "->", "optForMinSize", "(", ")", "&&", "adjustStackWithPops", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ")", ")", ")", "BuildStackAdjustment", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "StackAdjustment", ",", "false", ")", ";", "}", "}", "if", "(", "DwarfCFI", "&&", "!", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "CfaAdjustment", ")", "{", "BuildCFI", "(", "MBB", ",", "InsertPos", ",", "DL", ",", "MCCFIInstruction", "::", "createAdjustCfaOffset", "(", "nullptr", ",", "CfaAdjustment", ")", ")", ";", "}", "}", "return", "I", ";", "}", "if", "(", "isDestroy", "&&", "InternalAmt", ")", "{", "MachineBasicBlock", "::", "iterator", "CI", "=", "I", ";", "MachineBasicBlock", "::", "iterator", "B", "=", "MBB", ".", "begin", "(", ")", ";", "while", "(", "CI", "!=", "B", "&&", "!", "std", "::", "prev", "(", "CI", ")", "->", "isCall", "(", ")", ")", "--", "CI", ";", "BuildStackAdjustment", "(", "MBB", ",", "CI", ",", "DL", ",", "-", "InternalAmt", ",", "false", ")", ";", "}", "return", "I", ";", "}", "</s>" ]

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

[ "X86", "X86", "0", "0", "X86", "0" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitInlineAsmEnd", "(", "const", "MCSubtargetInfo", "&", "StartInfo", ",", "const", "MCSubtargetInfo", "*", "EndInfo", ")", "const", "{", "const", "bool", "WasThumb", "=", "isThumb", "(", "StartInfo", ")", ";", "if", "(", "!", "EndInfo", "||", "WasThumb", "!=", "isThumb", "(", "*", "EndInfo", ")", ")", "{", "OutStreamer", "->", "emitAssemblerFlag", "(", "WasThumb", "?", "MCAF_Code16", ":", "MCAF_Code32", ")", ";", "}", "}", "</s>" ]

[ "Let", "the", "target", "do", "anything", "it", "needs", "to", "do", "after", "emitting", "inlineasm", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"Mandarin DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "Mandarin", "\"Mandarin DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "void", "ix86_add_reg_usage_to_vzerouppers", "(", "void", ")", "{", "basic_block", "bb", ";", "rtx_insn", "*", "insn", ";", "auto_bitmap", "live_regs", ";", "df_analyze", "(", ")", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "bitmap_copy", "(", "live_regs", ",", "df_get_live_out", "(", "bb", ")", ")", ";", "df_simulate_initialize_backwards", "(", "bb", ",", "live_regs", ")", ";", "FOR_BB_INSNS_REVERSE", "(", "bb", ",", "insn", ")", "{", "if", "(", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "continue", ";", "if", "(", "vzeroupper_pattern", "(", "PATTERN", "(", "insn", ")", ",", "VOIDmode", ")", ")", "ix86_add_reg_usage_to_vzeroupper", "(", "insn", ",", "live_regs", ")", ";", "df_simulate_one_insn_backwards", "(", "bb", ",", "insn", ",", "live_regs", ")", ";", "}", "}", "}", "</s>" ]

[ "Walk", "the", "vzeroupper", "instructions", "in", "the", "function", "and", "annotate", "them", "with", "the", "effect", "that", "they", "have", "on", "the", "SSE", "registers", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "XCoreRegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "Units", ".", "none", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "ix86_expand_fp_absneg_operator", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "set", ",", "dst", ",", "src", ";", "bool", "use_sse", "=", "false", ";", "bool", "vector_mode", "=", "VECTOR_MODE_P", "(", "mode", ")", ";", "machine_mode", "vmode", "=", "mode", ";", "rtvec", "par", ";", "if", "(", "vector_mode", "||", "mode", "==", "TFmode", "||", "mode", "==", "HFmode", ")", "{", "use_sse", "=", "true", ";", "if", "(", "mode", "==", "HFmode", ")", "vmode", "=", "V8HFmode", ";", "}", "else", "if", "(", "TARGET_SSE_MATH", ")", "{", "use_sse", "=", "SSE_FLOAT_MODE_P", "(", "mode", ")", ";", "if", "(", "mode", "==", "SFmode", ")", "vmode", "=", "V4SFmode", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "vmode", "=", "V2DFmode", ";", "}", "dst", "=", "operands", "[", "0", "]", ";", "src", "=", "operands", "[", "1", "]", ";", "set", "=", "gen_rtx_fmt_e", "(", "code", ",", "mode", ",", "src", ")", ";", "set", "=", "gen_rtx_SET", "(", "dst", ",", "set", ")", ";", "if", "(", "use_sse", ")", "{", "rtx", "mask", ",", "use", ",", "clob", ";", "mask", "=", "ix86_build_signbit_mask", "(", "vmode", ",", "vector_mode", ",", "code", "==", "ABS", ")", ";", "use", "=", "gen_rtx_USE", "(", "VOIDmode", ",", "mask", ")", ";", "if", "(", "vector_mode", "||", "mode", "==", "TFmode", ")", "par", "=", "gen_rtvec", "(", "2", ",", "set", ",", "use", ")", ";", "else", "{", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "par", "=", "gen_rtvec", "(", "3", ",", "set", ",", "use", ",", "clob", ")", ";", "}", "}", "else", "{", "rtx", "clob", ";", "clob", "=", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "FLAGS_REG", ")", ")", ";", "par", "=", "gen_rtvec", "(", "2", ",", "set", ",", "clob", ")", ";", "}", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "par", ")", ")", ";", "}", "</s>" ]

[ "Generate", "code", "for", "floating", "point", "ABS", "or", "NEG", "." ]

[ "i386", "0", "1", "2", "3", "2" ]

[]

[ "<s>", "static", "enum", "reg_class", "rs6000_debug_secondary_reload_class", "(", "enum", "reg_class", "rclass", ",", "machine_mode", "mode", ",", "rtx", "in", ")", "{", "enum", "reg_class", "ret", "=", "rs6000_secondary_reload_class", "(", "rclass", ",", "mode", ",", "in", ")", ";", "fprintf", "(", "stderr", ",", "\"\\nrs6000_secondary_reload_class, return %s, rclass = %s, \"", "\"mode = %s, input rtx:\\n\"", ",", "reg_class_names", "[", "ret", "]", ",", "reg_class_names", "[", "rclass", "]", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "debug_rtx", "(", "in", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Debug", "version", "of", "rs6000_secondary_reload_class", "." ]

[ "powerpcspe", "\"\\nrs6000_secondary_reload_class, return %s, rclass = %s, \"", "\"mode = %s, input rtx:\\n\"" ]

[]

[ "<s>", "bool", "WebAssemblySetP2AlignOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Set p2align Operands **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "LOAD_I32", ":", "case", "WebAssembly", "::", "LOAD_I64", ":", "case", "WebAssembly", "::", "LOAD_F32", ":", "case", "WebAssembly", "::", "LOAD_F64", ":", "case", "WebAssembly", "::", "LOAD8_S_I32", ":", "case", "WebAssembly", "::", "LOAD8_U_I32", ":", "case", "WebAssembly", "::", "LOAD16_S_I32", ":", "case", "WebAssembly", "::", "LOAD16_U_I32", ":", "case", "WebAssembly", "::", "LOAD8_S_I64", ":", "case", "WebAssembly", "::", "LOAD8_U_I64", ":", "case", "WebAssembly", "::", "LOAD16_S_I64", ":", "case", "WebAssembly", "::", "LOAD16_U_I64", ":", "case", "WebAssembly", "::", "LOAD32_S_I64", ":", "case", "WebAssembly", "::", "LOAD32_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I32", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD8_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD16_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_LOAD32_U_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW8_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW16_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_AND_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_OR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XOR_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XCHG_I32", ":", "case", "WebAssembly", "::", "ATOMIC_RMW32_U_XCHG_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_ADD_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_SUB_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_AND_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_OR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XOR_I64", ":", "case", "WebAssembly", "::", "ATOMIC_RMW_XCHG_I64", ":", "RewriteP2Align", "(", "MI", ",", "WebAssembly", "::", "LoadP2AlignOperandNo", ")", ";", "break", ";", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I32", ":", "case", "WebAssembly", "::", "ATOMIC_STORE_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE8_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE16_I64", ":", "case", "WebAssembly", "::", "ATOMIC_STORE32_I64", ":", "RewriteP2Align", "(", "MI", ",", "WebAssembly", "::", "StoreP2AlignOperandNo", ")", ";", "break", ";", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "WebAssembly", "WebAssembly", "\"********** Set p2align Operands **********\\n\"", "\"********** Function: \"", "WebAssembly::LOAD_I32", "WebAssembly::LOAD_I64", "WebAssembly::LOAD_F32", "WebAssembly::LOAD_F64", "WebAssembly::LOAD8_S_I32", "WebAssembly::LOAD8_U_I32", "WebAssembly::LOAD16_S_I32", "WebAssembly::LOAD16_U_I32", "WebAssembly::LOAD8_S_I64", "WebAssembly::LOAD8_U_I64", "WebAssembly::LOAD16_S_I64", "WebAssembly::LOAD16_U_I64", "WebAssembly::LOAD32_S_I64", "WebAssembly::LOAD32_U_I64", "WebAssembly::ATOMIC_LOAD_I32", "WebAssembly::ATOMIC_LOAD8_U_I32", "WebAssembly::ATOMIC_LOAD16_U_I32", "WebAssembly::ATOMIC_LOAD_I64", "WebAssembly::ATOMIC_LOAD8_U_I64", "WebAssembly::ATOMIC_LOAD16_U_I64", "WebAssembly::ATOMIC_LOAD32_U_I64", "WebAssembly::ATOMIC_RMW8_U_ADD_I32", "WebAssembly::ATOMIC_RMW8_U_ADD_I64", "WebAssembly::ATOMIC_RMW8_U_SUB_I32", "WebAssembly::ATOMIC_RMW8_U_SUB_I64", "WebAssembly::ATOMIC_RMW8_U_AND_I32", "WebAssembly::ATOMIC_RMW8_U_AND_I64", "WebAssembly::ATOMIC_RMW8_U_OR_I32", "WebAssembly::ATOMIC_RMW8_U_OR_I64", "WebAssembly::ATOMIC_RMW8_U_XOR_I32", "WebAssembly::ATOMIC_RMW8_U_XOR_I64", "WebAssembly::ATOMIC_RMW8_U_XCHG_I32", "WebAssembly::ATOMIC_RMW8_U_XCHG_I64", "WebAssembly::ATOMIC_RMW16_U_ADD_I32", "WebAssembly::ATOMIC_RMW16_U_ADD_I64", "WebAssembly::ATOMIC_RMW16_U_SUB_I32", "WebAssembly::ATOMIC_RMW16_U_SUB_I64", "WebAssembly::ATOMIC_RMW16_U_AND_I32", "WebAssembly::ATOMIC_RMW16_U_AND_I64", "WebAssembly::ATOMIC_RMW16_U_OR_I32", "WebAssembly::ATOMIC_RMW16_U_OR_I64", "WebAssembly::ATOMIC_RMW16_U_XOR_I32", "WebAssembly::ATOMIC_RMW16_U_XOR_I64", "WebAssembly::ATOMIC_RMW16_U_XCHG_I32", "WebAssembly::ATOMIC_RMW16_U_XCHG_I64", "WebAssembly::ATOMIC_RMW_ADD_I32", "WebAssembly::ATOMIC_RMW32_U_ADD_I64", "WebAssembly::ATOMIC_RMW_SUB_I32", "WebAssembly::ATOMIC_RMW32_U_SUB_I64", "WebAssembly::ATOMIC_RMW_AND_I32", "WebAssembly::ATOMIC_RMW32_U_AND_I64", "WebAssembly::ATOMIC_RMW_OR_I32", "WebAssembly::ATOMIC_RMW32_U_OR_I64", "WebAssembly::ATOMIC_RMW_XOR_I32", "WebAssembly::ATOMIC_RMW32_U_XOR_I64", "WebAssembly::ATOMIC_RMW_XCHG_I32", "WebAssembly::ATOMIC_RMW32_U_XCHG_I64", "WebAssembly::ATOMIC_RMW_ADD_I64", "WebAssembly::ATOMIC_RMW_SUB_I64", "WebAssembly::ATOMIC_RMW_AND_I64", "WebAssembly::ATOMIC_RMW_OR_I64", "WebAssembly::ATOMIC_RMW_XOR_I64", "WebAssembly::ATOMIC_RMW_XCHG_I64", "WebAssembly::LoadP2AlignOperandNo", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "WebAssembly::ATOMIC_STORE_I32", "WebAssembly::ATOMIC_STORE8_I32", "WebAssembly::ATOMIC_STORE16_I32", "WebAssembly::ATOMIC_STORE_I64", "WebAssembly::ATOMIC_STORE8_I64", "WebAssembly::ATOMIC_STORE16_I64", "WebAssembly::ATOMIC_STORE32_I64", "WebAssembly::StoreP2AlignOperandNo" ]

[]