Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "bool", "reseveCallFrame", "=", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ";", "int", "Opcode", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "isDestroy", "=", "Opcode", "==", "getCallFrameDestroyOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "uint64_t", "Amount", "=", "!", "reseveCallFrame", "?", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ":", "0", ";", "uint64_t", "CalleeAmt", "=", "isDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "I", "=", "MBB", ".", "erase", "(", "I", ")", ";", "if", "(", "!", "reseveCallFrame", ")", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Opcode", "==", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "getSUBriOpcode", "(", "Is64Bit", ",", "Amount", ")", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Opcode", "==", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "{", "unsigned", "Opc", "=", "getADDriOpcode", "(", "Is64Bit", ",", "Amount", ")", ";", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "return", ";", "}", "if", "(", "Opcode", "==", "getCallFrameDestroyOpcode", "(", ")", "&&", "CalleeAmt", ")", "{", "unsigned", "Opc", "=", "getSUBriOpcode", "(", "Is64Bit", ",", "CalleeAmt", ")", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "StackPtr", ")", ".", "addReg", "(", "StackPtr", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "</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", "1", "0", "0", "1", "0", "3", "3" ]

[]

[ "<s>", "void", "XCoreMCInstLower", "::", "Initialize", "(", "MCContext", "*", "C", ")", "{", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "const", "char", "*", "arithmetic_instr", "(", "rtx", "op", ",", "int", "shift_first_arg", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "PLUS", ":", "return", "\"add\"", ";", "case", "MINUS", ":", "return", "shift_first_arg", "?", "\"rsb\"", ":", "\"sub\"", ";", "case", "IOR", ":", "return", "\"orr\"", ";", "case", "XOR", ":", "return", "\"eor\"", ";", "case", "AND", ":", "return", "\"and\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "appropriate", "ARM", "instruction", "for", "the", "operation", "code", ".", "The", "returned", "result", "should", "not", "be", "overwritten", ".", "OP", "is", "the", "rtx", "of", "the", "operation", ".", "SHIFT_FIRST_ARG", "is", "TRUE", "if", "the", "first", "argument", "of", "the", "operator", "was", "shifted", "." ]

[ "arm", "\"add\"", "\"rsb\"", "\"sub\"", "\"orr\"", "\"eor\"", "\"and\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "CAHPTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "TargetRegisterInfo", "*", "TRI", ",", "StringRef", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "CAHP", "::", "GPRRegClass", ")", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "TRI", ",", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "CAHP", "CAHP", "1", "0", "0U", "CAHP::GPRRegClass" ]

[]

[ "<s>", "bool", "aarch64_masks_and_shift_for_bfi_p", "(", "scalar_int_mode", "mode", ",", "unsigned", "HOST_WIDE_INT", "mask1", ",", "unsigned", "HOST_WIDE_INT", "shft_amnt", ",", "unsigned", "HOST_WIDE_INT", "mask2", ")", "{", "unsigned", "HOST_WIDE_INT", "t", ";", "if", "(", "mask1", "!=", "~", "mask2", ")", "return", "false", ";", "if", "(", "mask2", "==", "0", "||", "mask2", "==", "HOST_WIDE_INT_M1U", ")", "return", "false", ";", "gcc_assert", "(", "shft_amnt", "<", "GET_MODE_BITSIZE", "(", "mode", ")", ")", ";", "t", "=", "mask2", "+", "(", "HOST_WIDE_INT_1U", "<<", "shft_amnt", ")", ";", "return", "(", "t", "==", "(", "t", "&", "-", "t", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "masks", "and", "a", "shift", "amount", "from", "an", "RTX", "of", "the", "form", "(", "(", "x", "&", "MASK1", ")", "|", "(", "(", "y", "<", "<", "SHIFT_AMNT", ")", "&", "MASK2", ")", ")", "are", "valid", "to", "combine", "into", "a", "BFI", "instruction", "of", "mode", "MODE", ".", "See", "*", "arch64_bfi", "patterns", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "const", "Value", "*", "Ptr", "=", "LI", "->", "getPointerOperand", "(", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "Ptr", ",", "AM", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "&", "XII", "=", "(", "const", "X86InstrInfo", "&", ")", "TII", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "AddrOps", ";", "AM", ".", "getFullAddress", "(", "AddrOps", ")", ";", "MachineInstr", "*", "Result", "=", "XII", ".", "foldMemoryOperandImpl", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ",", "OpNo", ",", "AddrOps", ",", "FuncInfo", ".", "InsertPt", ",", "Size", ",", "LI", "->", "getAlign", "(", ")", ",", "true", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "unsigned", "OperandNo", "=", "0", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "I", "=", "Result", "->", "operands_begin", "(", ")", ",", "E", "=", "Result", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "OperandNo", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "AM", ".", "IndexReg", ")", "continue", ";", "unsigned", "IndexReg", "=", "constrainOperandRegClass", "(", "Result", "->", "getDesc", "(", ")", ",", "MO", ".", "getReg", "(", ")", ",", "OperandNo", ")", ";", "if", "(", "IndexReg", "==", "MO", ".", "getReg", "(", ")", ")", "continue", ";", "MO", ".", "setReg", "(", "IndexReg", ")", ";", "}", "Result", "->", "addMemOperand", "(", "*", "FuncInfo", ".", "MF", ",", "createMachineMemOperandFor", "(", "LI", ")", ")", ";", "Result", "->", "cloneInstrSymbols", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "(", "MI", ")", ";", "removeDeadCode", "(", "I", ",", "std", "::", "next", "(", "I", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

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

[]

[ "<s>", "bool", "ARMWinCOFFObjectWriter", "::", "recordRelocation", "(", "const", "MCFixup", "&", "Fixup", ")", "const", "{", "return", "static_cast", "<", "unsigned", ">", "(", "Fixup", ".", "getKind", "(", ")", ")", "!=", "ARM", "::", "fixup_t2_movt_hi16", ";", "}", "</s>" ]

[ "Record", "a", "relocation", "entry", "." ]

[ "ARM", "ARM", "ARM::fixup_t2_movt_hi16" ]

[]

[ "<s>", "static", "rtx", "ix86_delegitimize_tls_address", "(", "rtx", "orig_x", ")", "{", "rtx", "x", "=", "orig_x", ",", "unspec", ";", "struct", "ix86_address", "addr", ";", "if", "(", "!", "TARGET_TLS_DIRECT_SEG_REFS", ")", "return", "orig_x", ";", "if", "(", "MEM_P", "(", "x", ")", ")", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", "||", "GET_MODE", "(", "x", ")", "!=", "Pmode", ")", "return", "orig_x", ";", "if", "(", "ix86_decompose_address", "(", "x", ",", "&", "addr", ")", "==", "0", "||", "addr", ".", "seg", "!=", "DEFAULT_TLS_SEG_REG", "||", "addr", ".", "disp", "==", "NULL_RTX", "||", "GET_CODE", "(", "addr", ".", "disp", ")", "!=", "CONST", ")", "return", "orig_x", ";", "unspec", "=", "XEXP", "(", "addr", ".", "disp", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "unspec", ",", "1", ")", ")", ")", "unspec", "=", "XEXP", "(", "unspec", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "unspec", ")", "!=", "UNSPEC", "||", "XINT", "(", "unspec", ",", "1", ")", "!=", "UNSPEC_NTPOFF", ")", "return", "orig_x", ";", "x", "=", "XVECEXP", "(", "unspec", ",", "0", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", ")", ";", "if", "(", "unspec", "!=", "XEXP", "(", "addr", ".", "disp", ",", "0", ")", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "x", ",", "XEXP", "(", "XEXP", "(", "addr", ".", "disp", ",", "0", ")", ",", "1", ")", ")", ";", "if", "(", "addr", ".", "index", ")", "{", "rtx", "idx", "=", "addr", ".", "index", ";", "if", "(", "addr", ".", "scale", "!=", "1", ")", "idx", "=", "gen_rtx_MULT", "(", "Pmode", ",", "idx", ",", "GEN_INT", "(", "addr", ".", "scale", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "idx", ",", "x", ")", ";", "}", "if", "(", "addr", ".", "base", ")", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ".", "base", ",", "x", ")", ";", "if", "(", "MEM_P", "(", "orig_x", ")", ")", "x", "=", "replace_equiv_address_nv", "(", "orig_x", ",", "x", ")", ";", "return", "x", ";", "}", "</s>" ]

[ "Helper", "function", "for", "ix86_delegitimize_address", ".", "Attempt", "to", "delegitimize", "TLS", "local-exec", "accesses", "." ]

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

[]

[ "<s>", "static", "int", "unspec_cdot", "(", "int", "rot", ")", "{", "switch", "(", "rot", ")", "{", "case", "0", ":", "return", "UNSPEC_CDOT", ";", "case", "90", ":", "return", "UNSPEC_CDOT90", ";", "case", "180", ":", "return", "UNSPEC_CDOT180", ";", "case", "270", ":", "return", "UNSPEC_CDOT270", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "UNSPEC_CDOT", "*", "unspec", "for", "rotation", "amount", "ROT", "." ]

[ "aarch64", "0", "90", "180", "270" ]

[]

[ "<s>", "static", "void", "nvptx_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "cum", "->", "count", "++", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_ADVANCE", "." ]

[ "nvptx" ]

[]

[ "<s>", "int", "AMDGPUFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "unsigned", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "AMDGPURegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "unsigned", "OffsetBytes", "=", "2", "*", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "int", "UpperBound", "=", "FI", "==", "-", "1", "?", "MFI", "->", "getNumObjects", "(", ")", ":", "FI", ";", "for", "(", "int", "i", "=", "MFI", "->", "getObjectIndexBegin", "(", ")", ";", "i", "<", "UpperBound", ";", "++", "i", ")", "{", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", "->", "getObjectAlignment", "(", "i", ")", ")", ";", "OffsetBytes", "+=", "MFI", "->", "getObjectSize", "(", "i", ")", ";", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "4", ")", ";", "}", "if", "(", "FI", "!=", "-", "1", ")", "OffsetBytes", "=", "alignTo", "(", "OffsetBytes", ",", "MFI", "->", "getObjectAlignment", "(", "FI", ")", ")", ";", "return", "OffsetBytes", "/", "(", "getStackWidth", "(", "MF", ")", "*", "4", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "2", "4", "1", "4", "1", "4" ]

[]

[ "<s>", "static", "enum", "attr_type", "type_for_anomaly", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "rtx_sequence", "*", "seq", "=", "dyn_cast", "<", "rtx_sequence", "*", ">", "(", "pat", ")", ")", "{", "enum", "attr_type", "t", ";", "t", "=", "get_attr_type", "(", "seq", "->", "insn", "(", "1", ")", ")", ";", "if", "(", "t", "==", "TYPE_MCLD", ")", "return", "t", ";", "t", "=", "get_attr_type", "(", "seq", "->", "insn", "(", "2", ")", ")", ";", "if", "(", "t", "==", "TYPE_MCLD", ")", "return", "t", ";", "return", "TYPE_MCST", ";", "}", "else", "return", "get_attr_type", "(", "insn", ")", ";", "}", "</s>" ]

[ "Return", "an", "insn", "type", "for", "INSN", "that", "can", "be", "used", "by", "the", "caller", "for", "anomaly", "workarounds", ".", "This", "differs", "from", "plain", "get_attr_type", "in", "that", "it", "handles", "SEQUENCEs", "." ]

[ "bfin", "1", "2" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isLegalAddressingMode", "(", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ")", "const", "{", "EVT", "VT", "=", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "!", "isLegalAddressImmediate", "(", "AM", ".", "BaseOffs", ",", "VT", ",", "Subtarget", ")", ")", "return", "false", ";", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "default", ":", "if", "(", "AM", ".", "BaseOffs", ")", "return", "false", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "return", "isLegalT2ScaledAddressingMode", "(", "AM", ",", "VT", ")", ";", "int", "Scale", "=", "AM", ".", "Scale", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "default", ":", "return", "false", ";", "case", "MVT", "::", "i1", ":", "case", "MVT", "::", "i8", ":", "case", "MVT", "::", "i32", ":", "if", "(", "Scale", "<", "0", ")", "Scale", "=", "-", "Scale", ";", "if", "(", "Scale", "==", "1", ")", "return", "true", ";", "return", "isPowerOf2_32", "(", "Scale", "&", "~", "1", ")", ";", "case", "MVT", "::", "i16", ":", "case", "MVT", "::", "i64", ":", "if", "(", "(", "(", "unsigned", ")", "AM", ".", "HasBaseReg", "+", "Scale", ")", "<=", "2", ")", "return", "true", ";", "return", "false", ";", "case", "MVT", "::", "isVoid", ":", "if", "(", "Scale", "&", "1", ")", "return", "false", ";", "return", "isPowerOf2_32", "(", "Scale", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "ARM", "ARM", "0", "1", "MVT::i1", "MVT::i8", "MVT::i32", "0", "1", "1", "MVT::i16", "MVT::i64", "2", "MVT::isVoid", "1" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "MCExpr", "*", "E", ")", "{", "return", "E", "->", "getKind", "(", ")", "==", "MCExpr", "::", "Target", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "Nyuzi" ]

[]

[ "<s>", "bool", "HexagonPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "&", "IfConverterID", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "shadd_constant_p", "(", "int", "val", ")", "{", "if", "(", "val", "==", "2", "||", "val", "==", "4", "||", "val", "==", "8", ")", "return", "1", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "the", "given", "constant", "is", "2", ",", "4", ",", "or", "8", ".", "These", "are", "the", "valid", "constants", "for", "shadd", "instructions", "." ]

[ "pa", "2", "4", "8", "1", "0" ]

[]

[ "<s>", "static", "void", "ix86_dependencies_evaluation_hook", "(", "rtx_insn", "*", "head", ",", "rtx_insn", "*", "tail", ")", "{", "rtx_insn", "*", "insn", ";", "rtx_insn", "*", "first_arg", "=", "NULL", ";", "if", "(", "reload_completed", ")", "return", ";", "while", "(", "head", "!=", "tail", "&&", "DEBUG_INSN_P", "(", "head", ")", ")", "head", "=", "NEXT_INSN", "(", "head", ")", ";", "for", "(", "insn", "=", "tail", ";", "insn", "!=", "head", ";", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", "if", "(", "INSN_P", "(", "insn", ")", "&&", "CALL_P", "(", "insn", ")", ")", "{", "first_arg", "=", "add_parameter_dependencies", "(", "insn", ",", "head", ")", ";", "if", "(", "first_arg", ")", "{", "basic_block", "bb", "=", "BLOCK_FOR_INSN", "(", "insn", ")", ";", "int", "rgn", "=", "CONTAINING_RGN", "(", "bb", "->", "index", ")", ";", "int", "nr_blks", "=", "RGN_NR_BLOCKS", "(", "rgn", ")", ";", "if", "(", "nr_blks", ">", "1", "&&", "BLOCK_TO_BB", "(", "bb", "->", "index", ")", "!=", "0", ")", "{", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "{", "if", "(", "rgn", "==", "CONTAINING_RGN", "(", "e", "->", "src", "->", "index", ")", "&&", "BLOCK_TO_BB", "(", "bb", "->", "index", ")", ">", "BLOCK_TO_BB", "(", "e", "->", "src", "->", "index", ")", ")", "add_dependee_for_func_arg", "(", "first_arg", ",", "e", "->", "src", ")", ";", "}", "}", "insn", "=", "first_arg", ";", "if", "(", "insn", "==", "head", ")", "break", ";", "}", "}", "else", "if", "(", "first_arg", ")", "avoid_func_arg_motion", "(", "first_arg", ",", "insn", ")", ";", "}", "</s>" ]

[ "Hook", "for", "pre-reload", "schedule", "-", "avoid", "motion", "of", "function", "arguments", "passed", "in", "likely", "spilled", "HW", "registers", "." ]

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

[]

[ "<s>", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "bool", "TPCHazardRecognizer", "::", "atIssueLimit", "(", ")", "const", "{", "return", "(", "CurrentPacket", ".", "size", "(", ")", "==", "4", ")", ";", "}", "</s>" ]

[ "atIssueLimit", "-", "Return", "true", "if", "no", "more", "instructions", "may", "be", "issued", "in", "this", "cycle", "." ]

[ "TPC", "TPC", "4" ]

[]

[ "<s>", "static", "void", "cris_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "ca", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_arg_size", ",", "int", "second_time", ")", "{", "if", "(", "ca", "->", "regs", "<", "CRIS_MAX_ARGS_IN_REGS", ")", "{", "int", "stdarg_regs", "=", "CRIS_MAX_ARGS_IN_REGS", "-", "ca", "->", "regs", ";", "cfun", "->", "machine", "->", "stdarg_regs", "=", "stdarg_regs", ";", "*", "pretend_arg_size", "=", "stdarg_regs", "*", "4", ";", "}", "if", "(", "TARGET_PDEBUG", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\\n\"", ",", "ca", "->", "regs", ",", "*", "pretend_arg_size", ",", "second_time", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "cris", "4", "\"\\n; VA:: ANSI: %d args before, anon @ #%d, %dtime\\n\"" ]

[]

[ "<s>", "const", "DLXSubtarget", "*", "getSubtargetImpl", "(", "const", "llvm", "::", "Function", "&", ")", "const", "override", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "static", "void", "report_neither_nor", "(", "location_t", "location", ",", "tree", "fndecl", ",", "unsigned", "int", "argno", ",", "HOST_WIDE_INT", "actual", ",", "HOST_WIDE_INT", "value0", ",", "HOST_WIDE_INT", "value1", ")", "{", "error_at", "(", "location", ",", "\"passing %wd to argument %d of %qE, which expects\"", "\" either %wd or %wd\"", ",", "actual", ",", "argno", "+", "1", ",", "fndecl", ",", "value0", ",", "value1", ")", ";", "}", "</s>" ]

[ "Report", "that", "LOCATION", "has", "a", "call", "to", "FNDECL", "in", "which", "argument", "ARGNO", "has", "the", "value", "ACTUAL", ",", "whereas", "the", "function", "requires", "either", "VALUE0", "or", "VALUE1", ".", "ARGNO", "counts", "from", "zero", "." ]

[ "aarch64", "\"passing %wd to argument %d of %qE, which expects\"", "\" either %wd or %wd\"", "1" ]

[]

[ "<s>", "unsigned", "MSP430InstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", ".", "getDesc", "(", ")", ";", "switch", "(", "Desc", ".", "getOpcode", "(", ")", ")", "{", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "case", "TargetOpcode", "::", "INLINEASM_BR", ":", "{", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "return", "TII", ".", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "MF", "->", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "return", "Desc", ".", "getSize", "(", ")", ";", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "MSP430", "MSP430", "0", "0" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "*", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsIEEEMode", "=", "ST", "->", "enableIEEEBit", "(", "MF", ")", "||", "!", "MFI", "->", "hasNoSignedZerosFPMath", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "BI", ";", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "tryFoldInst", "(", "TII", ",", "&", "MI", ")", ";", "if", "(", "!", "TII", "->", "isFoldableCopy", "(", "MI", ")", ")", "{", "if", "(", "IsIEEEMode", "||", "!", "tryFoldOMod", "(", "MI", ")", ")", "tryFoldClamp", "(", "MI", ")", ";", "continue", ";", "}", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", "||", "OpToFold", ".", "isFI", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Dst", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "foldInstOperand", "(", "MI", ",", "OpToFold", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "ARMInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Pred", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "B", "||", "Opc", "==", "ARM", "::", "tB", ")", "{", "MI", "->", "setDesc", "(", "get", "(", "Opc", "==", "ARM", "::", "B", "?", "ARM", "::", "Bcc", ":", "ARM", "::", "tBcc", ")", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateImm", "(", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", ";", "MI", "->", "addOperand", "(", "MachineOperand", "::", "CreateReg", "(", "Pred", "[", "1", "]", ".", "getReg", "(", ")", ",", "false", ")", ")", ";", "return", "true", ";", "}", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "if", "(", "PIdx", "!=", "-", "1", ")", "{", "MachineOperand", "&", "PMO", "=", "MI", "->", "getOperand", "(", "PIdx", ")", ";", "PMO", ".", "setImm", "(", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ")", ";", "MI", "->", "getOperand", "(", "PIdx", "+", "1", ")", ".", "setReg", "(", "Pred", "[", "1", "]", ".", "getReg", "(", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "ARM", "ARM", "ARM::B", "ARM::tB", "ARM::B", "ARM::Bcc", "ARM::tBcc", "0", "1", "1", "0", "1", "1" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "FrameInfo", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "M0", "&&", "\"m0 should not be spilled\"", ")", ";", "assert", "(", "SrcReg", "!=", "AMDGPU", "::", "EXEC_LO", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC_HI", "&&", "SrcReg", "!=", "AMDGPU", "::", "EXEC", "&&", "\"exec should not be spilled\"", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "SrcReg", ".", "isVirtual", "(", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0_XEXECRegClass", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "RI", ".", "spillSGPRToVGPR", "(", ")", ")", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "TargetStackID", "::", "SGPRSpill", ")", ";", "return", ";", "}", "unsigned", "Opcode", "=", "RI", ".", "isAGPRClass", "(", "RC", ")", "?", "getAGPRSpillSaveOpcode", "(", "SpillSize", ")", ":", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "AMDGPU::M0", "\"m0 should not be spilled\"", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::EXEC", "\"exec should not be spilled\"", "4", "AMDGPU::SReg_32_XM0_XEXECRegClass", "0" ]

[]

[ "<s>", "static", "tree", "sh_handle_trap_exit_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute only applies to functions\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "INTEGER_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"%qE attribute argument not an \"", "\"integer constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "trap_exit", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "sh", "\"%qE attribute only applies to functions\"", "\"%qE attribute argument not an \"", "\"integer constant\"" ]

[]

[ "<s>", "bool", "SparcRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "!", "TargetRegisterInfo", "::", "canRealignStack", "(", "MF", ")", ")", "return", "false", ";", "if", "(", "getFrameLowering", "(", "MF", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "std", "::", "pair", "<", "SDValue", ",", "SDValue", ">", "AMDGPUTargetLowering", "::", "split64BitValue", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "SL", "(", "Op", ")", ";", "SDValue", "Vec", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "SL", ",", "MVT", "::", "v2i32", ",", "Op", ")", ";", "const", "SDValue", "Zero", "=", "DAG", ".", "getConstant", "(", "0", ",", "SL", ",", "MVT", "::", "i32", ")", ";", "const", "SDValue", "One", "=", "DAG", ".", "getConstant", "(", "1", ",", "SL", ",", "MVT", "::", "i32", ")", ";", "SDValue", "Lo", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "SL", ",", "MVT", "::", "i32", ",", "Vec", ",", "Zero", ")", ";", "SDValue", "Hi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "SL", ",", "MVT", "::", "i32", ",", "Vec", ",", "One", ")", ";", "return", "std", "::", "make_pair", "(", "Lo", ",", "Hi", ")", ";", "}", "</s>" ]

[ "Return", "64-bit", "value", "Op", "as", "two", "32-bit", "integers", "." ]

[ "AMDGPU", "AMDGPU", "ISD::BITCAST", "MVT::v2i32", "0", "MVT::i32", "1", "MVT::i32", "ISD::EXTRACT_VECTOR_ELT", "MVT::i32", "ISD::EXTRACT_VECTOR_ELT", "MVT::i32" ]

[]

[ "<s>", "void", "ia64_expand_vecint_cmov", "(", "rtx", "operands", "[", "]", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "operands", "[", "0", "]", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "bool", "negate", ";", "rtx", "cmp", ",", "x", ",", "ot", ",", "of", ";", "cmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "negate", "=", "ia64_expand_vecint_compare", "(", "code", ",", "mode", ",", "cmp", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ")", ";", "ot", "=", "operands", "[", "1", "+", "negate", "]", ";", "of", "=", "operands", "[", "2", "-", "negate", "]", ";", "if", "(", "ot", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "if", "(", "of", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "ot", ")", ";", "return", ";", "}", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "cmp", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "x", ",", "of", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "x", ")", ")", ";", "}", "else", "if", "(", "of", "==", "CONST0_RTX", "(", "mode", ")", ")", "{", "x", "=", "gen_rtx_AND", "(", "mode", ",", "cmp", ",", "ot", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "x", ")", ")", ";", "}", "else", "{", "rtx", "t", ",", "f", ";", "t", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "cmp", ",", "operands", "[", "1", "+", "negate", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "t", ",", "x", ")", ")", ";", "f", "=", "gen_reg_rtx", "(", "mode", ")", ";", "x", "=", "gen_rtx_NOT", "(", "mode", ",", "cmp", ")", ";", "x", "=", "gen_rtx_AND", "(", "mode", ",", "x", ",", "operands", "[", "2", "-", "negate", "]", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "f", ",", "x", ")", ")", ";", "x", "=", "gen_rtx_IOR", "(", "mode", ",", "t", ",", "f", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "operands", "[", "0", "]", ",", "x", ")", ")", ";", "}", "}", "</s>" ]

[ "Emit", "an", "integral", "vector", "conditional", "move", "." ]

[ "ia64", "0", "3", "4", "5", "1", "2", "0", "0", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "tree", "arm_promoted_type", "(", "const_tree", "t", ")", "{", "if", "(", "SCALAR_FLOAT_TYPE_P", "(", "t", ")", "&&", "TYPE_PRECISION", "(", "t", ")", "==", "16", "&&", "TYPE_MAIN_VARIANT", "(", "t", ")", "==", "arm_fp16_type_node", ")", "return", "float_type_node", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "TARGET_PROMOTED_TYPE", "." ]

[ "arm", "16" ]

[]

[ "<s>", "bool", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "PowerPC" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "std", "::", "string", "&", "TT", ",", "const", "std", "::", "string", "&", "FS", ",", "bool", "is64Bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ")", ",", "Subtarget", "(", "TT", ",", "FS", ",", "is64Bit", ")", ",", "DataLayout", "(", "Subtarget", ".", "getDataLayout", "(", ")", ")", ",", "FrameInfo", "(", "TargetFrameInfo", "::", "StackGrowsDown", ",", "Subtarget", ".", "getStackAlignment", "(", ")", ",", "(", "Subtarget", ".", "isTargetWin64", "(", ")", "?", "-", "40", ":", "(", "Subtarget", ".", "is64Bit", "(", ")", "?", "-", "8", ":", "-", "4", ")", ")", ")", ",", "InstrInfo", "(", "*", "this", ")", ",", "JITInfo", "(", "*", "this", ")", ",", "TLInfo", "(", "*", "this", ")", ",", "TSInfo", "(", "*", "this", ")", ",", "ELFWriterInfo", "(", "*", "this", ")", "{", "DefRelocModel", "=", "getRelocationModel", "(", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Default", ")", "{", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "DynamicNoPIC", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "assert", "(", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "&&", "\"Relocation mode not picked\"", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", "{", "if", "(", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "else", "if", "(", "!", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", "&&", "Subtarget", ".", "isTargetDarwin", "(", ")", "&&", "is64Bit", ")", "setRelocationModel", "(", "Reloc", "::", "PIC_", ")", ";", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetCygMing", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "Subtarget", ".", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "Subtarget", ".", "isTargetELF", "(", ")", ")", "{", "Subtarget", ".", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "if", "(", "Subtarget", ".", "getPICStyle", "(", ")", "==", "PICStyles", "::", "None", ")", "setRelocationModel", "(", "Reloc", "::", "Static", ")", ";", "}", "</s>" ]

[ "Create", "an", "X86", "target", "." ]

[ "X86", "X86", "X86", "40", "8", "4", "\"Relocation mode not picked\"" ]

[]

[ "<s>", "TargetTransformInfo", "GCNTargetMachine", "::", "getTargetTransformInfo", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "GCNTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetTransformInfo", "implementation", "for", "the", "target", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BaseReg", ",", "false", ")", ";", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "OffsetOperandNo", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "PowerPC", "PPC", "0", "\"Instr doesn't have FrameIndex operand!\"" ]

[]

[ "<s>", "unsigned", "Cpu0SEInstrInfo", "::", "getOppositeBranchOpc", "(", "unsigned", "Opc", ")", "const", "{", "switch", "(", "Opc", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Illegal opcode!\"", ")", ";", "case", "Cpu0", "::", "BEQ", ":", "return", "Cpu0", "::", "BNE", ";", "case", "Cpu0", "::", "BNE", ":", "return", "Cpu0", "::", "BEQ", ";", "}", "}", "</s>" ]

[ "getOppositeBranchOpc", "-", "Return", "the", "inverse", "of", "the", "specified", "opcode", ",", "e.g", "." ]

[ "Cpu0", "Cpu0", "\"Illegal opcode!\"", "Cpu0::BEQ", "Cpu0::BNE", "Cpu0::BNE", "Cpu0::BEQ" ]

[]

[ "<s>", "SDNode", "*", "SystemZDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "0", ";", "}", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "SDNode", "*", "ResNode", "=", "0", ";", "switch", "(", "Opcode", ")", "{", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "if", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "if", "(", "ConstantSDNode", "*", "Op1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", ")", "{", "uint64_t", "Val", "=", "Op1", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "SystemZ", "::", "isImmLF", "(", "Val", ")", "&&", "!", "SystemZ", "::", "isImmHF", "(", "Val", ")", ")", "Node", "=", "splitLargeImmediate", "(", "Opcode", ",", "Node", ",", "Node", "->", "getOperand", "(", "0", ")", ",", "Val", "-", "uint32_t", "(", "Val", ")", ",", "uint32_t", "(", "Val", ")", ")", ";", "}", "break", ";", "case", "ISD", "::", "AND", ":", "ResNode", "=", "tryRISBGForAND", "(", "Node", ")", ";", "break", ";", "case", "ISD", "::", "Constant", ":", "if", "(", "Node", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "{", "uint64_t", "Val", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", ")", "->", "getZExtValue", "(", ")", ";", "if", "(", "!", "SystemZ", "::", "isImmLF", "(", "Val", ")", "&&", "!", "SystemZ", "::", "isImmHF", "(", "Val", ")", "&&", "!", "isInt", "<", "32", ">", "(", "Val", ")", ")", "Node", "=", "splitLargeImmediate", "(", "ISD", "::", "OR", ",", "Node", ",", "SDValue", "(", ")", ",", "Val", "-", "uint32_t", "(", "Val", ")", ",", "uint32_t", "(", "Val", ")", ")", ";", "}", "break", ";", "case", "ISD", "::", "ATOMIC_LOAD_SUB", ":", "if", "(", "ConstantSDNode", "*", "Op2", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "2", ")", ")", ")", "{", "uint64_t", "Value", "=", "-", "Op2", "->", "getZExtValue", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "if", "(", "VT", "==", "MVT", "::", "i32", "||", "isInt", "<", "32", ">", "(", "Value", ")", ")", "{", "SDValue", "Ops", "[", "]", "=", "{", "Node", "->", "getOperand", "(", "0", ")", ",", "Node", "->", "getOperand", "(", "1", ")", ",", "CurDAG", "->", "getConstant", "(", "int32_t", "(", "Value", ")", ",", "VT", ")", "}", ";", "Node", "=", "CurDAG", "->", "MorphNodeTo", "(", "Node", ",", "ISD", "::", "ATOMIC_LOAD_ADD", ",", "Node", "->", "getVTList", "(", ")", ",", "Ops", ",", "array_lengthof", "(", "Ops", ")", ")", ";", "}", "}", "break", ";", "}", "if", "(", "!", "ResNode", ")", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "Node", "->", "dump", "(", "CurDAG", ")", ";", "else", "ResNode", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ";", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "0", "0", "ISD::OR", "ISD::XOR", "0", "MVT::i64", "1", "SystemZ::isImmLF", "SystemZ::isImmHF", "0", "ISD::AND", "ISD::Constant", "0", "MVT::i64", "SystemZ::isImmLF", "SystemZ::isImmHF", "32", "ISD::OR", "ISD::ATOMIC_LOAD_SUB", "2", "0", "MVT::i32", "32", "0", "1", "ISD::ATOMIC_LOAD_ADD", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "static", "bool", "riscv_pass_by_reference", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "HOST_WIDE_INT", "size", "=", "arg", ".", "type_size_in_bytes", "(", ")", ";", "struct", "riscv_arg_info", "info", ";", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "cum", "!=", "NULL", ")", "{", "riscv_get_arg_info", "(", "&", "info", ",", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ",", "arg", ".", "named", ",", "false", ")", ";", "if", "(", "info", ".", "num_fprs", ")", "return", "false", ";", "}", "return", "!", "IN_RANGE", "(", "size", ",", "0", ",", "2", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PASS_BY_REFERENCE", "." ]

[ "riscv", "0", "2" ]

[]

[ "<s>", "SDValue", "AlphaTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Copy", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "Alpha", "::", "R26", ",", "DAG", ".", "getNode", "(", "AlphaISD", "::", "GlobalRetAddr", ",", "DebugLoc", "(", ")", ",", "MVT", "::", "i64", ")", ",", "SDValue", "(", ")", ")", ";", "switch", "(", "Outs", ".", "size", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to return this many arguments!\"", ")", ";", "case", "0", ":", "break", ";", "case", "1", ":", "{", "EVT", "ArgVT", "=", "Outs", "[", "0", "]", ".", "VT", ";", "unsigned", "ArgReg", ";", "if", "(", "ArgVT", ".", "isInteger", "(", ")", ")", "ArgReg", "=", "Alpha", "::", "R0", ";", "else", "{", "assert", "(", "ArgVT", ".", "isFloatingPoint", "(", ")", ")", ";", "ArgReg", "=", "Alpha", "::", "F0", ";", "}", "Copy", "=", "DAG", ".", "getCopyToReg", "(", "Copy", ",", "dl", ",", "ArgReg", ",", "OutVals", "[", "0", "]", ",", "Copy", ".", "getValue", "(", "1", ")", ")", ";", "if", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_empty", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "ArgReg", ")", ";", "break", ";", "}", "case", "2", ":", "{", "EVT", "ArgVT", "=", "Outs", "[", "0", "]", ".", "VT", ";", "unsigned", "ArgReg1", ",", "ArgReg2", ";", "if", "(", "ArgVT", ".", "isInteger", "(", ")", ")", "{", "ArgReg1", "=", "Alpha", "::", "R0", ";", "ArgReg2", "=", "Alpha", "::", "R1", ";", "}", "else", "{", "assert", "(", "ArgVT", ".", "isFloatingPoint", "(", ")", ")", ";", "ArgReg1", "=", "Alpha", "::", "F0", ";", "ArgReg2", "=", "Alpha", "::", "F1", ";", "}", "Copy", "=", "DAG", ".", "getCopyToReg", "(", "Copy", ",", "dl", ",", "ArgReg1", ",", "OutVals", "[", "0", "]", ",", "Copy", ".", "getValue", "(", "1", ")", ")", ";", "if", "(", "std", "::", "find", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_begin", "(", ")", ",", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_end", "(", ")", ",", "ArgReg1", ")", "==", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_end", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "ArgReg1", ")", ";", "Copy", "=", "DAG", ".", "getCopyToReg", "(", "Copy", ",", "dl", ",", "ArgReg2", ",", "OutVals", "[", "1", "]", ",", "Copy", ".", "getValue", "(", "1", ")", ")", ";", "if", "(", "std", "::", "find", "(", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_begin", "(", ")", ",", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_end", "(", ")", ",", "ArgReg2", ")", "==", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "liveout_end", "(", ")", ")", "DAG", ".", "getMachineFunction", "(", ")", ".", "getRegInfo", "(", ")", ".", "addLiveOut", "(", "ArgReg2", ")", ";", "break", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "AlphaISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Copy", ",", "Copy", ".", "getValue", "(", "1", ")", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Alpha", "Alpha", "ISD::OutputArg", "Alpha::R26", "AlphaISD::GlobalRetAddr", "MVT::i64", "\"Do not know how to return this many arguments!\"", "0", "1", "0", "Alpha::R0", "Alpha::F0", "0", "1", "2", "0", "Alpha::R0", "Alpha::R1", "Alpha::F0", "Alpha::F1", "0", "1", "1", "1", "AlphaISD::RET_FLAG", "MVT::Other", "1" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "M68kRegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "auto", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opc", ")", ")", "{", "const", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "}", "using", "namespace", "TargetOpcode", ";", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "const", "ValueMapping", "*", "OperandsMapping", "=", "&", "M68k", "::", "ValueMappings", "[", "M68k", "::", "GPR3OpsIdx", "]", ";", "switch", "(", "Opc", ")", "{", "case", "G_ADD", ":", "case", "G_SUB", ":", "case", "G_MUL", ":", "case", "G_SDIV", ":", "case", "G_UDIV", ":", "case", "G_LOAD", ":", "case", "G_STORE", ":", "{", "OperandsMapping", "=", "&", "M68k", "::", "ValueMappings", "[", "M68k", "::", "GPR3OpsIdx", "]", ";", "break", ";", "}", "case", "G_CONSTANT", ":", "case", "G_FRAME_INDEX", ":", "OperandsMapping", "=", "getOperandsMapping", "(", "{", "&", "M68k", "::", "ValueMappings", "[", "M68k", "::", "GPR3OpsIdx", "]", ",", "nullptr", "}", ")", ";", "break", ";", "default", ":", "return", "getInvalidInstructionMapping", "(", ")", ";", "}", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "OperandsMapping", ",", "NumOperands", ")", ";", "}", "</s>" ]

[ "Get", "the", "mapping", "of", "the", "different", "operands", "of", "MI", "on", "the", "register", "bank", "." ]

[ "M68k", "M68k", "M68k::ValueMappings", "M68k::GPR3OpsIdx", "M68k::ValueMappings", "M68k::GPR3OpsIdx", "M68k::ValueMappings", "M68k::GPR3OpsIdx", "1" ]

[]

[ "<s>", "static", "void", "alpha_expand_unaligned_store_words", "(", "rtx", "*", "data_regs", ",", "rtx", "dmem", ",", "HOST_WIDE_INT", "words", ",", "HOST_WIDE_INT", "ofs", ")", "{", "rtx", "const", "im8", "=", "GEN_INT", "(", "-", "8", ")", ";", "rtx", "ins_tmps", "[", "MAX_MOVE_WORDS", "]", ";", "rtx", "st_tmp_1", ",", "st_tmp_2", ",", "dreg", ";", "rtx", "st_addr_1", ",", "st_addr_2", ",", "dmema", ";", "HOST_WIDE_INT", "i", ";", "dmema", "=", "XEXP", "(", "dmem", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "dmema", ")", "==", "LO_SUM", ")", "dmema", "=", "force_reg", "(", "Pmode", ",", "dmema", ")", ";", "if", "(", "data_regs", "!=", "NULL", ")", "for", "(", "i", "=", "0", ";", "i", "<", "words", ";", "++", "i", ")", "ins_tmps", "[", "i", "]", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "st_tmp_1", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "st_tmp_2", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "if", "(", "ofs", "!=", "0", ")", "dmem", "=", "adjust_address", "(", "dmem", ",", "GET_MODE", "(", "dmem", ")", ",", "ofs", ")", ";", "st_addr_2", "=", "change_address", "(", "dmem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "dmema", ",", "words", "*", "8", "-", "1", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "st_addr_2", ",", "0", ")", ";", "st_addr_1", "=", "change_address", "(", "dmem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "dmema", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "st_addr_1", ",", "0", ")", ";", "emit_move_insn", "(", "st_tmp_2", ",", "st_addr_2", ")", ";", "emit_move_insn", "(", "st_tmp_1", ",", "st_addr_1", ")", ";", "dreg", "=", "copy_addr_to_reg", "(", "dmema", ")", ";", "if", "(", "data_regs", "!=", "NULL", ")", "{", "for", "(", "i", "=", "words", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "emit_insn", "(", "gen_insqh", "(", "ins_tmps", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "dreg", ")", ")", ";", "emit_insn", "(", "gen_insql", "(", "data_regs", "[", "i", "]", ",", "data_regs", "[", "i", "]", ",", "dreg", ")", ")", ";", "}", "for", "(", "i", "=", "words", "-", "1", ";", "i", ">", "0", ";", "--", "i", ")", "{", "ins_tmps", "[", "i", "-", "1", "]", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "data_regs", "[", "i", "]", ",", "ins_tmps", "[", "i", "-", "1", "]", ",", "ins_tmps", "[", "i", "-", "1", "]", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "}", "emit_insn", "(", "gen_mskqh", "(", "st_tmp_2", ",", "st_tmp_2", ",", "dreg", ")", ")", ";", "emit_insn", "(", "gen_mskql", "(", "st_tmp_1", ",", "st_tmp_1", ",", "dreg", ")", ")", ";", "if", "(", "data_regs", "!=", "NULL", ")", "{", "st_tmp_2", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "st_tmp_2", ",", "ins_tmps", "[", "words", "-", "1", "]", ",", "st_tmp_2", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "st_tmp_1", "=", "expand_binop", "(", "DImode", ",", "ior_optab", ",", "st_tmp_1", ",", "data_regs", "[", "0", "]", ",", "st_tmp_1", ",", "1", ",", "OPTAB_WIDEN", ")", ";", "}", "emit_move_insn", "(", "st_addr_2", ",", "st_tmp_2", ")", ";", "for", "(", "i", "=", "words", "-", "1", ";", "i", ">", "0", ";", "--", "i", ")", "{", "rtx", "tmp", "=", "change_address", "(", "dmem", ",", "DImode", ",", "gen_rtx_AND", "(", "DImode", ",", "plus_constant", "(", "DImode", ",", "dmema", ",", "i", "*", "8", ")", ",", "im8", ")", ")", ";", "set_mem_alias_set", "(", "tmp", ",", "0", ")", ";", "emit_move_insn", "(", "tmp", ",", "data_regs", "?", "ins_tmps", "[", "i", "-", "1", "]", ":", "const0_rtx", ")", ";", "}", "emit_move_insn", "(", "st_addr_1", ",", "st_tmp_1", ")", ";", "}", "</s>" ]

[ "Store", "an", "integral", "number", "of", "consecutive", "unaligned", "quadwords", ".", "DATA_REGS", "may", "be", "NULL", "to", "store", "zeros", "." ]

[ "alpha", "8", "0", "0", "0", "8", "1", "0", "0", "1", "0", "1", "0", "1", "1", "1", "1", "1", "1", "0", "1", "1", "0", "8", "0", "1" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "NumBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "Idx", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</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", "." ]

[ "PowerPC", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "rtx", "arc_legitimize_tls_address", "(", "rtx", "addr", ",", "enum", "tls_model", "model", ")", "{", "rtx", "tmp", ";", "if", "(", "!", "flag_pic", "&&", "model", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", "model", "=", "TLS_MODEL_LOCAL_EXEC", ";", "gcc_assert", "(", "arc_tp_regno", "!=", "-", "1", ")", ";", "switch", "(", "model", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_GD", ")", ")", ";", "return", "arc_call_tls_get_addr", "(", "tmp", ")", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "rtx", "base", ";", "tree", "decl", ";", "const", "char", "*", "base_name", ";", "decl", "=", "SYMBOL_REF_DECL", "(", "addr", ")", ";", "base_name", "=", "DTPOFF_ZERO_SYM", ";", "if", "(", "decl", "&&", "bss_initializer_p", "(", "decl", ")", ")", "base_name", "=", "\".tbss\"", ";", "base", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "base_name", ")", ";", "tmp", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_move_insn", "(", "tmp", ",", "arc_unspec_offset", "(", "base", ",", "UNSPEC_TLS_GD", ")", ")", ";", "base", "=", "arc_call_tls_get_addr", "(", "tmp", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "force_reg", "(", "Pmode", ",", "base", ")", ",", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_OFF", ")", ")", ";", "case", "TLS_MODEL_INITIAL_EXEC", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_IE", ")", ";", "addr", "=", "copy_to_mode_reg", "(", "Pmode", ",", "gen_const_mem", "(", "Pmode", ",", "addr", ")", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "arc_tp_regno", ")", ",", "addr", ")", ";", "case", "TLS_MODEL_LOCAL_EXEC", ":", "addr", "=", "arc_unspec_offset", "(", "addr", ",", "UNSPEC_TLS_OFF", ")", ";", "return", "gen_rtx_PLUS", "(", "Pmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "arc_tp_regno", ")", ",", "addr", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "a", "legitimized", "address", "for", "ADDR", ",", "which", "is", "a", "SYMBOL_REF", "with", "tls_model", "MODEL", "." ]

[ "arc", "1", "\".tbss\"" ]

[]

[ "<s>", "bool", "ARMPreAllocLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TD", "=", "&", "Fn", ".", "getDataLayout", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MF", "=", "&", "Fn", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "RescheduleLoadStoreInstrs", "(", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "int", "call_address_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "return", "(", "symbolic_operand", "(", "op", ",", "mode", ")", "||", "(", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "LEGITIMATE_CONSTANT_P", "(", "op", ")", ")", "||", "(", "GET_CODE", "(", "op", ")", "==", "REG", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "a", "valid", "call", "operand", "." ]

[ "arc" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"TLCS900 Branch Selector\"", ";", "}", "</s>" ]

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

[ "TLCS900", "\"TLCS900 Branch Selector\"" ]

[]

[ "<s>", "bool", "PPCAIXAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "for", "(", "MCSymbol", "*", "Sym", ":", "ExtSymSDNodeSymbols", ")", "OutStreamer", "->", "emitSymbolAttribute", "(", "Sym", ",", "MCSA_Extern", ")", ";", "return", "PPCAsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

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

[]

[ "<s>", "SDValue", "Nios2TargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "return", "DAG", ".", "getNode", "(", "Nios2ISD", "::", "Ret", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Nios2", "Nios2", "ISD::OutputArg", "4", "1", "Nios2ISD::Ret", "MVT::Other" ]

[]

[ "<s>", "unsigned", "PPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "R31", ":", "PPC", "::", "R1", ";", "else", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "PPC", "::", "X31", ":", "PPC", "::", "X1", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::R31", "PPC::R1", "PPC::X31", "PPC::X1" ]

[]

[ "<s>", "ARMCC", "::", "CondCodes", "getPredicate", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "int", "PIdx", "=", "MI", "->", "findFirstPredOperandIdx", "(", ")", ";", "return", "PIdx", "!=", "-", "1", "?", "(", "ARMCC", "::", "CondCodes", ")", "MI", "->", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ":", "ARMCC", "::", "AL", ";", "}", "</s>" ]

[ "Returns", "the", "comparison", "predicate", "underlying", "the", "intrinsic", "." ]

[ "ARM", "ARMCC::CondCodes", "1", "ARMCC::CondCodes", "ARMCC::AL" ]

[]

[ "<s>", "void", "h8300_expand_epilogue", "(", "void", ")", "{", "int", "regno", ";", "int", "saved_regs", ";", "int", "n_regs", ";", "HOST_WIDE_INT", "frame_size", ";", "bool", "returned_p", ";", "if", "(", "h8300_os_task_function_p", "(", "current_function_decl", ")", ")", "return", ";", "frame_size", "=", "round_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "returned_p", "=", "false", ";", "h8300_emit_stack_adjustment", "(", "1", ",", "frame_size", ")", ";", "saved_regs", "=", "compute_saved_regs", "(", ")", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", ">=", "0", ";", "regno", "-=", "n_regs", ")", "{", "n_regs", "=", "1", ";", "if", "(", "saved_regs", "&", "(", "1", "<<", "regno", ")", ")", "{", "if", "(", "TARGET_H8300S", ")", "{", "if", "(", "(", "TARGET_H8300SX", "||", "(", "regno", "&", "3", ")", "==", "3", ")", "&&", "(", "(", "saved_regs", "<<", "3", ">>", "regno", ")", "&", "0x0f", ")", "==", "0x0f", ")", "n_regs", "=", "4", ";", "else", "if", "(", "(", "TARGET_H8300SX", "||", "(", "regno", "&", "3", ")", "==", "2", ")", "&&", "(", "(", "saved_regs", "<<", "2", ">>", "regno", ")", "&", "0x07", ")", "==", "0x07", ")", "n_regs", "=", "3", ";", "else", "if", "(", "(", "TARGET_H8300SX", "||", "(", "regno", "&", "1", ")", "==", "1", ")", "&&", "(", "(", "saved_regs", "<<", "1", ">>", "regno", ")", "&", "0x03", ")", "==", "0x03", ")", "n_regs", "=", "2", ";", "}", "if", "(", "TARGET_H8300SX", "&&", "!", "frame_pointer_needed", "&&", "frame_size", "==", "0", "&&", "(", "saved_regs", "&", "(", "(", "1", "<<", "(", "regno", "-", "n_regs", "+", "1", ")", ")", "-", "1", ")", ")", "==", "0", ")", "returned_p", "=", "true", ";", "h8300_push_pop", "(", "regno", "-", "n_regs", "+", "1", ",", "n_regs", ",", "1", ",", "returned_p", ")", ";", "}", "}", "if", "(", "frame_pointer_needed", ")", "{", "if", "(", "TARGET_H8300SX", ")", "returned_p", "=", "true", ";", "h8300_push_pop", "(", "HARD_FRAME_POINTER_REGNUM", ",", "1", ",", "1", ",", "returned_p", ")", ";", "}", "if", "(", "!", "returned_p", ")", "emit_insn", "(", "gen_rtx_RETURN", "(", "VOIDmode", ")", ")", ";", "}", "</s>" ]

[ "Generate", "RTL", "code", "for", "the", "function", "epilogue", "." ]

[ "h8300", "1", "1", "0", "1", "1", "3", "3", "3", "0x0f", "0x0f", "4", "3", "2", "2", "0x07", "0x07", "3", "1", "1", "1", "0x03", "0x03", "2", "0", "1", "1", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "void", "emitIndIdx", "(", "const", "MCExpr", "*", ")", "override", "{", "}", "</s>" ]

[ ".indidx" ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "bool", "ix86_valid_target_attribute_p", "(", "tree", "fndecl", ",", "tree", "ARG_UNUSED", "(", "name", ")", ",", "tree", "args", ",", "int", "ARG_UNUSED", "(", "flags", ")", ")", "{", "struct", "gcc_options", "func_options", ";", "tree", "new_target", ",", "new_optimize", ";", "bool", "ret", "=", "true", ";", "if", "(", "TREE_VALUE", "(", "args", ")", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "==", "STRING_CST", "&&", "TREE_CHAIN", "(", "args", ")", "==", "NULL_TREE", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "TREE_VALUE", "(", "args", ")", ")", ",", "\"default\"", ")", "==", "0", ")", "return", "true", ";", "tree", "old_optimize", "=", "build_optimization_node", "(", "&", "global_options", ")", ";", "tree", "func_optimize", "=", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", ";", "if", "(", "!", "func_optimize", ")", "func_optimize", "=", "old_optimize", ";", "memset", "(", "&", "func_options", ",", "0", ",", "sizeof", "(", "func_options", ")", ")", ";", "init_options_struct", "(", "&", "func_options", ",", "NULL", ")", ";", "lang_hooks", ".", "init_options_struct", "(", "&", "func_options", ")", ";", "cl_optimization_restore", "(", "&", "func_options", ",", "TREE_OPTIMIZATION", "(", "func_optimize", ")", ")", ";", "cl_target_option_restore", "(", "&", "func_options", ",", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ")", ";", "new_target", "=", "ix86_valid_target_attribute_tree", "(", "args", ",", "&", "func_options", ",", "&", "global_options_set", ")", ";", "new_optimize", "=", "build_optimization_node", "(", "&", "func_options", ")", ";", "if", "(", "new_target", "==", "error_mark_node", ")", "ret", "=", "false", ";", "else", "if", "(", "fndecl", "&&", "new_target", ")", "{", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", "=", "new_target", ";", "if", "(", "old_optimize", "!=", "new_optimize", ")", "DECL_FUNCTION_SPECIFIC_OPTIMIZATION", "(", "fndecl", ")", "=", "new_optimize", ";", "}", "return", "ret", ";", "}", "</s>" ]

[ "Hook", "to", "validate", "attribute", "(", "(", "target", "(", "``", "string", "''", ")", ")", ")", "." ]

[ "i386", "\"default\"", "0", "0" ]

[]

[ "<s>", "void", "FixupLEAPass", "::", "processInstruction", "(", "MachineBasicBlock", "::", "iterator", "&", "I", ",", "MachineFunction", "::", "iterator", "MFI", ")", "{", "MachineInstr", "*", "MI", "=", "I", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "int", "AddrOffset", "=", "X86II", "::", "getMemoryOperandNo", "(", "Desc", ".", "TSFlags", ")", ";", "if", "(", "AddrOffset", ">=", "0", ")", "{", "AddrOffset", "+=", "X86II", "::", "getOperandBias", "(", "Desc", ")", ";", "MachineOperand", "&", "p", "=", "MI", "->", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrBaseReg", ")", ";", "if", "(", "p", ".", "isReg", "(", ")", "&&", "p", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "p", ",", "I", ",", "MFI", ")", ";", "}", "MachineOperand", "&", "q", "=", "MI", "->", "getOperand", "(", "AddrOffset", "+", "X86", "::", "AddrIndexReg", ")", ";", "if", "(", "q", ".", "isReg", "(", ")", "&&", "q", ".", "getReg", "(", ")", "!=", "X86", "::", "ESP", ")", "{", "seekLEAFixup", "(", "q", ",", "I", ",", "MFI", ")", ";", "}", "}", "}", "</s>" ]

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

[ "X86", "X86II::getMemoryOperandNo", "0", "X86II::getOperandBias", "X86::AddrBaseReg", "X86::ESP", "X86::AddrIndexReg", "X86::ESP" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_file_start", "(", "void", ")", "{", "rs6000_gen_section_name", "(", "&", "xcoff_bss_section_name", ",", "main_input_filename", ",", "\".bss_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_private_data_section_name", ",", "main_input_filename", ",", "\".rw_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_read_only_section_name", ",", "main_input_filename", ",", "\".ro_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_tls_data_section_name", ",", "main_input_filename", ",", "\".tls_\"", ")", ";", "rs6000_gen_section_name", "(", "&", "xcoff_tbss_section_name", ",", "main_input_filename", ",", "\".tbss_[UL]\"", ")", ";", "fputs", "(", "\"\\t.file\\t\"", ",", "asm_out_file", ")", ";", "output_quoted_string", "(", "asm_out_file", ",", "main_input_filename", ")", ";", "fputc", "(", "'\\n'", ",", "asm_out_file", ")", ";", "if", "(", "write_symbols", "!=", "NO_DEBUG", ")", "switch_to_section", "(", "private_data_section", ")", ";", "switch_to_section", "(", "toc_section", ")", ";", "switch_to_section", "(", "text_section", ")", ";", "if", "(", "profile_flag", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.extern %s\\n\"", ",", "RS6000_MCOUNT", ")", ";", "rs6000_file_start", "(", ")", ";", "}", "</s>" ]

[ "Output", "at", "beginning", "of", "assembler", "file", ".", "Initialize", "the", "section", "names", "for", "the", "RS/6000", "at", "this", "point", ".", "Specify", "filename", ",", "including", "full", "path", ",", "to", "assembler", ".", "We", "want", "to", "go", "into", "the", "TOC", "section", "so", "at", "least", "one", ".toc", "will", "be", "emitted", ".", "Also", ",", "in", "order", "to", "output", "proper", ".bs/.es", "pairs", ",", "we", "need", "at", "least", "one", "static", "[", "RW", "]", "section", "emitted", ".", "Finally", ",", "declare", "mcount", "when", "profiling", "to", "make", "the", "assembler", "happy", "." ]

[ "powerpcspe", "\".bss_\"", "\".rw_\"", "\".ro_\"", "\".tls_\"", "\".tbss_[UL]\"", "\"\\t.file\\t\"", "\"\\t.extern %s\\n\"" ]

[]

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

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

[ "Kudeyar", "Kudeyar", "Kudeyar" ]

[]

[ "<s>", "static", "bool", "arm_print_operand_punct_valid_p", "(", "unsigned", "char", "code", ")", "{", "return", "(", "code", "==", "'@'", "||", "code", "==", "'|'", "||", "code", "==", "'.'", "||", "code", "==", "'('", "||", "code", "==", "')'", "||", "code", "==", "'#'", "||", "(", "TARGET_32BIT", "&&", "(", "code", "==", "'?'", ")", ")", "||", "(", "TARGET_THUMB2", "&&", "(", "code", "==", "'!'", ")", ")", "||", "(", "TARGET_THUMB", "&&", "(", "code", "==", "'_'", ")", ")", ")", ";", "}", "</s>" ]

[ "Target", "hook", "for", "indicating", "whether", "a", "punctuation", "character", "for", "TARGET_PRINT_OPERAND", "is", "valid", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isFPRCopy", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "TargetOpcode", "::", "COPY", ":", "{", "Register", "DstReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "AArch64", "::", "FPR128RegClass", ".", "contains", "(", "DstReg", ")", ";", "}", "case", "AArch64", "::", "ORRv16i8", ":", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "getNumOperands", "(", ")", "==", "3", "&&", "MI", ".", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"invalid ORRv16i8 operands\"", ")", ";", "return", "true", ";", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Does", "this", "instruction", "rename", "an", "FPR", "without", "modifying", "bits", "?" ]

[ "AArch64", "AArch64", "0", "AArch64::FPR128RegClass", "AArch64::ORRv16i8", "1", "2", "3", "0", "\"invalid ORRv16i8 operands\"" ]

[]

[ "<s>", "unsigned", "getPointerSize", "(", ")", "const", "{", "return", "8", ";", "}", "</s>" ]

[ "Layout", "pointer", "size", "in", "bytes", ",", "rounded", "up", "to", "a", "whole", "number", "of", "bytes", "." ]

[ "FISC", "8" ]

[]

[ "<s>", "void", "rs6000_expand_vector_set", "(", "rtx", "target", ",", "rtx", "val", ",", "int", "elt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "mode", ")", ";", "rtx", "mask", ",", "mem", ",", "x", ";", "int", "width", "=", "GET_MODE_SIZE", "(", "inner_mode", ")", ";", "int", "i", ";", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "(", "mode", "==", "V2DFmode", "||", "mode", "==", "V2DImode", ")", ")", "{", "rtx", "(", "*", "set_func", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", "=", "(", "(", "mode", "==", "V2DFmode", ")", "?", "gen_vsx_set_v2df", ":", "gen_vsx_set_v2di", ")", ";", "emit_insn", "(", "set_func", "(", "target", ",", "target", ",", "val", ",", "GEN_INT", "(", "elt", ")", ")", ")", ";", "return", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "GET_MODE_SIZE", "(", "inner_mode", ")", "&&", "elt", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "mode", ",", "val", ")", ")", ";", "return", ";", "}", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ",", "val", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "VOIDmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_LVE", ")", ";", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "reg", ",", "mem", ")", ",", "x", ")", ")", ")", ";", "mask", "=", "gen_rtx_PARALLEL", "(", "V16QImode", ",", "rtvec_alloc", "(", "16", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "++", "i", ")", "XVECEXP", "(", "mask", ",", "0", ",", "i", ")", "=", "GEN_INT", "(", "i", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "width", ";", "++", "i", ")", "XVECEXP", "(", "mask", ",", "0", ",", "elt", "*", "width", "+", "i", ")", "=", "GEN_INT", "(", "i", "+", "0x10", ")", ";", "x", "=", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "XVEC", "(", "mask", ",", "0", ")", ")", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "x", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "target", ",", "reg", ",", "force_reg", "(", "V16QImode", ",", "x", ")", ")", ",", "UNSPEC_VPERM", ")", ";", "else", "{", "rtx", "notx", "=", "gen_rtx_NOT", "(", "V16QImode", ",", "force_reg", "(", "V16QImode", ",", "x", ")", ")", ";", "rtx", "iorx", "=", "(", "TARGET_P8_VECTOR", "?", "gen_rtx_IOR", "(", "V16QImode", ",", "notx", ",", "notx", ")", ":", "gen_rtx_AND", "(", "V16QImode", ",", "notx", ",", "notx", ")", ")", ";", "rtx", "tmp", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "iorx", ")", ")", ";", "x", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "reg", ",", "target", ",", "tmp", ")", ",", "UNSPEC_VPERM", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Set", "field", "ELT_RTX", "of", "TARGET", "to", "VAL", "." ]

[ "rs6000", "0", "0", "1", "2", "16", "0", "16", "0", "0", "0", "0x10", "0", "3", "3" ]

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "shouldReduceLoadWidth", "(", "SDNode", "*", "Load", ",", "ISD", "::", "LoadExtType", "ExtTy", ",", "EVT", "NewVT", ")", "const", "{", "if", "(", "ExtTy", "!=", "ISD", "::", "NON_EXTLOAD", ")", "return", "true", ";", "MemSDNode", "*", "Mem", "=", "dyn_cast", "<", "MemSDNode", ">", "(", "Load", ")", ";", "assert", "(", "Mem", ")", ";", "const", "SDValue", "&", "Base", "=", "Mem", "->", "getBasePtr", "(", ")", ";", "if", "(", "Base", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "Base", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "SHL", "&&", "Base", ".", "getOperand", "(", "1", ")", ".", "hasOneUse", "(", ")", "&&", "Base", ".", "getOperand", "(", "1", ")", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "{", "uint64_t", "ShiftAmount", "=", "Base", ".", "getOperand", "(", "1", ")", ".", "getConstantOperandVal", "(", "1", ")", ";", "uint64_t", "LoadBytes", "=", "Mem", "->", "getMemoryVT", "(", ")", ".", "getSizeInBits", "(", ")", "/", "8", ";", "if", "(", "ShiftAmount", "==", "Log2_32", "(", "LoadBytes", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "believe", "it", "is", "correct", "and", "profitable", "to", "reduce", "the", "load", "node", "to", "a", "smaller", "type", "." ]

[ "AArch64", "AArch64", "ISD::LoadExtType", "ISD::NON_EXTLOAD", "ISD::ADD", "1", "ISD::SHL", "1", "1", "1", "ISD::Constant", "1", "1", "8" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"TVM continuations hoisting pass\"", ";", "}", "</s>" ]

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

[ "TVM", "\"TVM continuations hoisting pass\"" ]

[]

[ "<s>", "void", "PTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "static", "const", "char", "*", "alpha_mangle_fundamental_type", "(", "tree", "type", ")", "{", "if", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MANGLE_FUNDAMENTAL_TYPE", "." ]

[ "alpha", "\"g\"" ]

[]

[ "<s>", "int", "getIntImmCostInst", "(", "unsigned", "Opc", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", "=", "nullptr", ")", "{", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "Lanai" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "&", "Flags", ")", "const", "{", "if", "(", "!", "TargetInstrInfo", "::", "isMBBSafeToOutlineFrom", "(", "MBB", ",", "Flags", ")", ")", "return", "false", ";", "assert", "(", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ".", "tracksLiveness", "(", ")", "&&", "\"Suitable Machine Function for outlining must track liveness\"", ")", ";", "LiveRegUnits", "LRU", "(", "getRegisterInfo", "(", ")", ")", ";", "std", "::", "for_each", "(", "MBB", ".", "rbegin", "(", ")", ",", "MBB", ".", "rend", "(", ")", ",", "[", "&", "LRU", "]", "(", "MachineInstr", "&", "MI", ")", "{", "LRU", ".", "accumulate", "(", "MI", ")", ";", "}", ")", ";", "bool", "W16AvailableInBlock", "=", "LRU", ".", "available", "(", "AArch64", "::", "W16", ")", ";", "bool", "W17AvailableInBlock", "=", "LRU", ".", "available", "(", "AArch64", "::", "W17", ")", ";", "bool", "NZCVAvailableInBlock", "=", "LRU", ".", "available", "(", "AArch64", "::", "NZCV", ")", ";", "if", "(", "W16AvailableInBlock", "&&", "W17AvailableInBlock", "&&", "NZCVAvailableInBlock", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "UnsafeRegsDead", ";", "LRU", ".", "addLiveOuts", "(", "MBB", ")", ";", "if", "(", "W16AvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "W16", ")", ")", "return", "false", ";", "if", "(", "W17AvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "W17", ")", ")", "return", "false", ";", "if", "(", "NZCVAvailableInBlock", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "NZCV", ")", ")", "return", "false", ";", "if", "(", "any_of", "(", "MBB", ",", "[", "]", "(", "MachineInstr", "&", "MI", ")", "{", "return", "MI", ".", "isCall", "(", ")", ";", "}", ")", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "HasCalls", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "bool", "CanSaveLR", "=", "false", ";", "const", "AArch64RegisterInfo", "*", "ARI", "=", "static_cast", "<", "const", "AArch64RegisterInfo", "*", ">", "(", "MF", "->", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ";", "for", "(", "unsigned", "Reg", ":", "AArch64", "::", "GPR64RegClass", ")", "{", "if", "(", "!", "ARI", "->", "isReservedReg", "(", "*", "MF", ",", "Reg", ")", "&&", "Reg", "!=", "AArch64", "::", "LR", "&&", "Reg", "!=", "AArch64", "::", "X16", "&&", "Reg", "!=", "AArch64", "::", "X17", "&&", "LRU", ".", "available", "(", "Reg", ")", ")", "{", "CanSaveLR", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "CanSaveLR", "&&", "!", "LRU", ".", "available", "(", "AArch64", "::", "LR", ")", ")", "Flags", "|=", "MachineOutlinerMBBFlags", "::", "LRUnavailableSomewhere", ";", "return", "true", ";", "}", "</s>" ]

[ "Optional", "target", "hook", "that", "returns", "true", "if", "MBB", "is", "safe", "to", "outline", "from", ",", "and", "returns", "any", "target-specific", "information", "in", "Flags", "." ]

[ "AArch64", "AArch64", "\"Suitable Machine Function for outlining must track liveness\"", "AArch64::W16", "AArch64::W17", "AArch64::NZCV", "AArch64::W16", "AArch64::W17", "AArch64::NZCV", "AArch64", "AArch64", "AArch64::GPR64RegClass", "AArch64::LR", "AArch64::X16", "AArch64::X17", "AArch64::LR" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "{", "return", "Kind", "==", "k_Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "Mips" ]

[]

[ "<s>", "SDNode", "*", "BPFDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "UNDEF", ":", "{", "errs", "(", ")", "<<", "\"BUG: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "'\\n'", ";", "report_fatal_error", "(", "\"shouldn't see UNDEF during Select\"", ")", ";", "break", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "unsigned", "IntNo", "=", "cast", "<", "ConstantSDNode", ">", "(", "Node", "->", "getOperand", "(", "1", ")", ")", "->", "getZExtValue", "(", ")", ";", "switch", "(", "IntNo", ")", "{", "case", "Intrinsic", "::", "bpf_load_byte", ":", "case", "Intrinsic", "::", "bpf_load_half", ":", "case", "Intrinsic", "::", "bpf_load_word", ":", "{", "SDLoc", "DL", "(", "Node", ")", ";", "SDValue", "Chain", "=", "Node", "->", "getOperand", "(", "0", ")", ";", "SDValue", "N1", "=", "Node", "->", "getOperand", "(", "1", ")", ";", "SDValue", "Skb", "=", "Node", "->", "getOperand", "(", "2", ")", ";", "SDValue", "N3", "=", "Node", "->", "getOperand", "(", "3", ")", ";", "SDValue", "R6Reg", "=", "CurDAG", "->", "getRegister", "(", "BPF", "::", "R6", ",", "MVT", "::", "i64", ")", ";", "Chain", "=", "CurDAG", "->", "getCopyToReg", "(", "Chain", ",", "DL", ",", "R6Reg", ",", "Skb", ",", "SDValue", "(", ")", ")", ";", "Node", "=", "CurDAG", "->", "UpdateNodeOperands", "(", "Node", ",", "Chain", ",", "N1", ",", "R6Reg", ",", "N3", ")", ";", "break", ";", "}", "}", "break", ";", "}", "case", "ISD", "::", "FrameIndex", ":", "{", "int", "FI", "=", "cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "BPF", "::", "MOV_rr", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "SDLoc", "(", "Node", ")", ",", "VT", ",", "TFI", ")", ";", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"=> \"", ";", "if", "(", "ResNode", "==", "nullptr", "||", "ResNode", "==", "Node", ")", "Node", "->", "dump", "(", "CurDAG", ")", ";", "else", "ResNode", "->", "dump", "(", "CurDAG", ")", ";", "dbgs", "(", ")", "<<", "'\\n'", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "BPF", "BPF", "\"Selecting: \"", "\"== \"", "ISD::UNDEF", "\"BUG: \"", "\"shouldn't see UNDEF during Select\"", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::bpf_load_byte", "Intrinsic::bpf_load_half", "Intrinsic::bpf_load_word", "0", "1", "2", "3", "BPF::R6", "MVT::i64", "ISD::FrameIndex", "0", "BPF::MOV_rr", "\"=> \"" ]

[]

[ "<s>", "static", "bool", "arc_can_use_doloop_p", "(", "const", "widest_int", "&", "iterations", ",", "const", "widest_int", "&", ",", "unsigned", "int", "loop_depth", ",", "bool", "entered_at_top", ")", "{", "if", "(", "loop_depth", ">", "1", ")", "return", "false", ";", "if", "(", "TARGET_ARC700", "&&", "!", "entered_at_top", "&&", "wi", "::", "gtu_p", "(", "iterations", ",", "0", ")", "&&", "wi", "::", "leu_p", "(", "iterations", ",", "flag_pic", "?", "6", ":", "3", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_USE_DOLOOP_P", "." ]

[ "arc", "1", "0", "6", "3" ]

[]

[ "<s>", "std", "::", "vector", "<", "std", "::", "string", ">", "pop", "(", "Px", "a", ")", "{", "return", "D", "(", "\"pop\"", ",", "R", "(", "a", ")", ")", ";", "}", "</s>" ]

[ "Pop", "the", "previous", "solver", "state", "." ]

[ "Teak", "\"pop\"" ]

[]

[ "<s>", "MCOperand", "P2MCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "unsigned", "offset", ")", "const", "{", "MachineOperandType", "MOTy", "=", "MO", ".", "getType", "(", ")", ";", "switch", "(", "MOTy", ")", "{", "default", ":", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Operand type: \"", "<<", "(", "int", ")", "MOTy", "<<", "\"\\n\"", ")", ";", "llvm_unreachable", "(", "\"MCInstrLower: unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"mcinst lower, MO: \"", ";", "MO", ".", "dump", "(", ")", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"MO type: \"", "<<", "(", "int", ")", "MOTy", "<<", "\"\\n\"", ")", ";", "return", "LowerSymbolOperand", "(", "MO", ",", "MOTy", ",", "offset", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "break", ";", "return", "MCOperand", "::", "createReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", "+", "offset", ")", ";", "case", "MachineOperand", "::", "MO_RegisterMask", ":", "break", ";", "}", "return", "MCOperand", "(", ")", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "P2", "P2", "\"Operand type: \"", "\"\\n\"", "\"MCInstrLower: unknown operand type\"", "\"mcinst lower, MO: \"", "\"MO type: \"", "\"\\n\"" ]

[]

[ "<s>", "unsigned", "int", "call_properties", "(", "const", "function_instance", "&", ")", "const", "OVERRIDE", "{", "return", "0", ";", "}", "</s>" ]

[ "Default", "implementation", "of", "function_base", ":", ":call_properties", ",", "with", "conservatively", "correct", "behavior", "for", "floating-point", "instructions", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "const", "ARMSubtarget", "*", "ARMBaseTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "FS", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "std", "::", "string", "Key", "=", "CPU", "+", "FS", ";", "if", "(", "F", ".", "hasMinSize", "(", ")", ")", "Key", "+=", "\"+minsize\"", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "ARMSubtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ",", "F", ".", "hasMinSize", "(", ")", ")", ";", "if", "(", "!", "I", "->", "isThumb", "(", ")", "&&", "!", "I", "->", "hasARMOps", "(", ")", ")", "F", ".", "getContext", "(", ")", ".", "emitError", "(", "\"Function '\"", "+", "F", ".", "getName", "(", ")", "+", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "ARM", "ARM", "ARM", "\"target-cpu\"", "\"target-features\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "\"+minsize\"", "ARM", "ARM", "\"Function '\"", "\"' uses ARM \"", "\"instructions, but the target does not support ARM mode execution.\"" ]

[]

[ "<s>", "static", "void", "iq2000_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "tree", "type", "ATTRIBUTE_UNUSED", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "unsigned", "int", "iq2000_off", "=", "!", "cum", "->", "last_arg_fp", ";", "unsigned", "int", "iq2000_fp_off", "=", "cum", "->", "last_arg_fp", ";", "if", "(", "(", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", "-", "iq2000_off", ")", ")", "{", "int", "iq2000_save_gp_regs", "=", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "arg_words", "-", "iq2000_off", ";", "int", "iq2000_save_fp_regs", "=", "(", "MAX_ARGS_IN_REGISTERS", "-", "cum", "->", "fp_arg_words", "-", "iq2000_fp_off", ")", ";", "if", "(", "iq2000_save_gp_regs", "<", "0", ")", "iq2000_save_gp_regs", "=", "0", ";", "if", "(", "iq2000_save_fp_regs", "<", "0", ")", "iq2000_save_fp_regs", "=", "0", ";", "*", "pretend_size", "=", "(", "(", "iq2000_save_gp_regs", "*", "UNITS_PER_WORD", ")", "+", "(", "iq2000_save_fp_regs", "*", "UNITS_PER_FPREG", ")", ")", ";", "if", "(", "!", "(", "no_rtl", ")", ")", "{", "if", "(", "cum", "->", "arg_words", "<", "MAX_ARGS_IN_REGISTERS", "-", "iq2000_off", ")", "{", "rtx", "ptr", ",", "mem", ";", "ptr", "=", "plus_constant", "(", "virtual_incoming_args_rtx", ",", "-", "(", "iq2000_save_gp_regs", "*", "UNITS_PER_WORD", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "ptr", ")", ";", "move_block_from_reg", "(", "cum", "->", "arg_words", "+", "GP_ARG_FIRST", "+", "iq2000_off", ",", "mem", ",", "iq2000_save_gp_regs", ")", ";", "}", "}", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "iq2000", "0", "0", "0", "0" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "MMIX" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "materializeFrameBaseRegister", "(", "MachineBasicBlock", "*", "MBB", ",", "unsigned", "BaseReg", ",", "int", "FrameIdx", ",", "int64_t", "Offset", ")", "const", "{", "ARMFunctionInfo", "*", "AFI", "=", "MBB", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "ADDriOpc", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "ADDri", ":", "(", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "?", "ARM", "::", "tADDrSPi", ":", "ARM", "::", "t2ADDri", ")", ";", "MachineBasicBlock", "::", "iterator", "Ins", "=", "MBB", "->", "begin", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "Ins", "!=", "MBB", "->", "end", "(", ")", ")", "DL", "=", "Ins", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "MBB", ",", "Ins", ",", "DL", ",", "TII", ".", "get", "(", "ADDriOpc", ")", ",", "BaseReg", ")", ".", "addFrameIndex", "(", "FrameIdx", ")", ".", "addImm", "(", "Offset", ")", ";", "if", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "AddDefaultCC", "(", "AddDefaultPred", "(", "MIB", ")", ")", ";", "}", "</s>" ]

[ "Insert", "defining", "instruction", "(", "s", ")", "for", "a", "pointer", "to", "FrameIdx", "before", "insertion", "point", "I", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::ADDri", "ARM::tADDrSPi", "ARM::t2ADDri" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "finalizeLowering", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SIMachineFunctionInfo", "*", "Info", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "if", "(", "Info", "->", "isEntryFunction", "(", ")", ")", "{", "reservePrivateMemoryRegs", "(", "getTargetMachine", "(", ")", ",", "MF", ",", "*", "TRI", ",", "*", "Info", ")", ";", "}", "bool", "NeedSP", "=", "!", "Info", "->", "isEntryFunction", "(", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "hasCalls", "(", ")", ";", "if", "(", "NeedSP", ")", "{", "unsigned", "ReservedStackPtrOffsetReg", "=", "TRI", "->", "reservedStackPtrOffsetReg", "(", "MF", ")", ";", "Info", "->", "setStackPtrOffsetReg", "(", "ReservedStackPtrOffsetReg", ")", ";", "assert", "(", "Info", "->", "getStackPtrOffsetReg", "(", ")", "!=", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "assert", "(", "!", "TRI", "->", "isSubRegister", "(", "Info", "->", "getScratchRSrcReg", "(", ")", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SP_REG", ",", "Info", "->", "getStackPtrOffsetReg", "(", ")", ")", ";", "}", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "PRIVATE_RSRC_REG", ",", "Info", "->", "getScratchRSrcReg", "(", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "FP_REG", ",", "Info", "->", "getFrameOffsetReg", "(", ")", ")", ";", "MRI", ".", "replaceRegWith", "(", "AMDGPU", "::", "SCRATCH_WAVE_OFFSET_REG", ",", "Info", "->", "getScratchWaveOffsetReg", "(", ")", ")", ";", "Info", "->", "limitOccupancy", "(", "MF", ")", ";", "TargetLoweringBase", "::", "finalizeLowering", "(", "MF", ")", ";", "}", "</s>" ]

[ "Execute", "target", "specific", "actions", "to", "finalize", "target", "lowering", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "AMDGPU::SP_REG", "AMDGPU::PRIVATE_RSRC_REG", "AMDGPU::FP_REG", "AMDGPU::SCRATCH_WAVE_OFFSET_REG" ]

[]

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

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

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "const", "uint32_t", "*", "SIRegisterInfo", "::", "getNoPreservedMask", "(", ")", "const", "{", "return", "CSR_AMDGPU_NoRegs_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "register", "mask", "that", "clobbers", "everything", "." ]

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Z80 Machine Late Optimization\"", ";", "}", "</s>" ]

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

[ "Z80", "\"Z80 Machine Late Optimization\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "mips_epilogue_emit_cfa_restores", "(", "void", ")", "{", "rtx_insn", "*", "insn", ";", "insn", "=", "get_last_insn", "(", ")", ";", "if", "(", "mips_epilogue", ".", "cfa_restores", ")", "{", "gcc_assert", "(", "insn", "&&", "!", "REG_NOTES", "(", "insn", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "REG_NOTES", "(", "insn", ")", "=", "mips_epilogue", ".", "cfa_restores", ";", "mips_epilogue", ".", "cfa_restores", "=", "0", ";", "}", "return", "insn", ";", "}", "</s>" ]

[ "Attach", "all", "pending", "register", "saves", "to", "the", "previous", "instruction", ".", "Return", "that", "instruction", "." ]

[ "mips", "1", "0" ]

[]

[ "<s>", "static", "void", "insn_set_clock", "(", "rtx", "insn", ",", "int", "cycle", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "uid", ">=", "INSN_INFO_LENGTH", ")", "insn_info", ".", "safe_grow", "(", "uid", "*", "5", "/", "4", "+", "10", ",", "true", ")", ";", "INSN_INFO_ENTRY", "(", "uid", ")", ".", "clock", "=", "cycle", ";", "INSN_INFO_ENTRY", "(", "uid", ")", ".", "new_cond", "=", "NULL", ";", "INSN_INFO_ENTRY", "(", "uid", ")", ".", "reservation", "=", "0", ";", "INSN_INFO_ENTRY", "(", "uid", ")", ".", "ebb_start", "=", "false", ";", "}", "</s>" ]

[ "Set", "the", "clock", "cycle", "of", "INSN", "to", "CYCLE", ".", "Also", "clears", "the", "insn", "'s", "entry", "in", "new_conditions", "." ]

[ "c6x", "5", "4", "10", "0" ]

[]

[ "<s>", "SDNode", "*", "XNCMDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ")", ";", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Node", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "pru_section_type_flags", "(", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "reloc", ")", "{", "unsigned", "int", "flags", "=", "default_section_type_flags", "(", "decl", ",", "name", ",", "reloc", ")", ";", "if", "(", "!", "strcmp", "(", "name", ",", "\".pru_irq_map\"", ")", ")", "flags", "=", "SECTION_DEBUG", "|", "SECTION_RETAIN", ";", "return", "flags", ";", "}", "</s>" ]

[ "Implement", "TARGET_SECTION_TYPE_FLAGS", "." ]

[ "pru", "\".pru_irq_map\"" ]

[]

[ "<s>", "static", "bool", "or1k_strict_argument_naming", "(", "cumulative_args_t", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_STRICT_ARGUMENT_NAMING", ".", "Return", "true", "always", "as", "on", "OpenRISC", "the", "last", "argument", "in", "a", "variatic", "function", "is", "named", "." ]

[ "or1k" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "lowerCRSpilling", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "unsigned", "FrameIndex", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "dl", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "const", "TargetRegisterClass", "*", "G8RC", "=", "&", "PPC", "::", "G8RCRegClass", ";", "const", "TargetRegisterClass", "*", "GPRC", "=", "&", "PPC", "::", "GPRCRegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Subtarget", ".", "isPPC64", "(", ")", "?", "G8RC", ":", "GPRC", ";", "unsigned", "Reg", "=", "findScratchRegister", "(", "II", ",", "RS", ",", "RC", ",", "SPAdj", ")", ";", "unsigned", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "MFCRpseud", ")", ",", "Reg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "isKill", "(", ")", ")", ")", ";", "if", "(", "SrcReg", "!=", "PPC", "::", "CR0", ")", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "RLWINM", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "PPCRegisterInfo", "::", "getRegisterNumbering", "(", "SrcReg", ")", "*", "4", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "31", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "II", ",", "dl", ",", "TII", ".", "get", "(", "PPC", "::", "STW", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ")", ",", "FrameIndex", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "lowerCRSpilling", "-", "Generate", "the", "code", "for", "spilling", "a", "CR", "register", "." ]

[ "PowerPC", "PPC", "PPC::G8RCRegClass", "PPC::GPRCRegClass", "PPC", "0", "PPC::MFCRpseud", "0", "PPC::CR0", "PPC::RLWINM", "PPC", "4", "0", "31", "PPC::STW", "1" ]

[]

[ "<s>", "virtual", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Kind", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "TargetSize", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ";", "unsigned", "TargetOffset", "=", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", "=", "(", "TargetOffset", "+", "TargetSize", "+", "7", ")", "/", "8", ";", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "TargetSize", ")", ")", ";", "unsigned", "Shift", "=", "FullSize", "*", "8", "-", "(", "TargetOffset", "+", "TargetSize", ")", ";", "CurVal", "|=", "(", "Value", "&", "Mask", ")", "<<", "Shift", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</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", "." ]

[ "Patmos", "7", "8", "7", "8", "0", "0", "1", "8", "1", "64", "8", "0", "1", "8", "0xff" ]

[]

[ "<s>", "bool", "X86ATTAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'c'", ":", "printOperand", "(", "MI", ",", "OpNo", ",", "\"mem\"", ",", "true", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'w'", ":", "case", "'k'", ":", "case", "'q'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MI", "->", "getOperand", "(", "OpNo", ")", ",", "ExtraCode", "[", "0", "]", ")", ";", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "case", "'P'", ":", "printOperand", "(", "MI", ",", "OpNo", ",", "\"mem\"", ")", ";", "return", "false", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNo", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "X86", "X86", "0", "1", "0", "0", "\"mem\"", "0", "\"mem\"" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "bool", "MayNeedScavengingEmergencySlot", "=", "MFI", "->", "hasStackObjects", "(", ")", ";", "assert", "(", "(", "RS", "||", "!", "MayNeedScavengingEmergencySlot", ")", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "MayNeedScavengingEmergencySlot", ")", "{", "int", "ScavengeFI", "=", "MFI", "->", "CreateSpillStackObject", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getSize", "(", ")", ",", "AMDGPU", "::", "SGPR_32RegClass", ".", "getAlignment", "(", ")", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "static", "void", "release_scratch_register_on_entry", "(", "struct", "scratch_reg", "*", "sr", ",", "HOST_WIDE_INT", "offset", ",", "bool", "release_via_pop", ")", "{", "if", "(", "sr", "->", "saved", ")", "{", "if", "(", "release_via_pop", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "x", ",", "insn", "=", "emit_insn", "(", "gen_pop", "(", "sr", "->", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "x", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";", "x", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "x", ")", ";", "m", "->", "fs", ".", "sp_offset", "-=", "UNITS_PER_WORD", ";", "}", "else", "{", "rtx", "x", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "offset", ")", ";", "x", "=", "gen_rtx_SET", "(", "sr", "->", "reg", ",", "gen_rtx_MEM", "(", "word_mode", ",", "x", ")", ")", ";", "emit_insn", "(", "x", ")", ";", "}", "}", "}", "</s>" ]

[ "Release", "a", "scratch", "register", "obtained", "from", "the", "preceding", "function", ".", "If", "RELEASE_VIA_POP", "is", "true", ",", "we", "just", "pop", "the", "register", "off", "the", "stack", "to", "release", "it", ".", "This", "is", "what", "non-Linux", "systems", "use", "with", "-fstack-check", ".", "Otherwise", "we", "use", "OFFSET", "to", "locate", "the", "saved", "register", "and", "the", "allocated", "stack", "space", "becomes", "part", "of", "the", "local", "frame", "and", "is", "deallocated", "by", "the", "epilogue", "." ]

[ "i386", "1" ]

[]

[ "<s>", "const", "char", "*", "mips_output_jump", "(", "rtx", "*", "operands", ",", "int", "target_opno", ",", "int", "size_opno", ",", "bool", "link_p", ")", "{", "static", "char", "buffer", "[", "300", "]", ";", "char", "*", "s", "=", "buffer", ";", "bool", "reg_p", "=", "REG_P", "(", "operands", "[", "target_opno", "]", ")", ";", "const", "char", "*", "and_link", "=", "link_p", "?", "\"al\"", ":", "\"\"", ";", "const", "char", "*", "reg", "=", "reg_p", "?", "\"r\"", ":", "\"\"", ";", "const", "char", "*", "compact", "=", "\"\"", ";", "const", "char", "*", "nop", "=", "\"%/\"", ";", "const", "char", "*", "short_delay", "=", "link_p", "?", "\"%!\"", ":", "\"\"", ";", "const", "char", "*", "insn_name", "=", "TARGET_CB_NEVER", "||", "reg_p", "?", "\"j\"", ":", "\"b\"", ";", "if", "(", "!", "final_sequence", "&&", "(", "TARGET_CB_MAYBE", "||", "(", "ISA_HAS_JRC", "&&", "!", "link_p", "&&", "reg_p", ")", ")", ")", "{", "compact", "=", "\"c\"", ";", "nop", "=", "\"\"", ";", "}", "if", "(", "TARGET_USE_GOT", "&&", "!", "TARGET_EXPLICIT_RELOCS", ")", "sprintf", "(", "s", ",", "\"%%*%s%s\\t%%%d%%/\"", ",", "insn_name", ",", "and_link", ",", "target_opno", ")", ";", "else", "{", "if", "(", "!", "reg_p", "&&", "TARGET_ABICALLS_PIC2", ")", "s", "+=", "sprintf", "(", "s", ",", "\".option\\tpic0\\n\\t\"", ")", ";", "if", "(", "reg_p", "&&", "mips_get_pic_call_symbol", "(", "operands", ",", "size_opno", ")", ")", "s", "+=", "sprintf", "(", "s", ",", "\"%%*.reloc\\t1f,%s,%%%d\\n1:\\t\"", ",", "TARGET_MICROMIPS", "?", "\"R_MICROMIPS_JALR\"", ":", "\"R_MIPS_JALR\"", ",", "size_opno", ")", ";", "else", "s", "+=", "sprintf", "(", "s", ",", "\"%%*\"", ")", ";", "s", "+=", "sprintf", "(", "s", ",", "\"%s%s%s%s%s\\t%%%d%s\"", ",", "insn_name", ",", "and_link", ",", "reg", ",", "compact", ",", "short_delay", ",", "target_opno", ",", "nop", ")", ";", "if", "(", "!", "reg_p", "&&", "TARGET_ABICALLS_PIC2", ")", "s", "+=", "sprintf", "(", "s", ",", "\"\\n\\t.option\\tpic2\"", ")", ";", "}", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "for", "a", "call", ".", "OPERANDS", "are", "the", "operands", ",", "TARGET_OPNO", "is", "the", "operand", "number", "of", "the", "target", ".", "SIZE_OPNO", "is", "the", "operand", "number", "of", "the", "argument", "size", "operand", "that", "can", "optionally", "hold", "the", "call", "attributes", ".", "If", "SIZE_OPNO", "is", "not", "-1", "and", "the", "call", "is", "indirect", ",", "use", "the", "function", "symbol", "from", "the", "call", "attributes", "to", "attach", "a", "R_MIPS_JALR", "relocation", "to", "the", "call", ".", "LINK_P", "indicates", "whether", "the", "jump", "is", "a", "call", "and", "needs", "to", "set", "the", "link", "register", ".", "When", "generating", "GOT", "code", "without", "explicit", "relocation", "operators", ",", "all", "calls", "should", "use", "assembly", "macros", ".", "Otherwise", ",", "all", "indirect", "calls", "should", "use", "``", "jr", "''", "or", "``", "jalr", "''", ";", "we", "will", "arrange", "to", "restore", "$", "gp", "afterwards", "if", "necessary", ".", "Finally", ",", "we", "can", "only", "generate", "direct", "calls", "for", "-mabicalls", "by", "temporarily", "switching", "to", "non-PIC", "mode", ".", "For", "microMIPS", "jal", "(", "r", ")", ",", "we", "try", "to", "generate", "jal", "(", "r", ")", "s", "when", "a", "16-bit", "instruction", "is", "in", "the", "delay", "slot", "of", "jal", "(", "r", ")", ".", "Where", "compact", "branches", "are", "available", ",", "we", "try", "to", "use", "them", "if", "the", "delay", "slot", "has", "a", "NOP", "(", "or", "equivalently", "delay", "slots", "were", "not", "enabled", "for", "the", "instruction", "anyway", ")", "." ]

[ "mips", "300", "\"al\"", "\"\"", "\"r\"", "\"\"", "\"\"", "\"%/\"", "\"%!\"", "\"\"", "\"j\"", "\"b\"", "\"c\"", "\"\"", "\"%%*%s%s\\t%%%d%%/\"", "\".option\\tpic0\\n\\t\"", "\"%%*.reloc\\t1f,%s,%%%d\\n1:\\t\"", "\"R_MICROMIPS_JALR\"", "\"R_MIPS_JALR\"", "\"%%*\"", "\"%s%s%s%s%s\\t%%%d%s\"", "\"\\n\\t.option\\tpic2\"" ]

[]

[ "<s>", "bool", "m68k_movem_pattern_p", "(", "rtx", "pattern", ",", "rtx", "automod_base", ",", "HOST_WIDE_INT", "automod_offset", ",", "bool", "store_p", ")", "{", "rtx", "base", ",", "mem_base", ",", "set", ",", "mem", ",", "reg", ",", "last_reg", ";", "HOST_WIDE_INT", "offset", ",", "mem_offset", ";", "int", "i", ",", "first", ",", "len", ";", "enum", "reg_class", "rclass", ";", "len", "=", "XVECLEN", "(", "pattern", ",", "0", ")", ";", "first", "=", "(", "automod_base", "!=", "NULL", ")", ";", "if", "(", "automod_base", ")", "{", "if", "(", "store_p", "!=", "(", "automod_offset", "<", "0", ")", ")", "return", "false", ";", "base", "=", "automod_base", ";", "offset", "=", "(", "automod_offset", "<", "0", "?", "automod_offset", ":", "0", ")", ";", "}", "else", "{", "base", "=", "NULL", ";", "offset", "=", "0", ";", "}", "last_reg", "=", "NULL", ";", "rclass", "=", "NO_REGS", ";", "for", "(", "i", "=", "first", ";", "i", "<", "len", ";", "i", "++", ")", "{", "set", "=", "XVECEXP", "(", "pattern", ",", "0", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "set", ")", "!=", "SET", ")", "return", "false", ";", "mem", "=", "XEXP", "(", "set", ",", "!", "store_p", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", "||", "!", "memory_operand", "(", "mem", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "base", "==", "NULL", ")", "{", "m68k_split_offset", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "TARGET_COLDFIRE", "&&", "!", "m68k_legitimate_base_reg_p", "(", "base", ",", "reload_completed", ")", ")", "return", "false", ";", "}", "else", "{", "m68k_split_offset", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "&", "mem_base", ",", "&", "mem_offset", ")", ";", "if", "(", "!", "rtx_equal_p", "(", "base", ",", "mem_base", ")", "||", "offset", "!=", "mem_offset", ")", "return", "false", ";", "}", "reg", "=", "XEXP", "(", "set", ",", "store_p", ")", ";", "if", "(", "!", "REG_P", "(", "reg", ")", "||", "!", "HARD_REGISTER_P", "(", "reg", ")", "||", "GET_MODE", "(", "reg", ")", "!=", "reg_raw_mode", "[", "REGNO", "(", "reg", ")", "]", ")", "return", "false", ";", "if", "(", "last_reg", ")", "{", "if", "(", "!", "TEST_HARD_REG_BIT", "(", "reg_class_contents", "[", "rclass", "]", ",", "REGNO", "(", "reg", ")", ")", "||", "REGNO", "(", "last_reg", ")", ">=", "REGNO", "(", "reg", ")", ")", "return", "false", ";", "}", "else", "{", "if", "(", "INT_REGNO_P", "(", "REGNO", "(", "reg", ")", ")", ")", "rclass", "=", "GENERAL_REGS", ";", "else", "if", "(", "FP_REGNO_P", "(", "REGNO", "(", "reg", ")", ")", ")", "rclass", "=", "FP_REGS", ";", "else", "return", "false", ";", "}", "last_reg", "=", "reg", ";", "offset", "+=", "GET_MODE_SIZE", "(", "GET_MODE", "(", "reg", ")", ")", ";", "}", "if", "(", "automod_base", "&&", "offset", "!=", "(", "automod_offset", "<", "0", "?", "0", ":", "automod_offset", ")", ")", "return", "false", ";", "if", "(", "len", "<", "first", "+", "(", "rclass", "==", "FP_REGS", "?", "MIN_FMOVEM_REGS", ":", "MIN_MOVEM_REGS", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "PATTERN", "is", "a", "PARALLEL", "suitable", "for", "a", "movem", "or", "fmovem", "instruction", ".", "STORE_P", "says", "whether", "the", "move", "is", "a", "load", "or", "store", ".", "If", "the", "instruction", "uses", "post-increment", "or", "pre-decrement", "addressing", ",", "AUTOMOD_BASE", "is", "the", "base", "register", "and", "AUTOMOD_OFFSET", "is", "the", "total", "adjustment", ".", "This", "adjustment", "will", "be", "made", "by", "the", "first", "element", "of", "PARALLEL", ",", "with", "the", "loads", "or", "stores", "starting", "at", "element", "1", ".", "If", "the", "instruction", "does", "not", "use", "post-increment", "or", "pre-decrement", "addressing", ",", "AUTOMOD_BASE", "is", "null", ",", "AUTOMOD_OFFSET", "is", "0", ",", "and", "the", "loads", "or", "stores", "start", "at", "element", "0", "." ]

[ "m68k", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

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

[ "Implement", "RETURN_ADDR_RTX", ".", "Note", ",", "we", "do", "not", "support", "moving", "back", "to", "a", "previous", "frame", "." ]

[ "nios2", "0" ]

[]

[ "<s>", "EVT", "RISCVTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "getPointerTy", "(", "DL", ",", "0", ")", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", "&&", "(", "VT", ".", "isScalableVector", "(", ")", "||", "Subtarget", ".", "useRVVForFixedLengthVectors", "(", ")", ")", ")", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "0", "MVT::i1" ]

[]

[ "<s>", "static", "int", "rs6000_hard_regno_mode_ok", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "last_regno", "=", "regno", "+", "rs6000_hard_regno_nregs", "[", "mode", "]", "[", "regno", "]", "-", "1", ";", "if", "(", "mode", "==", "PTImode", ")", "return", "(", "IN_RANGE", "(", "regno", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", "&&", "IN_RANGE", "(", "last_regno", ",", "FIRST_GPR_REGNO", ",", "LAST_GPR_REGNO", ")", "&&", "(", "(", "regno", "&", "1", ")", "==", "0", ")", ")", ";", "if", "(", "TARGET_VSX", "&&", "VSX_REGNO_P", "(", "regno", ")", "&&", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "||", "FLOAT128_VECTOR_P", "(", "mode", ")", "||", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", "||", "(", "TARGET_VSX_TIMODE", "&&", "mode", "==", "TImode", ")", "||", "(", "TARGET_VADDUQM", "&&", "mode", "==", "V1TImode", ")", ")", ")", "{", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "return", "FP_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "16", "&&", "!", "reg_addr", "[", "mode", "]", ".", "scalar_in_vmx_p", ")", "return", "0", ";", "return", "ALTIVEC_REGNO_P", "(", "last_regno", ")", ";", "}", "}", "if", "(", "INT_REGNO_P", "(", "regno", ")", ")", "return", "INT_REGNO_P", "(", "last_regno", ")", ";", "if", "(", "FP_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "FLOAT128_VECTOR_P", "(", "mode", ")", ")", "return", "false", ";", "if", "(", "SCALAR_FLOAT_MODE_P", "(", "mode", ")", "&&", "(", "mode", "!=", "TDmode", "||", "(", "regno", "%", "2", ")", "==", "0", ")", "&&", "FP_REGNO_P", "(", "last_regno", ")", ")", "return", "1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "GET_MODE_SIZE", "(", "mode", ")", "==", "UNITS_PER_FP_WORD", ")", "return", "1", ";", "if", "(", "PAIRED_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_PAIRED_FLOAT", "&&", "PAIRED_VECTOR_MODE", "(", "mode", ")", ")", "return", "1", ";", "return", "0", ";", "}", "if", "(", "CR_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "CA_REGNO_P", "(", "regno", ")", ")", "return", "mode", "==", "Pmode", "||", "mode", "==", "SImode", ";", "if", "(", "ALTIVEC_REGNO_P", "(", "regno", ")", ")", "return", "(", "VECTOR_MEM_ALTIVEC_OR_VSX_P", "(", "mode", ")", "||", "mode", "==", "V1TImode", ")", ";", "if", "(", "SPE_SIMD_REGNO_P", "(", "regno", ")", "&&", "TARGET_SPE", "&&", "SPE_VECTOR_MODE", "(", "mode", ")", ")", "return", "1", ";", "return", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ";", "}", "</s>" ]

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

[ "rs6000", "1", "1", "0", "16", "0", "2", "0", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "tree", "arm_valid_target_attribute_tree", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "struct", "cl_target_option", "cl_opts", ";", "if", "(", "!", "arm_valid_target_attribute_rec", "(", "args", ",", "opts", ")", ")", "return", "NULL_TREE", ";", "cl_target_option_save", "(", "&", "cl_opts", ",", "opts", ",", "opts_set", ")", ";", "arm_configure_build_target", "(", "&", "arm_active_target", ",", "&", "cl_opts", ",", "opts_set", ",", "false", ")", ";", "arm_option_check_internal", "(", "opts", ")", ";", "arm_option_reconfigure_globals", "(", ")", ";", "arm_options_perform_arch_sanity_checks", "(", ")", ";", "arm_option_override_internal", "(", "opts", ",", "opts_set", ")", ";", "return", "build_target_option_node", "(", "opts", ",", "opts_set", ")", ";", "}", "</s>" ]

[ "Return", "a", "TARGET_OPTION_NODE", "tree", "of", "the", "target", "options", "listed", "or", "NULL", "." ]

[ "arm" ]

[]

[ "<s>", "unsigned", "XCoreRegisterInfo", "::", "getRARegister", "(", ")", "const", "{", "return", "XCore", "::", "LR", ";", "}", "</s>" ]

[ "This", "method", "should", "return", "the", "register", "where", "the", "return", "address", "can", "be", "found", "." ]

[ "XCore", "XCore", "XCore::LR" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "!", "FuncAttributes", ".", "hasFnAttr", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Op", ".", "size", "(", ")", ">=", "16", "&&", "(", "!", "Subtarget", ".", "isUnalignedMem16Slow", "(", ")", "||", "Op", ".", "isAligned", "(", "Align", "(", "16", ")", ")", ")", ")", "{", "if", "(", "Op", ".", "size", "(", ")", ">=", "64", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "512", ")", ")", "{", "return", "Subtarget", ".", "hasBWI", "(", ")", "?", "MVT", "::", "v64i8", ":", "MVT", "::", "v16i32", ";", "}", "if", "(", "Op", ".", "size", "(", ")", ">=", "32", "&&", "Subtarget", ".", "hasAVX", "(", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "256", ")", ")", "{", "return", "MVT", "::", "v32i8", ";", "}", "if", "(", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "128", ")", ")", "return", "MVT", "::", "v16i8", ";", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", "&&", "(", "Subtarget", ".", "is64Bit", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "128", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "(", "(", "Op", ".", "isMemcpy", "(", ")", "&&", "!", "Op", ".", "isMemcpyStrSrc", "(", ")", ")", "||", "Op", ".", "isZeroMemset", "(", ")", ")", "&&", "Op", ".", "size", "(", ")", ">=", "8", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Op", ".", "size", "(", ")", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "16", "64", "512", "MVT::v64i8", "MVT::v16i32", "32", "256", "MVT::v32i8", "128", "MVT::v16i8", "128", "MVT::v4f32", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "riscv_new_address_profitable_p", "(", "rtx", "memref", ",", "rtx_insn", "*", "insn", ",", "rtx", "new_addr", ")", "{", "addr_space_t", "as", "=", "MEM_ADDR_SPACE", "(", "memref", ")", ";", "bool", "speed", "=", "optimize_bb_for_speed_p", "(", "BLOCK_FOR_INSN", "(", "insn", ")", ")", ";", "int", "old_cost", "=", "address_cost", "(", "XEXP", "(", "memref", ",", "0", ")", ",", "GET_MODE", "(", "memref", ")", ",", "as", ",", "speed", ")", ";", "int", "new_cost", "=", "address_cost", "(", "new_addr", ",", "GET_MODE", "(", "memref", ")", ",", "as", ",", "speed", ")", ";", "return", "new_cost", "<=", "old_cost", ";", "}", "</s>" ]

[ "Implement", "TARGET_NEW_ADDRESS_PROFITABLE_P", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "void", "riscv_init_builtins", "(", "void", ")", "{", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "riscv_builtins", ")", ";", "i", "++", ")", "{", "const", "struct", "riscv_builtin_description", "*", "d", "=", "&", "riscv_builtins", "[", "i", "]", ";", "if", "(", "d", "->", "avail", "(", ")", ")", "{", "tree", "type", "=", "riscv_build_function_type", "(", "d", "->", "prototype", ")", ";", "riscv_builtin_decls", "[", "i", "]", "=", "add_builtin_function", "(", "d", "->", "name", ",", "type", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "riscv_builtin_decl_index", "[", "d", "->", "icode", "]", "=", "i", ";", "}", "}", "}", "</s>" ]

[ "Implement", "TARGET_INIT_BUILTINS", "." ]

[ "riscv", "0" ]

[]