Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "TargetRegisterClass", "*", "SIRegisterInfo", "::", "getCFGStructurizerRegClass", "(", "MVT", "VT", ")", "const", "{", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "case", "MVT", "::", "i32", ":", "return", "&", "AMDGPU", "::", "VReg_32RegClass", ";", "}", "}", "</s>" ]

[ "get", "the", "register", "class", "of", "the", "specified", "type", "to", "use", "in", "the", "CFGStructurizer" ]

[ "R600", "SI", "MVT::i32" ]

[]

[ "<s>", "void", "MBlazeAsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "O", "<<", "\"\\t.frame\\t\"", "<<", "getRegisterName", "(", "stackReg", ")", "<<", "','", "<<", "stackSize", "<<", "','", "<<", "getRegisterName", "(", "returnReg", ")", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "MBlaze", "MBlaze", "\"\\t.frame\\t\"" ]

[]

[ "<s>", "bool", "arc_legitimate_pic_addr_p", "(", "rtx", "addr", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "CONST", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "!=", "CONST_INT", ")", "return", "false", ";", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "}", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "UNSPEC", "||", "XVECLEN", "(", "addr", ",", "0", ")", "!=", "1", ")", "return", "false", ";", "if", "(", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOT", "&&", "XINT", "(", "addr", ",", "1", ")", "!=", "ARC_UNSPEC_GOTOFF", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "SYMBOL_REF", "&&", "GET_CODE", "(", "XVECEXP", "(", "addr", ",", "0", ",", "0", ")", ")", "!=", "LABEL_REF", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "ADDR", "is", "a", "valid", "pic", "address", ".", "A", "valid", "pic", "address", "on", "arc", "should", "look", "like", "const", "(", "unspec", "(", "SYMBOL_REF/LABEL", ")", "(", "ARC_UNSPEC_GOTOFF/ARC_UNSPEC_GOT", ")", ")" ]

[ "arc", "0", "1", "0", "0", "1", "1", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "enableAggressiveFMAFusion", "(", "EVT", "VT", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "always", "benefits", "from", "combining", "into", "FMA", "for", "a", "given", "value", "type", "." ]

[ "NVPTX" ]

[]

[ "<s>", "MCOperand", "SystemZMCInstLower", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "return", "MCOperand", "(", ")", ";", "return", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "return", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "0", ")", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "{", "StringRef", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "case", "MachineOperand", "::", "MO_JumpTableIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetJTISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "0", ")", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "case", "MachineOperand", "::", "MO_BlockAddress", ":", "{", "const", "BlockAddress", "*", "BA", "=", "MO", ".", "getBlockAddress", "(", ")", ";", "return", "lowerSymbolOperand", "(", "MO", ",", "AsmPrinter", ".", "GetBlockAddressSymbol", "(", "BA", ")", ",", "MO", ".", "getOffset", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "\"unknown operand type\"", "0", "0" ]

[]

[ "<s>", "tree", "aarch64_resolve_overloaded_builtin_general", "(", "location_t", "loc", ",", "tree", "function", ",", "void", "*", "pass_params", ")", "{", "unsigned", "int", "fcode", "=", "AARCH64_BUILTIN_SUBCODE", "(", "function", ")", ";", "if", "(", "fcode", ">=", "AARCH64_MEMTAG_BUILTIN_START", "&&", "fcode", "<=", "AARCH64_MEMTAG_BUILTIN_END", ")", "return", "aarch64_resolve_overloaded_memtag", "(", "loc", ",", "function", ",", "pass_params", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Called", "at", "aarch64_resolve_overloaded_builtin", "in", "aarch64-c.cc", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "ARMScalarTargetTransformImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ")", "const", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "Bits", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "Bits", "==", "0", "||", "Bits", ">", "32", ")", "return", "4", ";", "int32_t", "SImmVal", "=", "Imm", ".", "getSExtValue", "(", ")", ";", "uint32_t", "ZImmVal", "=", "Imm", ".", "getZExtValue", "(", ")", ";", "if", "(", "!", "Subtarget", "->", "isThumb", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getSOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "Subtarget", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "else", "if", "(", "Subtarget", "->", "isThumb2", "(", ")", ")", "{", "if", "(", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "65536", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "ZImmVal", ")", "!=", "-", "1", ")", "||", "(", "ARM_AM", "::", "getT2SOImmVal", "(", "~", "ZImmVal", ")", "!=", "-", "1", ")", ")", "return", "1", ";", "return", "Subtarget", "->", "hasV6T2Ops", "(", ")", "?", "2", ":", "3", ";", "}", "else", "{", "if", "(", "SImmVal", ">=", "0", "&&", "SImmVal", "<", "256", ")", "return", "1", ";", "if", "(", "(", "~", "ZImmVal", "<", "256", ")", "||", "ARM_AM", "::", "isThumbImmShiftedVal", "(", "ZImmVal", ")", ")", "return", "2", ";", "return", "3", ";", "}", "return", "2", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "ARM", "ARM", "0", "32", "4", "0", "65536", "ARM_AM::getSOImmVal", "1", "ARM_AM::getSOImmVal", "1", "1", "2", "3", "0", "65536", "ARM_AM::getT2SOImmVal", "1", "ARM_AM::getT2SOImmVal", "1", "1", "2", "3", "0", "256", "1", "256", "ARM_AM::isThumbImmShiftedVal", "2", "3", "2" ]

[]

[ "<s>", "static", "inline", "int", "isa_base_compat_p", "(", "const", "struct", "loongarch_isa", "*", "set1", ",", "const", "struct", "loongarch_isa", "*", "set2", ")", "{", "switch", "(", "set2", "->", "base", ")", "{", "case", "ISA_BASE_LA64V100", ":", "return", "(", "set1", "->", "base", "==", "ISA_BASE_LA64V100", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "set2", "is", "a", "subset", "of", "set1", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "unsigned", "int", "aarch64_unspec_cond_code", "(", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "NE", ":", "return", "UNSPEC_COND_NE", ";", "case", "EQ", ":", "return", "UNSPEC_COND_EQ", ";", "case", "LT", ":", "return", "UNSPEC_COND_LT", ";", "case", "GT", ":", "return", "UNSPEC_COND_GT", ";", "case", "LE", ":", "return", "UNSPEC_COND_LE", ";", "case", "GE", ":", "return", "UNSPEC_COND_GE", ";", "case", "LTU", ":", "return", "UNSPEC_COND_LO", ";", "case", "GTU", ":", "return", "UNSPEC_COND_HI", ";", "case", "LEU", ":", "return", "UNSPEC_COND_LS", ";", "case", "GEU", ":", "return", "UNSPEC_COND_HS", ";", "case", "UNORDERED", ":", "return", "UNSPEC_COND_UO", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "UNSPEC_COND_", "*", "code", "for", "comparison", "CODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "unsigned", "int", "m32r_compute_frame_size", "(", "poly_int64", "size", ")", "{", "unsigned", "int", "regno", ";", "unsigned", "int", "total_size", ",", "var_size", ",", "args_size", ",", "pretend_size", ",", "extra_size", ";", "unsigned", "int", "reg_size", ";", "unsigned", "int", "gmask", ";", "enum", "m32r_function_type", "fn_type", ";", "int", "interrupt_p", ";", "int", "pic_reg_used", "=", "flag_pic", "&&", "(", "crtl", "->", "uses_pic_offset_table", "|", "crtl", "->", "profile", ")", ";", "var_size", "=", "M32R_STACK_ALIGN", "(", "size", ")", ";", "args_size", "=", "M32R_STACK_ALIGN", "(", "crtl", "->", "outgoing_args_size", ")", ";", "pretend_size", "=", "crtl", "->", "args", ".", "pretend_args_size", ";", "extra_size", "=", "FIRST_PARM_OFFSET", "(", "0", ")", ";", "total_size", "=", "extra_size", "+", "pretend_size", "+", "args_size", "+", "var_size", ";", "reg_size", "=", "0", ";", "gmask", "=", "0", ";", "fn_type", "=", "m32r_compute_function_type", "(", "current_function_decl", ")", ";", "interrupt_p", "=", "M32R_INTERRUPT_P", "(", "fn_type", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "M32R_MAX_INT_REGS", ";", "regno", "++", ")", "{", "if", "(", "MUST_SAVE_REGISTER", "(", "regno", ",", "interrupt_p", ")", "||", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "pic_reg_used", ")", ")", "{", "reg_size", "+=", "UNITS_PER_WORD", ";", "gmask", "|=", "1", "<<", "regno", ";", "}", "}", "current_frame_info", ".", "save_fp", "=", "MUST_SAVE_FRAME_POINTER", ";", "current_frame_info", ".", "save_lr", "=", "MUST_SAVE_RETURN_ADDR", "||", "pic_reg_used", ";", "reg_size", "+=", "(", "(", "current_frame_info", ".", "save_fp", "+", "current_frame_info", ".", "save_lr", ")", "*", "UNITS_PER_WORD", ")", ";", "total_size", "+=", "reg_size", ";", "total_size", "=", "M32R_STACK_ALIGN", "(", "total_size", ")", ";", "current_frame_info", ".", "total_size", "=", "total_size", ";", "current_frame_info", ".", "extra_size", "=", "extra_size", ";", "current_frame_info", ".", "pretend_size", "=", "pretend_size", ";", "current_frame_info", ".", "var_size", "=", "var_size", ";", "current_frame_info", ".", "args_size", "=", "args_size", ";", "current_frame_info", ".", "reg_size", "=", "reg_size", ";", "current_frame_info", ".", "gmask", "=", "gmask", ";", "current_frame_info", ".", "initialized", "=", "reload_completed", ";", "return", "total_size", ";", "}", "</s>" ]

[ "Return", "the", "bytes", "needed", "to", "compute", "the", "frame", "pointer", "from", "the", "current", "stack", "pointer", ".", "SIZE", "is", "the", "size", "needed", "for", "local", "variables", "." ]

[ "m32r", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"ARM IR optimizations\"", ";", "}", "</s>" ]

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

[ "ARM", "\"ARM IR optimizations\"" ]

[]

[ "<s>", "int", "eligible_for_sibcall_delay", "(", "rtx_insn", "*", "trial", ")", "{", "rtx", "pat", ";", "if", "(", "get_attr_in_branch_delay", "(", "trial", ")", "==", "IN_BRANCH_DELAY_FALSE", ")", "return", "0", ";", "if", "(", "!", "NONJUMP_INSN_P", "(", "trial", ")", ")", "return", "0", ";", "pat", "=", "PATTERN", "(", "trial", ")", ";", "if", "(", "sparc_leaf_function_p", "||", "TARGET_FLAT", ")", "{", "if", "(", "LEAF_SIBCALL_SLOT_RESERVED_P", ")", "return", "0", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "Pmode", ",", "1", ")", ",", "pat", ")", ")", "return", "0", ";", "return", "1", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "pat", ")", ")", "!=", "REG", "||", "(", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ">=", "8", "&&", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", "<", "24", ")", "||", "!", "SPARC_INT_REG_P", "(", "REGNO", "(", "SET_DEST", "(", "pat", ")", ")", ")", ")", "return", "0", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "Pmode", ",", "15", ")", ",", "pat", ")", ")", "return", "0", ";", "return", "eligible_for_restore_insn", "(", "trial", ",", "false", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "TRIAL", "can", "go", "into", "the", "sibling", "call", "'s", "delay", "slot", "." ]

[ "sparc", "0", "0", "0", "1", "0", "1", "0", "8", "24", "0", "15", "0" ]

[]

[ "<s>", "static", "rtx_insn", "*", "emit_window_save", "(", "rtx", "increment", ")", "{", "rtx_insn", "*", "insn", "=", "emit_insn", "(", "gen_window_save", "(", "increment", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ",", "gen_rtx_REG", "(", "Pmode", ",", "INCOMING_RETURN_ADDR_REGNUM", ")", ")", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_WINDOW_SAVE", ",", "const0_rtx", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_DEF_CFA", ",", "plus_constant", "(", "Pmode", ",", "hard_frame_pointer_rtx", ",", "INCOMING_FRAME_SP_OFFSET", ")", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Emit", "a", "window_save", "insn", "." ]

[ "sparc", "1" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "!", "getARMSubtarget", "(", ")", ".", "isThumb1Only", "(", ")", ")", "PM", "->", "add", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "getARMSubtarget", "(", ")", ".", "isCortexA9", "(", ")", ")", "PM", "->", "add", "(", "createMLxExpansionPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

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

[]

[ "<s>", "void", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "Parser", ".", "Warning", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "PowerPC" ]

[]

[ "<s>", "virtual", "const", "Tile64Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

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

[ "Tile64" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildIndirectRead", "(", "MachineBasicBlock", "*", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "ValueReg", ",", "unsigned", "Address", ",", "unsigned", "OffsetReg", ",", "unsigned", "AddrChan", ")", "const", "{", "unsigned", "AddrReg", ";", "switch", "(", "AddrChan", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Invalid Channel\"", ")", ";", "case", "0", ":", "AddrReg", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "1", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_YRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "2", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_ZRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "case", "3", ":", "AddrReg", "=", "AMDGPU", "::", "R600_Addr_WRegClass", ".", "getRegister", "(", "Address", ")", ";", "break", ";", "}", "MachineInstr", "*", "MOVA", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOVA_INT_eg", ",", "AMDGPU", "::", "AR_X", ",", "OffsetReg", ")", ";", "setImmOperand", "(", "MOVA", ",", "AMDGPU", "::", "OpName", "::", "write", ",", "0", ")", ";", "MachineInstrBuilder", "Mov", "=", "buildDefaultInstruction", "(", "*", "MBB", ",", "I", ",", "AMDGPU", "::", "MOV", ",", "ValueReg", ",", "AddrReg", ")", ".", "addReg", "(", "AMDGPU", "::", "AR_X", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Kill", ")", ";", "setImmOperand", "(", "Mov", ",", "AMDGPU", "::", "OpName", "::", "src0_rel", ",", "1", ")", ";", "return", "Mov", ";", "}", "</s>" ]

[ "Build", "instruction", "(", "s", ")", "for", "an", "indirect", "register", "read", "." ]

[ "AMDGPU", "R600", "\"Invalid Channel\"", "0", "AMDGPU::R600_AddrRegClass", "1", "AMDGPU::R600_Addr_YRegClass", "2", "AMDGPU::R600_Addr_ZRegClass", "3", "AMDGPU::R600_Addr_WRegClass", "AMDGPU::MOVA_INT_eg", "AMDGPU::AR_X", "AMDGPU::OpName", "0", "AMDGPU::MOV", "AMDGPU::AR_X", "AMDGPU::OpName", "1" ]

[]

[ "<s>", "unsigned", "int", "mips_hard_regno_nregs", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "ST_REG_P", "(", "regno", ")", ")", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "3", ")", "/", "4", ")", ";", "else", "if", "(", "!", "FP_REG_P", "(", "regno", ")", ")", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "else", "return", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_FPREG", "-", "1", ")", "/", "UNITS_PER_FPREG", ")", ";", "}", "</s>" ]

[ "Implement", "HARD_REGNO_NREGS", "." ]

[ "mips", "3", "4", "1", "1" ]

[]

[ "<s>", "insn_code", "function_expander", "::", "direct_optab_handler_for_sign", "(", "optab", "signed_op", ",", "optab", "unsigned_op", ",", "unsigned", "int", "suffix_i", ",", "machine_mode", "mode", ")", "{", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "vector_mode", "(", "suffix_i", ")", ";", "optab", "op", "=", "type_suffix", "(", "suffix_i", ")", ".", "unsigned_p", "?", "unsigned_op", ":", "signed_op", ";", "return", "::", "direct_optab_handler", "(", "op", ",", "mode", ")", ";", "}", "</s>" ]

[ "Choose", "between", "signed", "and", "unsigned", "direct", "optabs", "SIGNED_OP", "and", "UNSIGNED_OP", "based", "on", "the", "signedness", "of", "type", "suffix", "SUFFIX_I", ",", "then", "pick", "the", "appropriate", "optab", "handler", "for", "the", "mode", ".", "Use", "MODE", "as", "the", "mode", "if", "given", ",", "otherwise", "use", "the", "mode", "of", "type", "suffix", "SUFFIX_I", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AArch64O0PreLegalizerCombiner", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "FailedISel", ")", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "GISelKnownBits", "*", "KB", "=", "&", "getAnalysis", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ".", "get", "(", "MF", ")", ";", "AArch64O0PreLegalizerCombinerInfo", "PCInfo", "(", "false", ",", "F", ".", "hasOptSize", "(", ")", ",", "F", ".", "hasMinSize", "(", ")", ",", "KB", ",", "nullptr", ")", ";", "Combiner", "C", "(", "PCInfo", ",", "&", "TPC", ")", ";", "return", "C", ".", "combineMachineInstrs", "(", "MF", ",", "nullptr", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "cris_frame_pointer_required", "(", "void", ")", "{", "return", "!", "crtl", "->", "sp_is_unchanging", ";", "}", "</s>" ]

[ "Implement", "TARGET_FRAME_POINTER_REQUIRED", ".", "Really", "only", "needed", "if", "the", "stack", "frame", "has", "variable", "length", "(", "alloca", "or", "variable", "sized", "local", "arguments", "(", "GNU", "C", "extension", ")", ".", "See", "PR39499", "and", "PR38609", "for", "the", "reason", "this", "is", "n't", "just", "0", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "isPredicated", "(", ")", "const", "{", "return", "Predicated", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "already", "predicated", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "s", ".", "Error", "=", "CHECK_SUCCESS", ";", "s", ".", "Warning", "=", "CHECK_SUCCESS", ";", "s", ".", "ShuffleError", "=", "HexagonShuffler", "::", "SHUFFLE_SUCCESS", ";", "s", ".", "Register", "=", "Hexagon", "::", "NoRegister", ";", "}", "</s>" ]

[ "Reset", "an", "existing", "scalar", "value", "for", "Def", "and", "a", "given", "Instance", "." ]

[ "Hexagon", "Hexagon", "Hexagon::NoRegister" ]

[]

[ "<s>", "static", "void", "m68k_override_options_after_change", "(", "void", ")", "{", "if", "(", "m68k_sched_cpu", "==", "CPU_UNKNOWN", ")", "{", "flag_schedule_insns", "=", "0", ";", "flag_schedule_insns_after_reload", "=", "0", ";", "flag_modulo_sched", "=", "0", ";", "flag_live_range_shrinkage", "=", "0", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE", "." ]

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

[]

[ "<s>", "bool", "X86TargetLowering", "::", "allowTruncateForTailCall", "(", "Type", "*", "Ty1", ",", "Type", "*", "Ty2", ")", "const", "{", "if", "(", "!", "Ty1", "->", "isIntegerTy", "(", ")", "||", "!", "Ty2", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isTypeLegal", "(", "EVT", "::", "getEVT", "(", "Ty1", ")", ")", ")", "return", "false", ";", "assert", "(", "Ty1", "->", "getPrimitiveSizeInBits", "(", ")", "<=", "64", "&&", "\"i128 is probably not a noop\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "truncation", "from", "FromTy", "to", "ToTy", "is", "permitted", "when", "deciding", "whether", "a", "call", "is", "in", "tail", "position", "." ]

[ "X86", "X86", "64", "\"i128 is probably not a noop\"" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "isFrameOffsetLegal", "(", "const", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "unsigned", "FIOperandNum", "=", "0", ";", "while", "(", "!", "MI", "->", "getOperand", "(", "FIOperandNum", ")", ".", "isFI", "(", ")", ")", "{", "++", "FIOperandNum", ";", "assert", "(", "FIOperandNum", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "OffsetOperandNo", "=", "getOffsetONFromFION", "(", "*", "MI", ",", "FIOperandNum", ")", ";", "Offset", "+=", "MI", "->", "getOperand", "(", "OffsetOperandNo", ")", ".", "getImm", "(", ")", ";", "return", "MI", "->", "getOpcode", "(", ")", "==", "PPC", "::", "DBG_VALUE", "||", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "STACKMAP", "||", "MI", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "PATCHPOINT", "||", "(", "isInt", "<", "16", ">", "(", "Offset", ")", "&&", "(", "!", "usesIXAddr", "(", "*", "MI", ")", "||", "(", "Offset", "&", "3", ")", "==", "0", ")", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "a", "given", "base", "register", "plus", "offset", "immediate", "is", "encodable", "to", "resolve", "a", "frame", "index", "." ]

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

[]

[ "<s>", "MCSectionXCore", "*", "MCSectionXCore", "::", "Create", "(", "const", "StringRef", "&", "Section", ",", "unsigned", "Type", ",", "unsigned", "Flags", ",", "SectionKind", "K", ",", "bool", "isExplicit", ",", "MCContext", "&", "Ctx", ")", "{", "return", "new", "(", "Ctx", ")", "MCSectionXCore", "(", "Section", ",", "Type", ",", "Flags", ",", "K", ",", "isExplicit", ")", ";", "}", "</s>" ]

[ "Construct", "a", "unary", "instruction", ",", "given", "the", "opcode", "and", "an", "operand", "." ]

[ "XCore", "XCore", "XCore", "XCore" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isUnconditionalTailCall", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "TCRETURNdi", ":", "case", "X86", "::", "TCRETURNri", ":", "case", "X86", "::", "TCRETURNmi", ":", "case", "X86", "::", "TCRETURNdi64", ":", "case", "X86", "::", "TCRETURNri64", ":", "case", "X86", "::", "TCRETURNmi64", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "MI", "is", "an", "unconditional", "tail", "call", "." ]

[ "X86", "X86", "X86::TCRETURNdi", "X86::TCRETURNri", "X86::TCRETURNmi", "X86::TCRETURNdi64", "X86::TCRETURNri64", "X86::TCRETURNmi64" ]

[]

[ "<s>", "static", "int", "mips_issue_rate", "(", "void", ")", "{", "switch", "(", "mips_tune", ")", "{", "case", "PROCESSOR_R4130", ":", "case", "PROCESSOR_R5400", ":", "case", "PROCESSOR_R5500", ":", "case", "PROCESSOR_R7000", ":", "case", "PROCESSOR_R9000", ":", "return", "2", ";", "case", "PROCESSOR_SB1", ":", "return", "3", ";", "default", ":", "return", "1", ";", "}", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "that", "can", "be", "issued", "per", "cycle", "." ]

[ "mips", "2", "3", "1" ]

[]

[ "<s>", "ISD", "::", "NodeType", "getExtendForAtomicOps", "(", ")", "const", "override", "{", "return", "ISD", "::", "SIGN_EXTEND", ";", "}", "</s>" ]

[ "Returns", "how", "the", "platform", "'s", "atomic", "operations", "are", "extended", "(", "ZERO_EXTEND", ",", "SIGN_EXTEND", ",", "or", "ANY_EXTEND", ")", "." ]

[ "Mips", "ISD::NodeType", "ISD::SIGN_EXTEND" ]

[]

[ "<s>", "void", "HexagonAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "std", "::", "vector", "<", "MachineInstr", "const", "*", ">", "BundleMIs", ";", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "MII", "=", "MI", ";", "++", "MII", ";", "unsigned", "int", "IgnoreCount", "=", "0", ";", "while", "(", "MII", "!=", "MBB", "->", "end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ")", "{", "const", "MachineInstr", "*", "MInst", "=", "MII", ";", "if", "(", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "DBG_VALUE", "||", "MInst", "->", "getOpcode", "(", ")", "==", "TargetOpcode", "::", "IMPLICIT_DEF", ")", "{", "IgnoreCount", "++", ";", "++", "MII", ";", "continue", ";", "}", "BundleMIs", ".", "push_back", "(", "MInst", ")", ";", "++", "MII", ";", "}", "unsigned", "Size", "=", "BundleMIs", ".", "size", "(", ")", ";", "assert", "(", "(", "Size", "+", "IgnoreCount", ")", "==", "MI", "->", "getBundleSize", "(", ")", "&&", "\"Corrupt Bundle!\"", ")", ";", "for", "(", "unsigned", "Index", "=", "0", ";", "Index", "<", "Size", ";", "Index", "++", ")", "{", "MCInst", "MCI", ";", "HexagonLowerToMC", "(", "BundleMIs", "[", "Index", "]", ",", "MCI", ",", "*", "this", ")", ";", "HexagonMCInstrInfo", "::", "AppendImplicitOperands", "(", "MCI", ")", ";", "HexagonMCInstrInfo", "::", "setPacketBegin", "(", "MCI", ",", "Index", "==", "0", ")", ";", "HexagonMCInstrInfo", "::", "setPacketEnd", "(", "MCI", ",", "Index", "==", "(", "Size", "-", "1", ")", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "MCI", ")", ";", "}", "}", "else", "{", "MCInst", "MCI", ";", "HexagonLowerToMC", "(", "MI", ",", "MCI", ",", "*", "this", ")", ";", "HexagonMCInstrInfo", "::", "AppendImplicitOperands", "(", "MCI", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "ENDLOOP0", ")", "{", "HexagonMCInstrInfo", "::", "setPacketBegin", "(", "MCI", ",", "true", ")", ";", "HexagonMCInstrInfo", "::", "setPacketEnd", "(", "MCI", ",", "true", ")", ";", "}", "EmitToStreamer", "(", "OutStreamer", ",", "MCI", ")", ";", "}", "return", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "0", "\"Corrupt Bundle!\"", "0", "Hexagon", "Hexagon", "Hexagon", "0", "Hexagon", "1", "Hexagon", "Hexagon", "Hexagon::ENDLOOP0", "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "rtx", "ix86_get_drap_rtx", "(", "void", ")", "{", "if", "(", "ix86_force_drap", "||", "(", "(", "cfun", "->", "machine", "->", "outgoing_args_on_stack", "||", "crtl", "->", "sp_is_clobbered_by_asm", ")", "&&", "!", "ACCUMULATE_OUTGOING_ARGS", ")", ")", "crtl", "->", "need_drap", "=", "true", ";", "if", "(", "stack_realign_drap", ")", "{", "unsigned", "int", "regno", "=", "find_drap_reg", "(", ")", ";", "rtx", "drap_vreg", ";", "rtx", "arg_ptr", ";", "rtx_insn", "*", "seq", ",", "*", "insn", ";", "arg_ptr", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "crtl", "->", "drap_reg", "=", "arg_ptr", ";", "start_sequence", "(", ")", ";", "drap_vreg", "=", "copy_to_reg", "(", "arg_ptr", ")", ";", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "insn", "=", "emit_insn_before", "(", "seq", ",", "NEXT_INSN", "(", "entry_of_function", "(", ")", ")", ")", ";", "if", "(", "!", "optimize", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_SET_VDRAP", ",", "drap_vreg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "return", "drap_vreg", ";", "}", "else", "return", "NULL", ";", "}", "</s>" ]

[ "Handle", "the", "TARGET_GET_DRAP_RTX", "hook", ".", "Return", "NULL", "if", "no", "DRAP", "is", "needed", "or", "an", "rtx", "for", "DRAP", "otherwise", "." ]

[ "i386", "1" ]

[]

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

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

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

[]

[ "<s>", "static", "void", "mips_select_rtx_section", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "if", "(", "TARGET_MIPS16", ")", "{", "function_section", "(", "current_function_decl", ")", ";", "}", "else", "if", "(", "TARGET_EMBEDDED_DATA", ")", "{", "mergeable_constant_section", "(", "mode", ",", "align", ",", "0", ")", ";", "}", "else", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "(", "unsigned", ")", "mips_section_threshold", "&&", "mips_section_threshold", ">", "0", ")", "named_section", "(", "0", ",", "\".sdata\"", ",", "0", ")", ";", "else", "if", "(", "flag_pic", "&&", "symbolic_expression_p", "(", "x", ")", ")", "named_section", "(", "0", ",", "\".data.rel.ro\"", ",", "3", ")", ";", "else", "mergeable_constant_section", "(", "mode", ",", "align", ",", "0", ")", ";", "}", "}", "</s>" ]

[ "Choose", "the", "section", "to", "use", "for", "the", "constant", "rtx", "expression", "X", "that", "has", "mode", "MODE", "." ]

[ "mips", "0", "0", "0", "\".sdata\"", "0", "0", "\".data.rel.ro\"", "3", "0" ]

[]

[ "<s>", "void", "ARCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "ARCInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "ARCSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "ARCFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "ObjSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getStackSize", "(", ")", ";", "int", "LocalFrameSize", "=", "MF", ".", "getFrameInfo", "(", ")", ".", "getLocalFrameSize", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MI", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"ObjSize : \"", "<<", "ObjSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"LocalFrameSize : \"", "<<", "LocalFrameSize", "<<", "\"\\n\"", ")", ";", "(", "void", ")", "LocalFrameSize", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "Register", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Offset", "=", "StackSize", "+", "Offset", ";", "if", "(", "FrameIndex", ">=", "0", ")", "assert", "(", "(", "Offset", ">=", "0", "&&", "Offset", "<", "StackSize", ")", "&&", "\"SP Offset not in bounds.\"", ")", ";", "}", "else", "{", "if", "(", "FrameIndex", ">=", "0", ")", "{", "assert", "(", "(", "Offset", "<", "0", "&&", "-", "Offset", "<=", "StackSize", ")", "&&", "\"FP Offset not in bounds.\"", ")", ";", "}", "}", "ReplaceFrameIndex", "(", "II", ",", "TII", ",", "Reg", ",", "getFrameRegister", "(", "MF", ")", ",", "Offset", ",", "StackSize", ",", "ObjSize", ",", "RS", ",", "SPAdj", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "0", "\"Unexpected\"", "ARC", "ARC", "ARC", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"ObjSize : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "\"LocalFrameSize : \"", "\"\\n\"", "1", "1", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "0", "ARC::GPR32RegClass", "\"Unexpected register operand\"", "0", "0", "\"SP Offset not in bounds.\"", "0", "0", "\"FP Offset not in bounds.\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldSinkOperands", "(", "Instruction", "*", "I", ",", "SmallVectorImpl", "<", "Use", "*", ">", "&", "Ops", ")", "const", "{", "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Add", ":", "{", "if", "(", "!", "areExtractExts", "(", "I", "->", "getOperand", "(", "0", ")", ",", "I", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "if", "(", "!", "Subtarget", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "auto", "IsSinker", "=", "[", "]", "(", "Instruction", "*", "I", ",", "int", "Operand", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "ICmp", ":", "return", "true", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "Operand", "==", "1", ";", "default", ":", "return", "false", ";", "}", "}", ";", "int", "Op", "=", "0", ";", "if", "(", "!", "isa", "<", "ShuffleVectorInst", ">", "(", "I", "->", "getOperand", "(", "Op", ")", ")", ")", "Op", "=", "1", ";", "if", "(", "!", "IsSinker", "(", "I", ",", "Op", ")", ")", "return", "false", ";", "if", "(", "!", "match", "(", "I", "->", "getOperand", "(", "Op", ")", ",", "m_ShuffleVector", "(", "m_InsertElement", "(", "m_Undef", "(", ")", ",", "m_Value", "(", ")", ",", "m_ZeroInt", "(", ")", ")", ",", "m_Undef", "(", ")", ",", "m_Zero", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "Instruction", "*", "Shuffle", "=", "cast", "<", "Instruction", ">", "(", "I", "->", "getOperand", "(", "Op", ")", ")", ";", "for", "(", "Use", "&", "U", ":", "Shuffle", "->", "uses", "(", ")", ")", "{", "Instruction", "*", "Insn", "=", "cast", "<", "Instruction", ">", "(", "U", ".", "getUser", "(", ")", ")", ";", "if", "(", "!", "IsSinker", "(", "Insn", ",", "U", ".", "getOperandNo", "(", ")", ")", ")", "return", "false", ";", "}", "Ops", ".", "push_back", "(", "&", "Shuffle", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "Op", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "sinking", "I", "'s", "operands", "to", "the", "same", "basic", "block", "as", "I", "is", "profitable", ",", "e.g", "." ]

[ "ARM", "ARM", "0", "1", "0", "1", "1", "0", "1", "0" ]

[]

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

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

[ "WebAssembly" ]

[]

[ "<s>", "bool", "MBlazeIntrinsicInfo", "::", "isOverloaded", "(", "unsigned", "IntrID", ")", "const", "{", "if", "(", "IntrID", "==", "0", ")", "return", "false", ";", "unsigned", "id", "=", "IntrID", "-", "Intrinsic", "::", "num_intrinsics", "+", "1", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "intrinsic", "can", "be", "overloaded", "." ]

[ "MBlaze", "MBlaze", "0", "Intrinsic::num_intrinsics", "1" ]

[]

[ "<s>", "void", "HexagonSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Src", ",", "SUnit", "*", "Dst", ",", "SDep", "&", "Dep", ")", "const", "{", "MachineInstr", "*", "SrcInst", "=", "Src", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "DstInst", "=", "Dst", "->", "getInstr", "(", ")", ";", "if", "(", "!", "Src", "->", "isInstr", "(", ")", "||", "!", "Dst", "->", "isInstr", "(", ")", ")", "return", ";", "const", "HexagonInstrInfo", "*", "QII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "getInstrInfo", "(", ")", ")", ";", "if", "(", "QII", "->", "canExecuteInBundle", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "if", "(", "!", "hasV60TOps", "(", ")", ")", "return", ";", "if", "(", "QII", "->", "isPostIncrement", "(", "*", "SrcInst", ")", "&&", "Dep", ".", "isAssignedRegDep", "(", ")", ")", "{", "if", "(", "SrcInst", "->", "mayStore", "(", ")", ")", "return", ";", "if", "(", "Dep", ".", "getReg", "(", ")", "!=", "SrcInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "return", ";", "}", "else", "if", "(", "QII", "->", "isPostIncrement", "(", "*", "DstInst", ")", "&&", "Dep", ".", "getKind", "(", ")", "==", "SDep", "::", "Anti", ")", "{", "if", "(", "DstInst", "->", "mayStore", "(", ")", ")", "return", ";", "if", "(", "Dep", ".", "getReg", "(", ")", "!=", "DstInst", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ")", "return", ";", "}", "else", "if", "(", "QII", "->", "isPostIncrement", "(", "*", "DstInst", ")", "&&", "DstInst", "->", "mayStore", "(", ")", "&&", "Dep", ".", "isAssignedRegDep", "(", ")", ")", "{", "MachineOperand", "&", "Op", "=", "DstInst", "->", "getOperand", "(", "DstInst", "->", "getNumOperands", "(", ")", "-", "1", ")", ";", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Dep", ".", "getReg", "(", ")", "!=", "Op", ".", "getReg", "(", ")", ")", "return", ";", "}", "if", "(", "useBSBScheduling", "(", ")", "&&", "SrcInst", "->", "isPHI", "(", ")", ")", "{", "changePhiLatency", "(", "*", "SrcInst", ",", "Dst", ",", "Dep", ")", ";", "return", ";", "}", "if", "(", "DstInst", "->", "isRegSequence", "(", ")", "&&", "Dst", "->", "NumSuccs", "==", "1", ")", "DstInst", "=", "Dst", "->", "Succs", "[", "0", "]", ".", "getSUnit", "(", ")", "->", "getInstr", "(", ")", ";", "if", "(", "EnableDotCurSched", "&&", "QII", "->", "isToBeScheduledASAP", "(", "*", "SrcInst", ",", "*", "DstInst", ")", "&&", "isBestZeroLatency", "(", "Src", ",", "Dst", ",", "QII", ")", ")", "{", "Dep", ".", "setLatency", "(", "0", ")", ";", "return", ";", "}", "updateLatency", "(", "*", "SrcInst", ",", "*", "DstInst", ",", "Dep", ")", ";", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "0", "0", "0", "1", "1", "0", "0" ]

[]

[ "<s>", "enum", "cris_symbol_type", "cris_symbol_type_of", "(", "const_rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "SYMBOL_REF", ":", "return", "flag_pic", "?", "(", "SYMBOL_REF_LOCAL_P", "(", "x", ")", "?", "cris_rel_symbol", ":", "cris_got_symbol", ")", ":", "cris_offsettable_symbol", ";", "case", "LABEL_REF", ":", "return", "flag_pic", "?", "cris_rel_symbol", ":", "cris_offsettable_symbol", ";", "case", "CONST", ":", "return", "cris_symbol_type_of", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "case", "PLUS", ":", "case", "MINUS", ":", "{", "enum", "cris_symbol_type", "t1", "=", "cris_symbol_type_of", "(", "XEXP", "(", "x", ",", "0", ")", ")", ";", "enum", "cris_symbol_type", "t2", "=", "cris_symbol_type_of", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "gcc_assert", "(", "t1", "==", "cris_no_symbol", "||", "t2", "==", "cris_no_symbol", ")", ";", "if", "(", "t1", "==", "cris_got_symbol", "||", "t2", "==", "cris_got_symbol", ")", "return", "cris_got_symbol_needing_fixup", ";", "return", "t1", "!=", "cris_no_symbol", "?", "t1", ":", "t2", ";", "}", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "cris_no_symbol", ";", "case", "UNSPEC", ":", "return", "cris_unspec", ";", "default", ":", "fatal_insn", "(", "\"unrecognized supposed constant\"", ",", "x", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "find", "the", "right", "symbol-type", "to", "generate", ",", "given", "the", "original", "(", "non-PIC", ")", "representation", "." ]

[ "cris", "0", "0", "1", "\"unrecognized supposed constant\"" ]

[]

[ "<s>", "static", "const", "char", "*", "getName", "(", ")", "{", "return", "DEBUG_TYPE", ";", "}", "</s>" ]

[ "Return", "a", "string", "with", "the", "name", "of", "the", "plan", "and", "the", "applicable", "VFs", "and", "UFs", "." ]

[ "MOS" ]

[]

[ "<s>", "void", "SPUHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"SPUHazardRecognizer::AdvanceCycle\\n\"", ")", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "CellSPU", "SPU", "\"SPUHazardRecognizer::AdvanceCycle\\n\"" ]

[]

[ "<s>", "int", "includes_rldic_lshift_p", "(", "rtx", "shiftop", ",", "rtx", "andop", ")", "{", "if", "(", "GET_CODE", "(", "andop", ")", "==", "CONST_INT", ")", "{", "unsigned", "HOST_WIDE_INT", "c", ",", "lsb", ",", "shift_mask", ";", "c", "=", "INTVAL", "(", "andop", ")", ";", "if", "(", "c", "==", "0", "||", "c", "==", "HOST_WIDE_INT_M1U", ")", "return", "0", ";", "shift_mask", "=", "HOST_WIDE_INT_M1U", ";", "shift_mask", "<<=", "INTVAL", "(", "shiftop", ")", ";", "lsb", "=", "c", "&", "-", "c", ";", "if", "(", "-", "lsb", "!=", "shift_mask", ")", "return", "0", ";", "c", "=", "~", "c", ";", "c", "&=", "-", "lsb", ";", "lsb", "=", "c", "&", "-", "c", ";", "return", "c", "==", "-", "lsb", ";", "}", "else", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "ANDOP", "is", "a", "mask", "suitable", "for", "use", "with", "an", "rldic", "insn", "to", "perform", "a", "left", "shift", ".", "It", "must", "have", "exactly", "SHIFTOP", "least", "significant", "0", "'s", ",", "then", "one", "or", "more", "1", "'s", ",", "then", "zero", "or", "more", "0", "'s", "." ]

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

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getCacheLineSize", "(", ")", "const", "{", "if", "(", "CacheLineSize", ".", "getNumOccurrences", "(", ")", ">", "0", ")", "return", "CacheLineSize", ";", "unsigned", "Directive", "=", "ST", "->", "getCPUDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_PWR7", "||", "Directive", "==", "PPC", "::", "DIR_PWR8", "||", "Directive", "==", "PPC", "::", "DIR_PWR9", "||", "Directive", "==", "PPC", "::", "DIR_PWR_FUTURE", ")", "return", "128", ";", "return", "64", ";", "}", "</s>" ]

[ "Return", "the", "target", "cache", "line", "size", "in", "bytes", "." ]

[ "PowerPC", "PPC", "0", "PPC::DIR_PWR7", "PPC::DIR_PWR8", "PPC::DIR_PWR9", "PPC::DIR_PWR_FUTURE", "128", "64" ]

[]

[ "<s>", "unsigned", "AlphaRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameInfo", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "Alpha", "::", "R15", ":", "Alpha", "::", "R30", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::R15", "Alpha::R30" ]

[]

[ "<s>", "enum", "reg_class", "pdp11_regno_reg_class", "(", "int", "regno", ")", "{", "if", "(", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", "return", "GENERAL_REGS", ";", "else", "if", "(", "regno", ">", "AC3_REGNUM", ")", "return", "NO_LOAD_FPU_REGS", ";", "else", "if", "(", "regno", ">=", "AC0_REGNUM", ")", "return", "LOAD_FPU_REGS", ";", "else", "if", "(", "regno", "&", "1", ")", "return", "MUL_REGS", ";", "else", "return", "GENERAL_REGS", ";", "}", "</s>" ]

[ "Return", "the", "class", "number", "of", "the", "smallest", "class", "containing", "reg", "number", "REGNO", "." ]

[ "pdp11", "1" ]

[]

[ "<s>", "static", "inline", "bool", "m32r_store_preinc_predec_p", "(", "machine_mode", "mode", ",", "const_rtx", "x", ",", "bool", "strict", ")", "{", "if", "(", "(", "mode", "==", "SImode", "||", "mode", "==", "SFmode", ")", "&&", "(", "GET_CODE", "(", "x", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "x", ")", "==", "PRE_DEC", ")", "&&", "REG_P", "(", "XEXP", "(", "x", ",", "0", ")", ")", "\\", "&&", "m32r_rtx_ok_for_base_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "strict", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Is", "this", "an", "increment/decrement", "and", "store", "operation", "." ]

[ "m32r", "0", "0" ]

[]

[ "<s>", "virtual", "const", "TLCS900InstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "TLCS900", "TLCS900" ]

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitLinkage", "(", "const", "GlobalValue", "*", "GV", ",", "MCSymbol", "*", "GVSym", ")", "const", "{", "assert", "(", "MAI", "->", "hasVisibilityOnlyWithLinkage", "(", ")", "&&", "\"AIX's linkage directives take a visibility setting.\"", ")", ";", "MCSymbolAttr", "LinkageAttr", "=", "MCSA_Invalid", ";", "switch", "(", "GV", "->", "getLinkage", "(", ")", ")", "{", "case", "GlobalValue", "::", "ExternalLinkage", ":", "LinkageAttr", "=", "GV", "->", "isDeclaration", "(", ")", "?", "MCSA_Extern", ":", "MCSA_Global", ";", "break", ";", "case", "GlobalValue", "::", "LinkOnceAnyLinkage", ":", "case", "GlobalValue", "::", "LinkOnceODRLinkage", ":", "case", "GlobalValue", "::", "WeakAnyLinkage", ":", "case", "GlobalValue", "::", "WeakODRLinkage", ":", "case", "GlobalValue", "::", "ExternalWeakLinkage", ":", "LinkageAttr", "=", "MCSA_Weak", ";", "break", ";", "case", "GlobalValue", "::", "AvailableExternallyLinkage", ":", "LinkageAttr", "=", "MCSA_Extern", ";", "break", ";", "case", "GlobalValue", "::", "PrivateLinkage", ":", "return", ";", "case", "GlobalValue", "::", "InternalLinkage", ":", "assert", "(", "GV", "->", "getVisibility", "(", ")", "==", "GlobalValue", "::", "DefaultVisibility", "&&", "\"InternalLinkage should not have other visibility setting.\"", ")", ";", "LinkageAttr", "=", "MCSA_LGlobal", ";", "break", ";", "case", "GlobalValue", "::", "AppendingLinkage", ":", "llvm_unreachable", "(", "\"Should never emit this\"", ")", ";", "case", "GlobalValue", "::", "CommonLinkage", ":", "llvm_unreachable", "(", "\"CommonLinkage of XCOFF should not come to this path\"", ")", ";", "}", "assert", "(", "LinkageAttr", "!=", "MCSA_Invalid", "&&", "\"LinkageAttr should not MCSA_Invalid.\"", ")", ";", "MCSymbolAttr", "VisibilityAttr", "=", "MCSA_Invalid", ";", "if", "(", "!", "TM", ".", "getIgnoreXCOFFVisibility", "(", ")", ")", "{", "switch", "(", "GV", "->", "getVisibility", "(", ")", ")", "{", "case", "GlobalValue", "::", "DefaultVisibility", ":", "break", ";", "case", "GlobalValue", "::", "HiddenVisibility", ":", "VisibilityAttr", "=", "MAI", "->", "getHiddenVisibilityAttr", "(", ")", ";", "break", ";", "case", "GlobalValue", "::", "ProtectedVisibility", ":", "VisibilityAttr", "=", "MAI", "->", "getProtectedVisibilityAttr", "(", ")", ";", "break", ";", "}", "}", "OutStreamer", "->", "emitXCOFFSymbolLinkageWithVisibility", "(", "GVSym", ",", "LinkageAttr", ",", "VisibilityAttr", ")", ";", "}", "</s>" ]

[ "This", "emits", "linkage", "information", "about", "GVSym", "based", "on", "GV", ",", "if", "this", "is", "supported", "by", "the", "target", "." ]

[ "PowerPC", "PPC", "\"AIX's linkage directives take a visibility setting.\"", "\"InternalLinkage should not have other visibility setting.\"", "\"Should never emit this\"", "\"CommonLinkage of XCOFF should not come to this path\"", "\"LinkageAttr should not MCSA_Invalid.\"" ]

[]

[ "<s>", "void", "emitImportModule", "(", "const", "MCSymbolWasm", "*", ",", "StringRef", ")", "override", "{", "}", "</s>" ]

[ ".import_module" ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "void", "nvptx_option_override", "(", "void", ")", "{", "init_machine_status", "=", "nvptx_init_machine_status", ";", "flag_toplevel_reorder", "=", "1", ";", "flag_var_tracking", "=", "0", ";", "write_symbols", "=", "NO_DEBUG", ";", "debug_info_level", "=", "DINFO_LEVEL_NONE", ";", "declared_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "needed_fndecls_htab", "=", "hash_table", "<", "tree_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "declared_libfuncs_htab", "=", "hash_table", "<", "declared_libfunc_hasher", ">", "::", "create_ggc", "(", "17", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "nvptx", "1", "0", "17", "17", "17" ]

[]

[ "<s>", "static", "ArrayRef", "<", "MCPhysReg", ">", "getAllSGPR128", "(", ")", "{", "return", "makeArrayRef", "(", "AMDGPU", "::", "SReg_128RegClass", ".", "begin", "(", ")", ",", "AMDGPU", "::", "SReg_128RegClass", ".", "getNumRegs", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "all", "SGPR128", "which", "satisfy", "the", "waves", "per", "execution", "unit", "requirement", "of", "the", "subtarget", "." ]

[ "AMDGPU", "AMDGPU::SReg_128RegClass", "AMDGPU::SReg_128RegClass" ]

[]

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

[ "isMem", "-", "Is", "this", "a", "memory", "operand", "?" ]

[ "SNES" ]

[]

[ "<s>", "int", "use_return_insn", "(", "int", "iscond", ",", "rtx", "sibling", ")", "{", "int", "regno", ";", "unsigned", "int", "func_type", ";", "unsigned", "long", "saved_int_regs", ";", "unsigned", "HOST_WIDE_INT", "stack_adjust", ";", "arm_stack_offsets", "*", "offsets", ";", "if", "(", "!", "reload_completed", ")", "return", "0", ";", "if", "(", "arm_current_function_pac_enabled_p", "(", ")", ")", "return", "0", ";", "func_type", "=", "arm_current_func_type", "(", ")", ";", "if", "(", "func_type", "&", "(", "ARM_FT_VOLATILE", "|", "ARM_FT_NAKED", "|", "ARM_FT_STACKALIGN", ")", ")", "return", "0", ";", "if", "(", "IS_INTERRUPT", "(", "func_type", ")", "&&", "(", "frame_pointer_needed", "||", "TARGET_THUMB", ")", ")", "return", "0", ";", "if", "(", "TARGET_LDRD", "&&", "current_tune", "->", "prefer_ldrd_strd", "&&", "!", "optimize_function_for_size_p", "(", "cfun", ")", ")", "return", "0", ";", "offsets", "=", "arm_get_frame_offsets", "(", ")", ";", "stack_adjust", "=", "offsets", "->", "outgoing_args", "-", "offsets", "->", "saved_regs", ";", "if", "(", "crtl", "->", "args", ".", "pretend_args_size", "||", "cfun", "->", "machine", "->", "uses_anonymous_args", "||", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "calls_alloca", "||", "!", "(", "stack_adjust", "==", "0", "||", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", "&&", "stack_adjust", "==", "4", ")", ")", "||", "(", "!", "(", "TARGET_APCS_FRAME", "&&", "frame_pointer_needed", ")", "&&", "arm_compute_static_chain_stack_bytes", "(", ")", "!=", "0", ")", ")", "return", "0", ";", "saved_int_regs", "=", "offsets", "->", "saved_regs_mask", ";", "if", "(", "stack_adjust", "==", "4", "&&", "!", "arm_arch5t", "&&", "TARGET_ARM", ")", "{", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "3", ")", ")", "return", "0", ";", "if", "(", "arm_size_return_regs", "(", ")", ">=", "(", "4", "*", "UNITS_PER_WORD", ")", ")", "return", "0", ";", "if", "(", "sibling", ")", "{", "gcc_assert", "(", "CALL_P", "(", "sibling", ")", ")", ";", "if", "(", "find_regno_fusage", "(", "sibling", ",", "USE", ",", "3", ")", ")", "return", "0", ";", "}", "if", "(", "saved_int_regs", "&", "0x7", ")", "return", "0", ";", "}", "if", "(", "TARGET_INTERWORK", "&&", "saved_int_regs", "!=", "0", "&&", "!", "IS_INTERRUPT", "(", "func_type", ")", ")", "return", "0", ";", "if", "(", "iscond", "&&", "arm_tune_strongarm", ")", "{", "if", "(", "saved_int_regs", "!=", "0", "&&", "saved_int_regs", "!=", "(", "1", "<<", "LR_REGNUM", ")", ")", "return", "0", ";", "if", "(", "flag_pic", "&&", "arm_pic_register", "!=", "INVALID_REGNUM", "&&", "df_regs_ever_live_p", "(", "PIC_OFFSET_TABLE_REGNUM", ")", ")", "return", "0", ";", "}", "if", "(", "IS_CMSE_ENTRY", "(", "func_type", ")", "&&", "(", "saved_int_regs", "||", "TARGET_HAVE_FPCXT_CMSE", ")", ")", "return", "0", ";", "if", "(", "saved_int_regs", "&&", "!", "(", "saved_int_regs", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", ")", "return", "0", ";", "if", "(", "TARGET_VFP_BASE", ")", "for", "(", "regno", "=", "FIRST_VFP_REGNUM", ";", "regno", "<=", "LAST_VFP_REGNUM", ";", "regno", "++", ")", "if", "(", "reg_needs_saving_p", "(", "regno", ")", ")", "return", "0", ";", "if", "(", "TARGET_REALLY_IWMMXT", ")", "for", "(", "regno", "=", "FIRST_IWMMXT_REGNUM", ";", "regno", "<=", "LAST_IWMMXT_REGNUM", ";", "regno", "++", ")", "if", "(", "reg_needs_saving_p", "(", "regno", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "function", "'s", "epilogue", "can", "be", "output", "as", "RTL", "." ]

[ "arm", "0", "0", "0", "0", "0", "0", "4", "0", "0", "4", "3", "0", "4", "0", "3", "0", "0x7", "0", "0", "0", "0", "1", "0", "0", "0", "1", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "SystemZRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "assert", "(", "MI", "->", "isCopy", "(", ")", "&&", "\"Only expecting COPY instructions\"", ")", ";", "if", "(", "!", "(", "NewRC", "->", "hasSuperClassEq", "(", "&", "SystemZ", "::", "GR128BitRegClass", ")", "&&", "(", "getRegSizeInBits", "(", "*", "SrcRC", ")", "<=", "64", "||", "getRegSizeInBits", "(", "*", "DstRC", ")", "<=", "64", ")", ")", ")", "return", "true", ";", "unsigned", "WideOpNo", "=", "(", "getRegSizeInBits", "(", "*", "SrcRC", ")", "==", "128", "?", "1", ":", "0", ")", ";", "unsigned", "GR128Reg", "=", "MI", "->", "getOperand", "(", "WideOpNo", ")", ".", "getReg", "(", ")", ";", "unsigned", "GRNarReg", "=", "MI", "->", "getOperand", "(", "(", "WideOpNo", "==", "1", ")", "?", "0", ":", "1", ")", ".", "getReg", "(", ")", ";", "LiveInterval", "&", "IntGR128", "=", "LIS", ".", "getInterval", "(", "GR128Reg", ")", ";", "LiveInterval", "&", "IntGRNar", "=", "LIS", ".", "getInterval", "(", "GRNarReg", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "if", "(", "LIS", ".", "isLiveInToMBB", "(", "IntGR128", ",", "MBB", ")", "||", "LIS", ".", "isLiveOutOfMBB", "(", "IntGR128", ",", "MBB", ")", "||", "LIS", ".", "isLiveInToMBB", "(", "IntGRNar", ",", "MBB", ")", "||", "LIS", ".", "isLiveOutOfMBB", "(", "IntGRNar", ",", "MBB", ")", ")", "return", "false", ";", "MachineInstr", "*", "FirstMI", "=", "nullptr", ",", "*", "LastMI", "=", "nullptr", ";", "if", "(", "WideOpNo", "==", "1", ")", "{", "FirstMI", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGR128", ".", "beginIndex", "(", ")", ")", ";", "LastMI", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGRNar", ".", "endIndex", "(", ")", ")", ";", "}", "else", "{", "FirstMI", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGRNar", ".", "beginIndex", "(", ")", ")", ";", "LastMI", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGR128", ".", "endIndex", "(", ")", ")", ";", "}", "assert", "(", "FirstMI", "&&", "LastMI", "&&", "\"No instruction from index?\"", ")", ";", "BitVector", "PhysClobbered", "(", "getNumRegs", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "FirstMI", ",", "MEE", "=", "LastMI", ";", "MEE", "++", ";", "for", "(", ";", "MII", "!=", "MEE", ";", "++", "MII", ")", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MII", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "isPhysicalRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SI", "(", "MO", ".", "getReg", "(", ")", ",", "this", ",", "true", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "NewRC", "->", "contains", "(", "*", "SI", ")", ")", "{", "PhysClobbered", ".", "set", "(", "*", "SI", ")", ";", "break", ";", "}", "}", "}", "unsigned", "const", "DemandedFreeGR128", "=", "3", ";", "if", "(", "PhysClobbered", ".", "count", "(", ")", ">", "(", "NewRC", "->", "getNumRegs", "(", ")", "-", "DemandedFreeGR128", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "SystemZ", "SystemZ", "\"Only expecting COPY instructions\"", "SystemZ::GR128BitRegClass", "64", "64", "128", "1", "0", "1", "0", "1", "1", "\"No instruction from index?\"", "3" ]

[]

[ "<s>", "bool", "TL45InstrInfo", "::", "expandPostRAPseudo", "(", "MachineInstr", "&", "MI", ")", "const", "{", "const", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "TL45", "::", "CMP_JMP", ":", "{", "auto", "ConditionCode", "=", "ISD", "::", "CondCode", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ";", "unsigned", "int", "JmpOpcode", ";", "resolveComparison", "(", "MBB", ",", "MI", ",", "DL", ",", "ConditionCode", ",", "MI", ".", "getOperand", "(", "1", ")", ",", "MI", ".", "getOperand", "(", "2", ")", ",", "JmpOpcode", ",", "false", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "JmpOpcode", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ";", "break", ";", "}", "case", "TL45", "::", "CMPI_JMP", ":", "{", "auto", "ConditionCode", "=", "ISD", "::", "CondCode", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ")", ";", "unsigned", "int", "JmpOpcode", ";", "resolveComparison", "(", "MBB", ",", "MI", ",", "DL", ",", "ConditionCode", ",", "MI", ".", "getOperand", "(", "1", ")", ",", "MI", ".", "getOperand", "(", "2", ")", ",", "JmpOpcode", ",", "true", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "JmpOpcode", ")", ")", ".", "add", "(", "MI", ".", "getOperand", "(", "3", ")", ")", ";", "break", ";", "}", "case", "TL45", "::", "ADD32", ":", "{", "MachineOperand", "&", "dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "src", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "MachineOperand", "&", "imm", "=", "MI", ".", "getOperand", "(", "2", ")", ";", "assert", "(", "imm", ".", "isImm", "(", ")", "&&", "\"imm must be immediate\"", ")", ";", "uint64_t", "val", "=", "(", "uint32_t", ")", "imm", ".", "getImm", "(", ")", ";", "uint64_t", "low", "=", "val", "&", "0xffffu", ";", "uint64_t", "high", "=", "(", "val", ">>", "16u", ")", "&", "0xffffu", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TL45", "::", "ADDIZ", ")", ")", ".", "add", "(", "dst", ")", ".", "add", "(", "src", ")", ".", "addImm", "(", "low", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "TL45", "::", "ADDHI", ")", ")", ".", "add", "(", "dst", ")", ".", "add", "(", "dst", ")", ".", "addImm", "(", "high", ")", ";", "break", ";", "}", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "TL45", "TL45", "TL45::CMP_JMP", "ISD::CondCode", "0", "1", "2", "3", "TL45::CMPI_JMP", "ISD::CondCode", "0", "1", "2", "3", "TL45::ADD32", "0", "1", "2", "\"imm must be immediate\"", "0xffffu", "16u", "0xffffu", "TL45::ADDIZ", "TL45::ADDHI" ]

[]

[ "<s>", "void", "NVPTXPassConfig", "::", "addIRPasses", "(", ")", "{", "disablePass", "(", "&", "PrologEpilogCodeInserterID", ")", ";", "disablePass", "(", "&", "MachineCopyPropagationID", ")", ";", "disablePass", "(", "&", "TailDuplicateID", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "LiveDebugValuesID", ")", ";", "disablePass", "(", "&", "PostRAMachineSinkingID", ")", ";", "disablePass", "(", "&", "PostRASchedulerID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "disablePass", "(", "&", "ShrinkWrapID", ")", ";", "const", "NVPTXSubtarget", "&", "ST", "=", "*", "getTM", "<", "NVPTXTargetMachine", ">", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "addPass", "(", "createNVVMReflectPass", "(", "ST", ".", "getSmVersion", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createNVPTXImageOptimizerPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXAssignValidGlobalNamesPass", "(", ")", ")", ";", "addPass", "(", "createGenericToNVVMPass", "(", ")", ")", ";", "addPass", "(", "createNVPTXLowerArgsPass", "(", "&", "getNVPTXTargetMachine", "(", ")", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addAddressSpaceInferencePasses", "(", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "}", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addEarlyCSEOrGVNPass", "(", ")", ";", "if", "(", "!", "DisableLoadStoreVectorizer", ")", "addPass", "(", "createLoadStoreVectorizerPass", "(", ")", ")", ";", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "reservedPrivateSegmentBufferReg", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "unsigned", "BaseIdx", "=", "alignDown", "(", "ST", ".", "getMaxNumSGPRs", "(", "MF", ")", ",", "4", ")", "-", "4", ";", "unsigned", "BaseReg", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "BaseIdx", ")", ")", ";", "return", "getMatchingSuperReg", "(", "BaseReg", ",", "AMDGPU", "::", "sub0", ",", "&", "AMDGPU", "::", "SReg_128RegClass", ")", ";", "}", "</s>" ]

[ "Return", "the", "end", "register", "initially", "reserved", "for", "the", "scratch", "buffer", "in", "case", "spilling", "is", "needed", "." ]

[ "AMDGPU", "SI", "4", "4", "AMDGPU::SGPR_32RegClass", "AMDGPU::sub0", "AMDGPU::SReg_128RegClass" ]

[]

[ "<s>", "int", "AArch64TTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "ValTy", ",", "bool", "IsPairwiseForm", ")", "{", "if", "(", "IsPairwiseForm", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "ValTy", ")", ";", "MVT", "MTy", "=", "LT", ".", "second", ";", "int", "ISD", "=", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", ";", "assert", "(", "ISD", "&&", "\"Invalid opcode\"", ")", ";", "static", "const", "CostTblEntry", "CostTblNoPairwise", "[", "]", "{", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v16i8", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v8i16", ",", "1", "}", ",", "{", "ISD", "::", "ADD", ",", "MVT", "::", "v4i32", ",", "1", "}", ",", "}", ";", "if", "(", "const", "auto", "*", "Entry", "=", "CostTableLookup", "(", "CostTblNoPairwise", ",", "ISD", ",", "MTy", ")", ")", "return", "LT", ".", "first", "*", "Entry", "->", "Cost", ";", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "ValTy", ",", "IsPairwiseForm", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "AArch64", "AArch64", "\"Invalid opcode\"", "ISD::ADD", "MVT::v8i8", "1", "ISD::ADD", "MVT::v16i8", "1", "ISD::ADD", "MVT::v4i16", "1", "ISD::ADD", "MVT::v8i16", "1", "ISD::ADD", "MVT::v4i32", "1" ]

[]

[ "<s>", "bool", "doInitialization", "(", "Module", "&", ")", "override", "{", "if", "(", "!", "StatsFile", ".", "empty", "(", ")", "&&", "!", "AppendStatsFile", "&&", "sys", "::", "fs", "::", "exists", "(", "StatsFile", ")", ")", "{", "sys", "::", "fs", "::", "remove", "(", "StatsFile", ".", "c_str", "(", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "Patmos" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "X86" ]

[]

[ "<s>", "void", "SIScheduleBlock", "::", "addPred", "(", "SIScheduleBlock", "*", "Pred", ")", "{", "unsigned", "PredID", "=", "Pred", "->", "getID", "(", ")", ";", "for", "(", "SIScheduleBlock", "*", "P", ":", "Preds", ")", "{", "if", "(", "PredID", "==", "P", "->", "getID", "(", ")", ")", "return", ";", "}", "Preds", ".", "push_back", "(", "Pred", ")", ";", "assert", "(", "none_of", "(", "Succs", ",", "[", "=", "]", "(", "SIScheduleBlock", "*", "S", ")", "{", "return", "PredID", "==", "S", "->", "getID", "(", ")", ";", "}", ")", "&&", "\"Loop in the Block Graph!\"", ")", ";", "}", "</s>" ]

[ "Adds", "the", "specified", "edge", "as", "a", "pred", "of", "the", "current", "node", "if", "not", "already", "." ]

[ "AMDGPU", "SI", "SI", "SI", "SI", "\"Loop in the Block Graph!\"" ]

[]

[ "<s>", "void", "assignValueToReg", "(", "Register", "ValVReg", ",", "Register", "PhysReg", ",", "CCValAssign", "VA", ")", "override", "{", "switch", "(", "VA", ".", "getLocVT", "(", ")", ".", "getSizeInBits", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Not yet implemented.\"", ")", ";", "case", "8", ":", "case", "16", ":", "break", ";", "}", "makeLive", "(", "PhysReg", ")", ";", "MIRBuilder", ".", "buildCopy", "(", "ValVReg", ",", "PhysReg", ")", ";", "}", "</s>" ]

[ "The", "specified", "value", "has", "been", "assigned", "to", "a", "physical", "register", ",", "handle", "the", "appropriate", "COPY", "(", "either", "to", "or", "from", ")", "and", "mark", "any", "relevant", "uses/defines", "as", "needed", "." ]

[ "MOS", "\"Not yet implemented.\"", "8", "16" ]

[]

[ "<s>", "unsigned", "ARMAsmParser", "::", "validateTargetOperandClass", "(", "MCParsedAsmOperand", "*", "AsmOp", ",", "unsigned", "Kind", ")", "{", "ARMOperand", "*", "Op", "=", "static_cast", "<", "ARMOperand", "*", ">", "(", "AsmOp", ")", ";", "switch", "(", "Kind", ")", "{", "default", ":", "break", ";", "case", "MCK__35_0", ":", "if", "(", "Op", "->", "isImm", "(", ")", ")", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", "->", "getImm", "(", ")", ")", ")", "if", "(", "CE", "->", "getValue", "(", ")", "==", "0", ")", "return", "Match_Success", ";", "break", ";", "case", "MCK_ARMSOImm", ":", "if", "(", "Op", "->", "isImm", "(", ")", ")", "{", "const", "MCExpr", "*", "SOExpr", "=", "Op", "->", "getImm", "(", ")", ";", "int64_t", "Value", ";", "if", "(", "!", "SOExpr", "->", "EvaluateAsAbsolute", "(", "Value", ")", ")", "return", "Match_Success", ";", "assert", "(", "(", "Value", ">=", "INT32_MIN", "&&", "Value", "<=", "UINT32_MAX", ")", "&&", "\"expression value must be representable in 32 bits\"", ")", ";", "}", "break", ";", "case", "MCK_GPRPair", ":", "if", "(", "Op", "->", "isReg", "(", ")", "&&", "MRI", "->", "getRegClass", "(", "ARM", "::", "GPRRegClassID", ")", ".", "contains", "(", "Op", "->", "getReg", "(", ")", ")", ")", "return", "Match_Success", ";", "break", ";", "}", "return", "Match_InvalidOperand", ";", "}", "</s>" ]

[ "Allow", "a", "target", "to", "add", "special", "case", "operand", "matching", "for", "things", "that", "tblgen", "doesn't/ca", "n't", "handle", "effectively", "." ]

[ "ARM", "ARM", "ARM", "ARM", "0", "ARM", "\"expression value must be representable in 32 bits\"", "ARM::GPRRegClassID" ]

[]

[ "<s>", "void", "CSKYAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "if", "(", "InConstantPool", "&&", "MI", "->", "getOpcode", "(", ")", "!=", "CSKY", "::", "CONSTPOOL_ENTRY", ")", "{", "InConstantPool", "=", "false", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "CSKY", "::", "PseudoTLSLA32", ")", "return", "expandTLSLA", "(", "MI", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "CSKY", "::", "CONSTPOOL_ENTRY", ")", "return", "emitCustomConstantPool", "(", "MI", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::CONSTPOOL_ENTRY", "CSKY::PseudoTLSLA32", "CSKY::CONSTPOOL_ENTRY" ]

[]

[ "<s>", "machine_mode", "arc_select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", ",", "rtx", "y", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "rtx", "x1", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "y", "==", "const0_rtx", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", "||", "(", "(", "op", "==", "LT", "||", "op", "==", "GE", ")", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", "<=", "4", ")", ")", ")", "return", "CC_ZNmode", ";", "if", "(", "mode", "==", "SImode", "&&", "GET_CODE", "(", "y", ")", "==", "NEG", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", ")", "return", "CC_ZNmode", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "&&", "CONST_INT_P", "(", "y", ")", "&&", "(", "(", "INTVAL", "(", "y", ")", "-", "1", ")", "&", "INTVAL", "(", "y", ")", ")", "==", "0", "&&", "INTVAL", "(", "y", ")", ")", "return", "CC_Zmode", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "op", "==", "EQ", "||", "op", "==", "NE", ")", "&&", "CONST_INT_P", "(", "y", ")", "&&", "GET_CODE", "(", "x", ")", "==", "AND", "&&", "CONST_INT_P", "(", "(", "x1", "=", "XEXP", "(", "x", ",", "1", ")", ")", ")", "&&", "(", "(", "INTVAL", "(", "x1", ")", "+", "1", ")", "&", "INTVAL", "(", "x1", ")", ")", "==", "0", "&&", "(", "~", "INTVAL", "(", "x1", ")", "|", "INTVAL", "(", "y", ")", ")", "<", "0", "&&", "(", "~", "INTVAL", "(", "x1", ")", "|", "INTVAL", "(", "y", ")", ")", ">", "-", "0x800", ")", "return", "CC_Zmode", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "SImode", "&&", "(", "op", "==", "LTU", "||", "op", "==", "GEU", ")", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "(", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "y", ")", "||", "rtx_equal_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "y", ")", ")", ")", "return", "CC_Cmode", ";", "if", "(", "TARGET_ARGONAUT_SET", "&&", "(", "(", "mode", "==", "SFmode", "&&", "TARGET_SPFP", ")", "||", "(", "mode", "==", "DFmode", "&&", "TARGET_DPFP", ")", ")", ")", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "UNEQ", ":", "case", "LTGT", ":", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "CC_FPXmode", ";", "case", "LT", ":", "case", "UNGE", ":", "case", "GT", ":", "case", "UNLE", ":", "return", "CC_FP_GTmode", ";", "case", "LE", ":", "case", "UNGT", ":", "case", "GE", ":", "case", "UNLT", ":", "return", "CC_FP_GEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "&&", "TARGET_OPTFPE", ")", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "return", "CC_Zmode", ";", "case", "LT", ":", "case", "UNGE", ":", "case", "GT", ":", "case", "UNLE", ":", "return", "CC_FP_GTmode", ";", "case", "LE", ":", "case", "UNGT", ":", "case", "GE", ":", "case", "UNLT", ":", "return", "CC_FP_GEmode", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "return", "CC_FP_UNEQmode", ";", "case", "ORDERED", ":", "case", "UNORDERED", ":", "return", "CC_FP_ORDmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "CCmode", ";", "}", "</s>" ]

[ "Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "first", "operand", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", "." ]

[ "arc", "4", "1", "0", "1", "1", "0", "0", "0x800", "0", "1" ]

[]

[ "<s>", "bool", "FISCTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "return", "false", ";", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "!", "AM", ".", "HasBaseReg", ")", "break", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "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", "." ]

[ "FISC", "FISC", "0", "1" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreGlobalInstructionSelect", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "addPass", "(", "createAMDGPURegBankCombiner", "(", "IsOptNone", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "the", "(", "global", ")", "instruction", "selection", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "breakPartialRegDependency", "(", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "VR128RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "unsigned", "Opc", "=", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ",", "Reg", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Undef", ")", ";", "}", "else", "if", "(", "X86", "::", "VR256RegClass", ".", "contains", "(", "Reg", ")", ")", "{", "unsigned", "XReg", "=", "TRI", "->", "getSubReg", "(", "Reg", ",", "X86", "::", "sub_xmm", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "X86", "::", "VXORPSrr", ")", ",", "XReg", ")", ".", "addReg", "(", "XReg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "XReg", ",", "RegState", "::", "Undef", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "else", "return", ";", "MI", "->", "addRegisterKilled", "(", "Reg", ",", "TRI", ",", "true", ")", ";", "}", "</s>" ]

[ "Insert", "a", "dependency-breaking", "instruction", "before", "MI", "to", "eliminate", "an", "unwanted", "dependency", "on", "OpNum", "." ]

[ "X86", "X86", "X86::VR128RegClass", "X86", "X86::VXORPSrr", "X86::XORPSrr", "X86::VR256RegClass", "X86::sub_xmm", "X86::VXORPSrr" ]

[]

[ "<s>", "static", "void", "expand_small_cpymem_or_setmem", "(", "rtx", "destmem", ",", "rtx", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "rtx", "value", ",", "rtx", "vec_value", ",", "rtx", "count", ",", "int", "size", ",", "rtx", "done_label", ",", "bool", "issetmem", ")", "{", "rtx_code_label", "*", "label", "=", "ix86_expand_aligntest", "(", "count", ",", "size", ",", "false", ")", ";", "machine_mode", "mode", "=", "int_mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "1", ")", ".", "else_blk", "(", ")", ";", "rtx", "modesize", ";", "int", "n", ";", "if", "(", "issetmem", ")", "{", "if", "(", "!", "vec_value", ")", "{", "if", "(", "GET_MODE", "(", "value", ")", "==", "VOIDmode", "&&", "size", ">", "8", ")", "mode", "=", "Pmode", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", ">", "GET_MODE_SIZE", "(", "GET_MODE", "(", "value", ")", ")", ")", "mode", "=", "GET_MODE", "(", "value", ")", ";", "}", "else", "mode", "=", "GET_MODE", "(", "vec_value", ")", ",", "value", "=", "vec_value", ";", "}", "else", "{", "if", "(", "size", ">=", "32", ")", "mode", "=", "TARGET_AVX", "?", "V32QImode", ":", "TARGET_SSE", "?", "V16QImode", ":", "DImode", ";", "else", "if", "(", "size", ">=", "16", ")", "mode", "=", "TARGET_SSE", "?", "V16QImode", ":", "DImode", ";", "srcmem", "=", "change_address", "(", "srcmem", ",", "mode", ",", "srcptr", ")", ";", "}", "destmem", "=", "change_address", "(", "destmem", ",", "mode", ",", "destptr", ")", ";", "modesize", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "size", ")", ";", "for", "(", "n", "=", "0", ";", "n", "*", "GET_MODE_SIZE", "(", "mode", ")", "<", "size", ";", "n", "++", ")", "{", "if", "(", "issetmem", ")", "emit_move_insn", "(", "destmem", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "else", "{", "emit_move_insn", "(", "destmem", ",", "srcmem", ")", ";", "srcmem", "=", "offset_address", "(", "srcmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "destmem", "=", "offset_address", "(", "destmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "destmem", "=", "offset_address", "(", "destmem", ",", "count", ",", "1", ")", ";", "destmem", "=", "offset_address", "(", "destmem", ",", "GEN_INT", "(", "-", "2", "*", "size", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "!", "issetmem", ")", "{", "srcmem", "=", "offset_address", "(", "srcmem", ",", "count", ",", "1", ")", ";", "srcmem", "=", "offset_address", "(", "srcmem", ",", "GEN_INT", "(", "-", "2", "*", "size", ")", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "for", "(", "n", "=", "0", ";", "n", "*", "GET_MODE_SIZE", "(", "mode", ")", "<", "size", ";", "n", "++", ")", "{", "if", "(", "issetmem", ")", "emit_move_insn", "(", "destmem", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "else", "{", "emit_move_insn", "(", "destmem", ",", "srcmem", ")", ";", "srcmem", "=", "offset_address", "(", "srcmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "destmem", "=", "offset_address", "(", "destmem", ",", "modesize", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "}", "emit_jump_insn", "(", "gen_jump", "(", "done_label", ")", ")", ";", "emit_barrier", "(", ")", ";", "emit_label", "(", "label", ")", ";", "LABEL_NUSES", "(", "label", ")", "=", "1", ";", "}", "</s>" ]

[ "Test", "if", "COUNT", "&", "SIZE", "is", "nonzero", "and", "if", "so", ",", "expand", "movme", "or", "setmem", "sequence", "that", "is", "valid", "for", "SIZE", "..", "2", "*", "SIZE-1", "bytes", "and", "jump", "to", "DONE_LABEL", "." ]

[ "i386", "1", "8", "32", "16", "0", "1", "2", "1", "2", "0", "1" ]

[]

[ "<s>", "MachineInstr", "*", "SIInstrInfo", "::", "commuteInstruction", "(", "MachineInstr", "*", "MI", ",", "bool", "NewMI", ")", "const", "{", "if", "(", "MI", "->", "getNumOperands", "(", ")", "<", "3", ")", "return", "nullptr", ";", "int", "Src0Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ";", "assert", "(", "Src0Idx", "!=", "-", "1", "&&", "\"Should always have src0 operand\"", ")", ";", "MachineOperand", "&", "Src0", "=", "MI", "->", "getOperand", "(", "Src0Idx", ")", ";", "if", "(", "!", "Src0", ".", "isReg", "(", ")", ")", "return", "nullptr", ";", "int", "Src1Idx", "=", "AMDGPU", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "AMDGPU", "::", "OpName", "::", "src1", ")", ";", "if", "(", "Src1Idx", "==", "-", "1", ")", "return", "nullptr", ";", "MachineOperand", "&", "Src1", "=", "MI", "->", "getOperand", "(", "Src1Idx", ")", ";", "if", "(", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "(", "!", "isOperandLegal", "(", "MI", ",", "Src0Idx", ",", "&", "Src1", ")", "||", "!", "isOperandLegal", "(", "MI", ",", "Src1Idx", ",", "&", "Src0", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "!", "Src1", ".", "isReg", "(", ")", ")", "{", "if", "(", "NewMI", "||", "!", "Src1", ".", "isImm", "(", ")", "||", "(", "!", "isVOP2", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "!", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", "{", "return", "nullptr", ";", "}", "if", "(", "MachineOperand", "*", "Src0Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src0_modifiers", ")", ")", "{", "MachineOperand", "*", "Src1Mods", "=", "getNamedOperand", "(", "*", "MI", ",", "AMDGPU", "::", "OpName", "::", "src1_modifiers", ")", ";", "int", "Src0ModsVal", "=", "Src0Mods", "->", "getImm", "(", ")", ";", "if", "(", "!", "Src1Mods", "&&", "Src0ModsVal", "!=", "0", ")", "return", "nullptr", ";", "int", "Src1ModsVal", "=", "Src1Mods", "->", "getImm", "(", ")", ";", "assert", "(", "(", "Src1ModsVal", "==", "0", ")", "&&", "\"Not expecting modifiers with immediates\"", ")", ";", "Src1Mods", "->", "setImm", "(", "Src0ModsVal", ")", ";", "Src0Mods", "->", "setImm", "(", "Src1ModsVal", ")", ";", "}", "unsigned", "Reg", "=", "Src0", ".", "getReg", "(", ")", ";", "unsigned", "SubReg", "=", "Src0", ".", "getSubReg", "(", ")", ";", "if", "(", "Src1", ".", "isImm", "(", ")", ")", "Src0", ".", "ChangeToImmediate", "(", "Src1", ".", "getImm", "(", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Should only have immediates\"", ")", ";", "Src1", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "Src1", ".", "setSubReg", "(", "SubReg", ")", ";", "}", "else", "{", "MI", "=", "TargetInstrInfo", "::", "commuteInstruction", "(", "MI", ",", "NewMI", ")", ";", "}", "if", "(", "MI", ")", "MI", "->", "setDesc", "(", "get", "(", "commuteOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", ")", ";", "return", "MI", ";", "}", "</s>" ]

[ "This", "method", "commutes", "the", "operands", "of", "the", "given", "machine", "instruction", "MI", "." ]

[ "R600", "SI", "3", "1", "\"Should always have src0 operand\"", "1", "0", "0", "\"Not expecting modifiers with immediates\"", "\"Should only have immediates\"" ]

[]

[ "<s>", "void", "cmse_nonsecure_entry_clear_before_return", "(", "void", ")", "{", "int", "regno", ",", "maxregno", "=", "TARGET_HARD_FLOAT", "?", "LAST_VFP_REGNUM", ":", "IP_REGNUM", ";", "uint32_t", "padding_bits_to_clear", "=", "0", ";", "auto_sbitmap", "to_clear_bitmap", "(", "maxregno", "+", "1", ")", ";", "rtx", "r1_reg", ",", "result_rtl", ",", "clearing_reg", "=", "NULL_RTX", ";", "tree", "result_type", ";", "bitmap_clear", "(", "to_clear_bitmap", ")", ";", "bitmap_set_range", "(", "to_clear_bitmap", ",", "R0_REGNUM", ",", "NUM_ARG_REGS", ")", ";", "bitmap_set_bit", "(", "to_clear_bitmap", ",", "IP_REGNUM", ")", ";", "if", "(", "TARGET_HARD_FLOAT", ")", "{", "int", "float_bits", "=", "D7_VFP_REGNUM", "-", "FIRST_VFP_REGNUM", "+", "1", ";", "bitmap_set_range", "(", "to_clear_bitmap", ",", "FIRST_VFP_REGNUM", ",", "float_bits", ")", ";", "emit_use", "(", "gen_rtx_REG", "(", "SImode", ",", "IP_REGNUM", ")", ")", ";", "bitmap_clear_bit", "(", "to_clear_bitmap", ",", "IP_REGNUM", ")", ";", "emit_use", "(", "gen_rtx_REG", "(", "SImode", ",", "4", ")", ")", ";", "bitmap_clear_bit", "(", "to_clear_bitmap", ",", "4", ")", ";", "}", "for", "(", "regno", "=", "NUM_ARG_REGS", ";", "regno", "<=", "maxregno", ";", "regno", "++", ")", "{", "if", "(", "IN_RANGE", "(", "regno", ",", "FIRST_VFP_REGNUM", ",", "D7_VFP_REGNUM", ")", ")", "continue", ";", "if", "(", "IN_RANGE", "(", "regno", ",", "IP_REGNUM", ",", "PC_REGNUM", ")", ")", "continue", ";", "if", "(", "call_used_regs", "[", "regno", "]", ")", "bitmap_set_bit", "(", "to_clear_bitmap", ",", "regno", ")", ";", "}", "result_type", "=", "TREE_TYPE", "(", "DECL_RESULT", "(", "current_function_decl", ")", ")", ";", "if", "(", "!", "VOID_TYPE_P", "(", "result_type", ")", ")", "{", "uint64_t", "to_clear_return_mask", ";", "result_rtl", "=", "arm_function_value", "(", "result_type", ",", "current_function_decl", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "result_rtl", ")", ")", ";", "to_clear_return_mask", "=", "compute_not_to_clear_mask", "(", "result_type", ",", "result_rtl", ",", "0", ",", "&", "padding_bits_to_clear", ")", ";", "if", "(", "to_clear_return_mask", ")", "{", "gcc_assert", "(", "(", "unsigned", ")", "maxregno", "<", "sizeof", "(", "long", "long", ")", "*", "__CHAR_BIT__", ")", ";", "for", "(", "regno", "=", "R0_REGNUM", ";", "regno", "<=", "maxregno", ";", "regno", "++", ")", "{", "if", "(", "to_clear_return_mask", "&", "(", "1ULL", "<<", "regno", ")", ")", "bitmap_clear_bit", "(", "to_clear_bitmap", ",", "regno", ")", ";", "}", "}", "}", "if", "(", "padding_bits_to_clear", "!=", "0", ")", "{", "int", "to_clear_bitmap_size", "=", "SBITMAP_SIZE", "(", "(", "sbitmap", ")", "to_clear_bitmap", ")", ";", "auto_sbitmap", "to_clear_arg_regs_bitmap", "(", "to_clear_bitmap_size", ")", ";", "bitmap_clear", "(", "to_clear_arg_regs_bitmap", ")", ";", "bitmap_set_range", "(", "to_clear_arg_regs_bitmap", ",", "R1_REGNUM", ",", "NUM_ARG_REGS", "-", "1", ")", ";", "gcc_assert", "(", "bitmap_subset_p", "(", "to_clear_arg_regs_bitmap", ",", "to_clear_bitmap", ")", ")", ";", "}", "clearing_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "TARGET_THUMB1", "?", "R0_REGNUM", ":", "LR_REGNUM", ")", ";", "r1_reg", "=", "gen_rtx_REG", "(", "SImode", ",", "R0_REGNUM", "+", "1", ")", ";", "cmse_clear_registers", "(", "to_clear_bitmap", ",", "&", "padding_bits_to_clear", ",", "1", ",", "r1_reg", ",", "clearing_reg", ")", ";", "}", "</s>" ]

[ "Clear", "caller", "saved", "registers", "not", "used", "to", "pass", "return", "values", "and", "leaked", "condition", "flags", "before", "exiting", "a", "cmse_nonsecure_entry", "function", "." ]

[ "arm", "0", "1", "1", "4", "4", "0", "0", "1ULL", "0", "1", "1", "1" ]

[]

[ "<s>", "void", "AArch64BranchTargets", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "HexagonFixupHwLoops", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "fixupLoopInstrs", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "PTXTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown opcode\"", ")", ";", "case", "PTXISD", "::", "READ_PARAM", ":", "return", "\"PTXISD::READ_PARAM\"", ";", "case", "PTXISD", "::", "EXIT", ":", "return", "\"PTXISD::EXIT\"", ";", "case", "PTXISD", "::", "RET", ":", "return", "\"PTXISD::RET\"", ";", "}", "}", "</s>" ]

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

[ "PTX", "PTX", "\"Unknown opcode\"", "PTXISD::READ_PARAM", "\"PTXISD::READ_PARAM\"", "PTXISD::EXIT", "\"PTXISD::EXIT\"", "PTXISD::RET", "\"PTXISD::RET\"" ]

[]

[ "<s>", "static", "void", "output_short_suffix", "(", "FILE", "*", "file", ")", "{", "rtx_insn", "*", "insn", "=", "current_output_insn", ";", "if", "(", "arc_verify_short", "(", "insn", ",", "cfun", "->", "machine", "->", "unalign", ",", "1", ")", ")", "{", "fprintf", "(", "file", ",", "\"_s\"", ")", ";", "cfun", "->", "machine", "->", "unalign", "^=", "2", ";", "}", "extract_insn_cached", "(", "insn", ")", ";", "}", "</s>" ]

[ "When", "outputting", "an", "instruction", "(", "alternative", ")", "that", "can", "potentially", "be", "short", ",", "output", "the", "short", "suffix", "if", "the", "insn", "is", "in", "fact", "short", ",", "and", "update", "cfun-", ">", "machine-", ">", "unalign", "accordingly", "." ]

[ "arc", "1", "\"_s\"", "2" ]

[]

[ "<s>", "bool", "ARMCodeEmitter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "II", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getInstrInfo", "(", ")", ";", "TD", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getTargetData", "(", ")", ";", "JTI", "=", "(", "(", "ARMTargetMachine", "&", ")", "MF", ".", "getTarget", "(", ")", ")", ".", "getJITInfo", "(", ")", ";", "MCPEs", "=", "&", "MF", ".", "getConstantPool", "(", ")", "->", "getConstants", "(", ")", ";", "MJTEs", "=", "&", "MF", ".", "getJumpTableInfo", "(", ")", "->", "getJumpTables", "(", ")", ";", "IsPIC", "=", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ";", "JTI", "->", "Initialize", "(", "MF", ",", "IsPIC", ")", ";", "do", "{", "DOUT", "<<", "\"JITTing function '\"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"'\\n\"", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MBB", "!=", "E", ";", "++", "MBB", ")", "{", "MCE", ".", "StartMachineBasicBlock", "(", "MBB", ")", ";", "for", "(", "MachineBasicBlock", "::", "const_iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "emitInstruction", "(", "*", "I", ")", ";", "}", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"JIT relocation model must be set to static or default!\"", "ARM", "ARM", "ARM", "\"JITTing function '\"", "\"'\\n\"" ]

[]

[ "<s>", "static", "bool", "chkp_type_has_function_pointer", "(", "const_tree", "type", ")", "{", "bool", "res", "=", "false", ";", "if", "(", "POINTER_TYPE_P", "(", "type", ")", "&&", "FUNC_OR_METHOD_TYPE_P", "(", "TREE_TYPE", "(", "type", ")", ")", ")", "res", "=", "true", ";", "else", "if", "(", "RECORD_OR_UNION_TYPE_P", "(", "type", ")", ")", "{", "tree", "field", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "DECL_CHAIN", "(", "field", ")", ")", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", ")", "res", "=", "res", "||", "chkp_type_has_function_pointer", "(", "TREE_TYPE", "(", "field", ")", ")", ";", "}", "else", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "res", "=", "chkp_type_has_function_pointer", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "return", "res", ";", "}", "</s>" ]

[ "Return", "1", "if", "type", "TYPE", "is", "a", "pointer", "to", "function", "type", "or", "a", "structure", "having", "a", "pointer", "to", "function", "type", "as", "one", "of", "its", "fields", ".", "Otherwise", "return", "0", "." ]

[ "pru" ]

[]

[ "<s>", "static", "void", "mips_avoid_hazard", "(", "rtx_insn", "*", "after", ",", "rtx_insn", "*", "insn", ",", "int", "*", "hilo_delay", ",", "rtx", "*", "delayed_reg", ",", "rtx", "lo_reg", ")", "{", "rtx", "pattern", ",", "set", ";", "int", "nops", ",", "ninsns", ";", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "==", "ASM_INPUT", "||", "asm_noperands", "(", "pattern", ")", ">=", "0", ")", "cfun", "->", "machine", "->", "all_noreorder_p", "=", "false", ";", "ninsns", "=", "get_attr_length", "(", "insn", ")", "/", "4", ";", "if", "(", "ninsns", "==", "0", ")", "return", ";", "if", "(", "*", "hilo_delay", "<", "2", "&&", "reg_set_p", "(", "lo_reg", ",", "pattern", ")", ")", "nops", "=", "2", "-", "*", "hilo_delay", ";", "else", "if", "(", "*", "delayed_reg", "!=", "0", "&&", "reg_referenced_p", "(", "*", "delayed_reg", ",", "pattern", ")", ")", "nops", "=", "1", ";", "else", "nops", "=", "0", ";", "*", "hilo_delay", "+=", "nops", ";", "while", "(", "nops", "--", ">", "0", ")", "emit_insn_after", "(", "gen_hazard_nop", "(", ")", ",", "after", ")", ";", "*", "hilo_delay", "+=", "ninsns", ";", "*", "delayed_reg", "=", "0", ";", "if", "(", "INSN_CODE", "(", "insn", ")", ">=", "0", ")", "switch", "(", "get_attr_hazard", "(", "insn", ")", ")", "{", "case", "HAZARD_NONE", ":", "break", ";", "case", "HAZARD_HILO", ":", "*", "hilo_delay", "=", "0", ";", "break", ";", "case", "HAZARD_DELAY", ":", "set", "=", "single_set", "(", "insn", ")", ";", "gcc_assert", "(", "set", ")", ";", "*", "delayed_reg", "=", "SET_DEST", "(", "set", ")", ";", "break", ";", "}", "}", "</s>" ]

[ "Subroutine", "of", "mips_reorg", ".", "If", "there", "is", "a", "hazard", "between", "INSN", "and", "a", "previous", "instruction", ",", "avoid", "it", "by", "inserting", "nops", "after", "instruction", "AFTER", ".", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "describe", "the", "hazards", "that", "apply", "at", "this", "point", ".", "If", "*", "DELAYED_REG", "is", "non-null", ",", "INSN", "must", "wait", "a", "cycle", "before", "using", "the", "value", "of", "that", "register", ".", "*", "HILO_DELAY", "counts", "the", "number", "of", "instructions", "since", "the", "last", "hilo", "hazard", "(", "that", "is", ",", "the", "number", "of", "instructions", "since", "the", "last", "mflo", "or", "mfhi", ")", ".", "After", "inserting", "nops", "for", "INSN", ",", "update", "*", "DELAYED_REG", "and", "*", "HILO_DELAY", "for", "the", "next", "instruction", ".", "LO_REG", "is", "an", "rtx", "for", "the", "LO", "register", ",", "used", "in", "dependence", "checking", "." ]

[ "mips", "0", "4", "0", "2", "2", "0", "1", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "MaxAlign", "=", "MFI", "->", "getMaxAlignment", "(", ")", ";", "unsigned", "TargetAlign", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameInfo", "(", ")", "->", "getStackAlignment", "(", ")", ";", "unsigned", "AlignMask", "=", "TargetAlign", "-", "1", ";", "if", "(", "!", "DisableRedZone", "&&", "FrameSize", "<=", "224", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "!", "MFI", "->", "hasCalls", "(", ")", "&&", "(", "!", "ALIGN_STACK", "||", "MaxAlign", "<=", "TargetAlign", ")", ")", "{", "MFI", "->", "setStackSize", "(", "0", ")", ";", "return", ";", "}", "unsigned", "maxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "unsigned", "minCallFrameSize", "=", "PPCFrameInfo", "::", "getMinCallFrameSize", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "Subtarget", ".", "isMachoABI", "(", ")", ")", ";", "maxCallFrameSize", "=", "std", "::", "max", "(", "maxCallFrameSize", ",", "minCallFrameSize", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "maxCallFrameSize", "=", "(", "maxCallFrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setMaxCallFrameSize", "(", "maxCallFrameSize", ")", ";", "FrameSize", "+=", "maxCallFrameSize", ";", "FrameSize", "=", "(", "FrameSize", "+", "AlignMask", ")", "&", "~", "AlignMask", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "PowerPC", "PPC", "1", "224", "0", "PPC", "PPC" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "const", "AMDGPUTargetMachine", "&", "TM", "=", "getAMDGPUTargetMachine", "(", ")", ";", "disablePass", "(", "&", "StackMapLivenessID", ")", ";", "disablePass", "(", "&", "FuncletLayoutID", ")", ";", "disablePass", "(", "&", "PatchableFunctionID", ")", ";", "addPass", "(", "createAMDGPULowerIntrinsicsPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "r600", "||", "!", "EnableAMDGPUFunctionCalls", ")", "{", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerLegacyPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "}", "if", "(", "TM", ".", "getTargetTriple", "(", ")", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "addPass", "(", "createAMDGPUCodeGenPreparePass", "(", ")", ")", ";", "}", "addPass", "(", "createAMDGPUOpenCLImageTypeLoweringPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUOpenCLEnqueuedBlockLoweringPass", "(", ")", ")", ";", "if", "(", "TM", ".", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createInferAddressSpacesPass", "(", ")", ")", ";", "addPass", "(", "createAMDGPUPromoteAlloca", "(", ")", ")", ";", "if", "(", "EnableSROA", ")", "addPass", "(", "createSROAPass", "(", ")", ")", ";", "addStraightLineScalarOptimizationPasses", "(", ")", ";", "if", "(", "EnableAMDGPUAliasAnalysis", ")", "{", "addPass", "(", "createAMDGPUAAWrapperPass", "(", ")", ")", ";", "addPass", "(", "createExternalAAWrapperPass", "(", "[", "]", "(", "Pass", "&", "P", ",", "Function", "&", ",", "AAResults", "&", "AAR", ")", "{", "if", "(", "auto", "*", "WrapperPass", "=", "P", ".", "getAnalysisIfAvailable", "<", "AMDGPUAAWrapperPass", ">", "(", ")", ")", "AAR", ".", "addAAResult", "(", "WrapperPass", "->", "getResult", "(", ")", ")", ";", "}", ")", ")", ";", "}", "}", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addEarlyCSEOrGVNPass", "(", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

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

[]

[ "<s>", "static", "rtx", "address_offset", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "op", ")", "==", "PRE_DEC", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "PRE_MODIFY", "||", "GET_CODE", "(", "op", ")", "==", "LO_SUM", ")", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "return", "op", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Given", "an", "address", ",", "return", "a", "constant", "offset", "term", "if", "one", "exists", "." ]

[ "powerpcspe", "0", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "rs6000_legitimate_combined_insn", "(", "rtx_insn", "*", "insn", ")", "{", "int", "icode", "=", "INSN_CODE", "(", "insn", ")", ";", "if", "(", "icode", "!=", "CODE_FOR_nothing", "&&", "(", "icode", "==", "CODE_FOR_ctrsi_internal1", "||", "icode", "==", "CODE_FOR_ctrdi_internal1", "||", "icode", "==", "CODE_FOR_ctrsi_internal2", "||", "icode", "==", "CODE_FOR_ctrdi_internal2", "||", "icode", "==", "CODE_FOR_ctrsi_internal3", "||", "icode", "==", "CODE_FOR_ctrdi_internal3", "||", "icode", "==", "CODE_FOR_ctrsi_internal4", "||", "icode", "==", "CODE_FOR_ctrdi_internal4", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_LEGITIMATE_COMBINED_INSN", "hook", "." ]

[ "powerpcspe" ]

[]

[ "<s>", "bool", "ARMFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "unsigned", "PushOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STMDB_UPD", ":", "ARM", "::", "STMDB_UPD", ";", "unsigned", "PushOneOpc", "=", "AFI", "->", "isThumbFunction", "(", ")", "?", "ARM", "::", "t2STR_PRE", ":", "ARM", "::", "STR_PRE_IMM", ";", "unsigned", "FltOpc", "=", "ARM", "::", "VSTMDDB_UPD", ";", "unsigned", "NumAlignedDPRCS2Regs", "=", "AFI", "->", "getNumAlignedDPRCS2Regs", "(", ")", ";", "if", "(", "AFI", "->", "shouldSignReturnAddress", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "STI", ".", "getInstrInfo", "(", ")", "->", "get", "(", "ARM", "::", "t2PAC", ")", ")", ".", "setMIFlags", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "if", "(", "llvm", "::", "any_of", "(", "CSI", ",", "[", "]", "(", "const", "CalleeSavedInfo", "&", "C", ")", "{", "return", "C", ".", "getReg", "(", ")", "==", "ARM", "::", "FPCXTNS", ";", "}", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MI", ",", "DebugLoc", "(", ")", ",", "STI", ".", "getInstrInfo", "(", ")", "->", "get", "(", "ARM", "::", "VSTR_FPCXTNS_pre", ")", ",", "ARM", "::", "SP", ")", ".", "addReg", "(", "ARM", "::", "SP", ")", ".", "addImm", "(", "-", "4", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea1Register", ",", "0", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "PushOpc", ",", "PushOneOpc", ",", "false", ",", "&", "isARMArea2Register", ",", "0", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "emitPushInst", "(", "MBB", ",", "MI", ",", "CSI", ",", "FltOpc", ",", "0", ",", "true", ",", "&", "isARMArea3Register", ",", "NumAlignedDPRCS2Regs", ",", "MachineInstr", "::", "FrameSetup", ")", ";", "if", "(", "NumAlignedDPRCS2Regs", ")", "emitAlignedDPRCS2Spills", "(", "MBB", ",", "MI", ",", "NumAlignedDPRCS2Regs", ",", "CSI", ",", "TRI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM::t2STMDB_UPD", "ARM::STMDB_UPD", "ARM::t2STR_PRE", "ARM::STR_PRE_IMM", "ARM::VSTMDDB_UPD", "ARM::t2PAC", "ARM::FPCXTNS", "ARM::VSTR_FPCXTNS_pre", "ARM::SP", "ARM::SP", "4", "ARMCC::AL", "ARM", "0", "ARM", "0", "0", "ARM" ]

[]

[ "<s>", "static", "void", "hsa_fatal", "(", "const", "char", "*", "str", ",", "hsa_status_t", "status", ")", "{", "const", "char", "*", "hsa_error_msg", ";", "hsa_fns", ".", "hsa_status_string_fn", "(", "status", ",", "&", "hsa_error_msg", ")", ";", "fprintf", "(", "stderr", ",", "\"%s: FAILED\\nHSA Runtime message: %s\\n\"", ",", "str", ",", "hsa_error_msg", ")", ";", "exit", "(", "1", ")", ";", "}", "</s>" ]

[ "Report", "a", "fatal", "error", "STR", "together", "with", "the", "HSA", "error", "corresponding", "to", "STATUS", "and", "terminate", "execution", "of", "the", "current", "process", "." ]

[ "gcn", "\"%s: FAILED\\nHSA Runtime message: %s\\n\"", "1" ]

[]

[ "<s>", "virtual", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "GlobalBaseReg", "=", "0", ";", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "CellSPU", "0" ]

[]

[ "<s>", "static", "bool", "s390_match_ccmode_set", "(", "rtx", "set", ",", "machine_mode", "req_mode", ")", "{", "machine_mode", "set_mode", ";", "gcc_assert", "(", "GET_CODE", "(", "set", ")", "==", "SET", ")", ";", "gcc_assert", "(", "req_mode", "!=", "CCVIALLmode", "&&", "req_mode", "!=", "CCVIANYmode", "&&", "req_mode", "!=", "CCVFALLmode", "&&", "req_mode", "!=", "CCVFANYmode", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "!=", "REG", "||", "!", "CC_REGNO_P", "(", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", ")", ")", "return", "1", ";", "set_mode", "=", "GET_MODE", "(", "SET_DEST", "(", "set", ")", ")", ";", "switch", "(", "set_mode", ")", "{", "case", "E_CCZ1mode", ":", "case", "E_CCSmode", ":", "case", "E_CCSRmode", ":", "case", "E_CCUmode", ":", "case", "E_CCURmode", ":", "case", "E_CCLmode", ":", "case", "E_CCL1mode", ":", "case", "E_CCL2mode", ":", "case", "E_CCL3mode", ":", "case", "E_CCT1mode", ":", "case", "E_CCT2mode", ":", "case", "E_CCT3mode", ":", "case", "E_CCVEQmode", ":", "case", "E_CCVIHmode", ":", "case", "E_CCVIHUmode", ":", "case", "E_CCVFHmode", ":", "case", "E_CCVFHEmode", ":", "if", "(", "req_mode", "!=", "set_mode", ")", "return", "0", ";", "break", ";", "case", "E_CCZmode", ":", "if", "(", "req_mode", "!=", "CCSmode", "&&", "req_mode", "!=", "CCUmode", "&&", "req_mode", "!=", "CCTmode", "&&", "req_mode", "!=", "CCSRmode", "&&", "req_mode", "!=", "CCURmode", "&&", "req_mode", "!=", "CCZ1mode", ")", "return", "0", ";", "break", ";", "case", "E_CCAPmode", ":", "case", "E_CCANmode", ":", "if", "(", "req_mode", "!=", "CCAmode", ")", "return", "0", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "(", "GET_MODE", "(", "SET_SRC", "(", "set", ")", ")", "==", "set_mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SET", "either", "does", "n't", "set", "the", "CC", "register", ",", "or", "else", "the", "source", "and", "destination", "have", "matching", "CC", "modes", "and", "that", "CC", "mode", "is", "at", "least", "as", "constrained", "as", "REQ_MODE", "." ]

[ "s390", "1", "0", "0", "0" ]

[]

[ "<s>", "ARMTargetLowering", "::", "ConstraintType", "ARMTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "unsigned", "S", "=", "Constraint", ".", "size", "(", ")", ";", "if", "(", "S", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'l'", ":", "return", "C_RegisterClass", ";", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'h'", ":", "return", "C_RegisterClass", ";", "case", "'x'", ":", "return", "C_RegisterClass", ";", "case", "'t'", ":", "return", "C_RegisterClass", ";", "case", "'j'", ":", "return", "C_Immediate", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "}", "}", "else", "if", "(", "S", "==", "2", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'T'", ":", "return", "C_RegisterClass", ";", "case", "'U'", ":", "return", "C_Memory", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "ARM", "ARM", "ARM", "1", "0", "2", "0" ]

[]

[ "<s>", "bool", "FalkorHWPFFix", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "auto", "&", "ST", "=", "static_cast", "<", "const", "AArch64Subtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "ST", ".", "getProcFamily", "(", ")", "!=", "AArch64Subtarget", "::", "Falkor", ")", "return", "false", ";", "if", "(", "skipFunction", "(", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "ST", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "MachineLoopInfo", "&", "LI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "Modified", "=", "false", ";", "for", "(", "MachineLoop", "*", "I", ":", "LI", ")", "for", "(", "auto", "L", "=", "df_begin", "(", "I", ")", ",", "LE", "=", "df_end", "(", "I", ")", ";", "L", "!=", "LE", ";", "++", "L", ")", "if", "(", "L", "->", "isInnermost", "(", ")", ")", "runOnLoop", "(", "*", "*", "L", ",", "Fn", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

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

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

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "bool", "isPairedLdSt", "(", "const", "MachineInstr", "&", "MI", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "AArch64", "::", "LDPSi", ":", "case", "AArch64", "::", "LDPSWi", ":", "case", "AArch64", "::", "LDPDi", ":", "case", "AArch64", "::", "LDPQi", ":", "case", "AArch64", "::", "LDPWi", ":", "case", "AArch64", "::", "LDPXi", ":", "case", "AArch64", "::", "STPSi", ":", "case", "AArch64", "::", "STPDi", ":", "case", "AArch64", "::", "STPQi", ":", "case", "AArch64", "::", "STPWi", ":", "case", "AArch64", "::", "STPXi", ":", "case", "AArch64", "::", "STGPi", ":", "return", "true", ";", "}", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "a", "paired", "load/store", "." ]

[ "AArch64", "AArch64::LDPSi", "AArch64::LDPSWi", "AArch64::LDPDi", "AArch64::LDPQi", "AArch64::LDPWi", "AArch64::LDPXi", "AArch64::STPSi", "AArch64::STPDi", "AArch64::STPQi", "AArch64::STPWi", "AArch64::STPXi", "AArch64::STGPi" ]

[]

[ "<s>", "void", "OrderedRegisterList", "::", "insert", "(", "unsigned", "VR", ")", "{", "iterator", "L", "=", "llvm", "::", "lower_bound", "(", "Seq", ",", "VR", ",", "Ord", ")", ";", "if", "(", "L", "==", "Seq", ".", "end", "(", ")", ")", "Seq", ".", "push_back", "(", "VR", ")", ";", "else", "Seq", ".", "insert", "(", "L", ",", "VR", ")", ";", "unsigned", "S", "=", "Seq", ".", "size", "(", ")", ";", "if", "(", "S", ">", "MaxSize", ")", "Seq", ".", "resize", "(", "MaxSize", ")", ";", "assert", "(", "Seq", ".", "size", "(", ")", "<=", "MaxSize", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "NyuziInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "bool", "destIsScalar", "=", "Nyuzi", "::", "GPR32RegClass", ".", "contains", "(", "DestReg", ")", ";", "bool", "srcIsScalar", "=", "Nyuzi", "::", "GPR32RegClass", ".", "contains", "(", "SrcReg", ")", ";", "unsigned", "operation", ";", "if", "(", "destIsScalar", "&&", "srcIsScalar", ")", "operation", "=", "Nyuzi", "::", "MOVESS", ";", "else", "if", "(", "!", "destIsScalar", "&&", "srcIsScalar", ")", "operation", "=", "Nyuzi", "::", "MOVEVSI", ";", "else", "if", "(", "!", "destIsScalar", "&&", "!", "srcIsScalar", ")", "operation", "=", "Nyuzi", "::", "MOVEVV", ";", "else", "llvm_unreachable", "(", "\"unsupported physical reg copy type\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "operation", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "Nyuzi", "Nyuzi", "Nyuzi::GPR32RegClass", "Nyuzi::GPR32RegClass", "Nyuzi::MOVESS", "Nyuzi::MOVEVSI", "Nyuzi::MOVEVV", "\"unsupported physical reg copy type\"" ]

[]

[ "<s>", "static", "void", "aarch64_option_print", "(", "FILE", "*", "file", ",", "int", "indent", ",", "struct", "cl_target_option", "*", "ptr", ")", "{", "const", "struct", "processor", "*", "cpu", "=", "aarch64_get_tune_cpu", "(", "ptr", "->", "x_explicit_tune_core", ")", ";", "unsigned", "long", "isa_flags", "=", "ptr", "->", "x_aarch64_isa_flags", ";", "const", "struct", "processor", "*", "arch", "=", "aarch64_get_arch", "(", "ptr", "->", "x_explicit_arch", ")", ";", "std", "::", "string", "extension", "=", "aarch64_get_extension_string_for_isa_flags", "(", "isa_flags", ",", "arch", "->", "flags", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected tune = %s\\n\"", ",", "indent", ",", "\"\"", ",", "cpu", "->", "name", ")", ";", "fprintf", "(", "file", ",", "\"%*sselected arch = %s%s\\n\"", ",", "indent", ",", "\"\"", ",", "arch", "->", "name", ",", "extension", ".", "c_str", "(", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_PRINT", "." ]

[ "aarch64", "\"%*sselected tune = %s\\n\"", "\"\"", "\"%*sselected arch = %s%s\\n\"", "\"\"" ]

[]

[ "<s>", "void", "xstormy16_expand_call", "(", "rtx", "retval", ",", "rtx", "dest", ",", "rtx", "counter", ")", "{", "rtx", "call", ",", "temp", ";", "machine_mode", "mode", ";", "gcc_assert", "(", "MEM_P", "(", "dest", ")", ")", ";", "dest", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "dest", ")", "&&", "!", "REG_P", "(", "dest", ")", ")", "dest", "=", "force_reg", "(", "Pmode", ",", "dest", ")", ";", "if", "(", "retval", "==", "NULL", ")", "mode", "=", "VOIDmode", ";", "else", "mode", "=", "GET_MODE", "(", "retval", ")", ";", "call", "=", "gen_rtx_CALL", "(", "mode", ",", "gen_rtx_MEM", "(", "FUNCTION_MODE", ",", "dest", ")", ",", "counter", ")", ";", "if", "(", "retval", ")", "call", "=", "gen_rtx_SET", "(", "retval", ",", "call", ")", ";", "if", "(", "!", "CONSTANT_P", "(", "dest", ")", ")", "{", "temp", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_move_insn", "(", "temp", ",", "const0_rtx", ")", ";", "}", "else", "temp", "=", "const0_rtx", ";", "call", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "2", ",", "call", ",", "gen_rtx_USE", "(", "VOIDmode", ",", "temp", ")", ")", ")", ";", "emit_call_insn", "(", "call", ")", ";", "}", "</s>" ]

[ "Expander", "for", "the", "`", "call", "'", "patterns", ".", "INDEX", "is", "the", "index", "of", "the", "switch", "statement", ".", "LOWER_BOUND", "is", "a", "CONST_INT", "that", "is", "the", "value", "of", "INDEX", "corresponding", "to", "the", "first", "table", "entry", ".", "RANGE", "is", "the", "number", "of", "table", "entries", ".", "TABLE", "is", "an", "ADDR_VEC", "that", "is", "the", "jump", "table", ".", "DEFAULT_LABEL", "is", "the", "address", "to", "branch", "to", "if", "INDEX", "is", "outside", "the", "range", "LOWER_BOUND", "to", "LOWER_BOUND+RANGE-1", "." ]

[ "stormy16", "0", "2" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "isComplex", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "HexagonInstrInfo", "*", "QII", "=", "(", "const", "HexagonInstrInfo", "*", ")", "TII", ";", "if", "(", "!", "(", "isTC1", "(", "MI", ")", ")", "&&", "!", "(", "QII", "->", "isTC2Early", "(", "MI", ")", ")", "&&", "!", "(", "MI", "->", "getDesc", "(", ")", ".", "mayLoad", "(", ")", ")", "&&", "!", "(", "MI", "->", "getDesc", "(", ")", ".", "mayStore", "(", ")", ")", "&&", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "!=", "Hexagon", "::", "S2_allocframe", ")", "&&", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", "!=", "Hexagon", "::", "L2_deallocframe", ")", "&&", "!", "(", "QII", "->", "isMemOp", "(", "MI", ")", ")", "&&", "!", "(", "MI", "->", "isBranch", "(", ")", ")", "&&", "!", "(", "MI", "->", "isReturn", "(", ")", ")", "&&", "!", "MI", "->", "isCall", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "the", "location", "is", "computed", "on", "the", "expression", "stack", ",", "meaning", "it", "can", "not", "be", "a", "simple", "register", "location", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon::S2_allocframe", "Hexagon::L2_deallocframe" ]

[]

[ "<s>", "const", "MCInstrDesc", "&", "getDesc", "(", "void", ")", "const", "{", "return", "*", "MCID", ";", "}", "</s>" ]

[ "Returns", "the", "target", "instruction", "descriptor", "of", "this", "MachineInstr", "." ]

[ "Hexagon" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "Subtarget", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", "&&", "!", "Subtarget", ".", "isDarwinABI", "(", ")", ")", "continue", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "0", "0", "PPC::VRSAVE", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "bool", "X86ATTAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "this", "->", "MF", "=", "&", "MF", ";", "unsigned", "CC", "=", "F", "->", "getCallingConv", "(", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "O", "<<", "\"\\n\\n\"", ";", "if", "(", "CC", "==", "CallingConv", "::", "X86_StdCall", "||", "CC", "==", "CallingConv", "::", "X86_FastCall", ")", "FunctionInfoMap", "[", "F", "]", "=", "*", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "EmitConstantPool", "(", "MF", ".", "getConstantPool", "(", ")", ")", ";", "if", "(", "F", "->", "hasDLLExportLinkage", "(", ")", ")", "DLLExportedFns", ".", "insert", "(", "Mang", "->", "makeNameProper", "(", "F", "->", "getName", "(", ")", ",", "\"\"", ")", ")", ";", "emitFunctionHeader", "(", "MF", ")", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", "||", "TAI", "->", "doesSupportExceptionHandling", "(", ")", ")", "DW", "->", "BeginFunction", "(", "&", "MF", ")", ";", "bool", "hasAnyRealCode", "=", "false", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "VerboseAsm", "&&", "(", "I", "->", "pred_empty", "(", ")", "||", "I", "->", "isOnlyReachableByFallthrough", "(", ")", ")", ")", "{", "}", "else", "{", "printBasicBlockLabel", "(", "I", ",", "true", ",", "true", ",", "VerboseAsm", ")", ";", "O", "<<", "'\\n'", ";", "}", "for", "(", "MachineBasicBlock", "::", "const_iterator", "II", "=", "I", "->", "begin", "(", ")", ",", "IE", "=", "I", "->", "end", "(", ")", ";", "II", "!=", "IE", ";", "++", "II", ")", "{", "if", "(", "!", "II", "->", "isLabel", "(", ")", ")", "hasAnyRealCode", "=", "true", ";", "printMachineInstruction", "(", "II", ")", ";", "}", "}", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", "&&", "!", "hasAnyRealCode", ")", "{", "O", "<<", "\"\\tnop\\n\"", ";", "}", "if", "(", "TAI", "->", "hasDotTypeDotSizeDirective", "(", ")", ")", "O", "<<", "\"\\t.size\\t\"", "<<", "CurrentFnName", "<<", "\", .-\"", "<<", "CurrentFnName", "<<", "'\\n'", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", ")", "DW", "->", "EndFunction", "(", "&", "MF", ")", ";", "EmitJumpTableInfo", "(", "MF", ".", "getJumpTableInfo", "(", ")", ",", "MF", ")", ";", "O", ".", "flush", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\\n\\n\"", "X86", "X86", "X86", "\"\"", "\"\\tnop\\n\"", "\"\\t.size\\t\"", "\", .-\"" ]

[]