Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "int", "crx_hard_regno_mode_ok", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "CC_REGNUM", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ")", "return", "0", ";", "if", "(", "HILO_REGNO_P", "(", "regno", ")", ")", "return", "mode", "==", "SImode", "||", "mode", "==", "DImode", ";", "return", "1", ";", "}", "</s>" ]

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

[ "crx", "0", "1" ]

[]

[ "<s>", "static", "bool", "arm_array_mode_supported_p", "(", "machine_mode", "mode", ",", "unsigned", "HOST_WIDE_INT", "nelems", ")", "{", "if", "(", "TARGET_NEON", "&&", "!", "BYTES_BIG_ENDIAN", "&&", "(", "VALID_NEON_DREG_MODE", "(", "mode", ")", "||", "VALID_NEON_QREG_MODE", "(", "mode", ")", ")", "&&", "(", "nelems", ">=", "2", "&&", "nelems", "<=", "4", ")", ")", "return", "true", ";", "if", "(", "TARGET_HAVE_MVE", "&&", "!", "BYTES_BIG_ENDIAN", "&&", "VALID_MVE_MODE", "(", "mode", ")", "&&", "(", "nelems", "==", "2", "||", "nelems", "==", "4", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "array_mode_supported_p", "." ]

[ "arm", "2", "4", "2", "4" ]

[]

[ "<s>", "static", "bool", "ia64_return_in_memory", "(", "tree", "valtype", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", ";", "enum", "machine_mode", "hfa_mode", ";", "HOST_WIDE_INT", "byte_size", ";", "mode", "=", "TYPE_MODE", "(", "valtype", ")", ";", "byte_size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "mode", "==", "BLKmode", ")", "{", "byte_size", "=", "int_size_in_bytes", "(", "valtype", ")", ";", "if", "(", "byte_size", "<", "0", ")", "return", "true", ";", "}", "hfa_mode", "=", "hfa_element_mode", "(", "valtype", ",", "0", ")", ";", "if", "(", "hfa_mode", "!=", "VOIDmode", ")", "{", "int", "hfa_size", "=", "GET_MODE_SIZE", "(", "hfa_mode", ")", ";", "if", "(", "byte_size", "/", "hfa_size", ">", "MAX_ARGUMENT_SLOTS", ")", "return", "true", ";", "else", "return", "false", ";", "}", "else", "if", "(", "byte_size", ">", "UNITS_PER_WORD", "*", "MAX_INT_RETURN_SLOTS", ")", "return", "true", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Return", "1", "if", "function", "return", "value", "returned", "in", "memory", ".", "Return", "0", "if", "it", "is", "in", "a", "register", "." ]

[ "ia64", "0", "0" ]

[]

[ "<s>", "rtx", "rs6000_allocate_stack_temp", "(", "machine_mode", "mode", ",", "bool", "offsettable_p", ",", "bool", "reg_reg_p", ")", "{", "rtx", "stack", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "rtx", "addr", "=", "XEXP", "(", "stack", ",", "0", ")", ";", "int", "strict_p", "=", "(", "reload_in_progress", "||", "reload_completed", ")", ";", "if", "(", "!", "legitimate_indirect_address_p", "(", "addr", ",", "strict_p", ")", ")", "{", "if", "(", "offsettable_p", "&&", "!", "rs6000_legitimate_offset_address_p", "(", "mode", ",", "addr", ",", "strict_p", ",", "true", ")", ")", "stack", "=", "replace_equiv_address", "(", "stack", ",", "copy_addr_to_reg", "(", "addr", ")", ")", ";", "else", "if", "(", "reg_reg_p", "&&", "!", "legitimate_indexed_address_p", "(", "addr", ",", "strict_p", ")", ")", "stack", "=", "replace_equiv_address", "(", "stack", ",", "copy_addr_to_reg", "(", "addr", ")", ")", ";", "}", "return", "stack", ";", "}", "</s>" ]

[ "Allocate", "a", "stack", "temp", "and", "fixup", "the", "address", "so", "it", "meets", "the", "particular", "memory", "requirements", "(", "either", "offetable", "or", "REG+REG", "addressing", ")", "." ]

[ "rs6000", "0" ]

[]

[ "<s>", "MVT", "SITargetLowering", "::", "getRegisterTypeForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "AMDGPU_KERNEL", ")", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "32", ")", "return", "ScalarVT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "Size", ">", "32", ")", "return", "MVT", "::", "i32", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "return", "VT", ".", "isInteger", "(", ")", "?", "MVT", "::", "v2i16", ":", "MVT", "::", "v2f16", ";", "}", "else", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">", "32", ")", "return", "MVT", "::", "i32", ";", "return", "TargetLowering", "::", "getRegisterTypeForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "combinations", "of", "ABIs", ",", "Targets", "and", "features", "require", "that", "types", "are", "legal", "for", "some", "operations", "and", "not", "for", "other", "operations", "." ]

[ "AMDGPU", "SI", "AMDGPU", "32", "32", "MVT::i32", "16", "MVT::v2i16", "MVT::v2f16", "32", "MVT::i32" ]

[]

[ "<s>", "void", "GCNHazardRecognizer", "::", "Reset", "(", ")", "{", "EmittedInstrs", ".", "clear", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "Mips16RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "DebugLoc", "DL", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "TII", ".", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "Mips", "::", "T0", ",", "Reg", ",", "true", ")", ";", "TII", ".", "copyPhysReg", "(", "MBB", ",", "UseMI", ",", "DL", ",", "Reg", ",", "Mips", "::", "T0", ",", "true", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "Mips", "Mips", "Mips::T0", "Mips::T0" ]

[]

[ "<s>", "static", "bool", "mips_interrupt_extra_call_saved_reg_p", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "(", "ISA_HAS_HILO", "||", "TARGET_DSP", ")", "&&", "MD_REG_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_DSP", "&&", "DSP_ACC_REG_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "cfun", "->", "machine", "->", "use_shadow_register_set", "==", "SHADOW_SET_NO", ")", "{", "if", "(", "regno", "==", "GP_REG_FIRST", ")", "return", "false", ";", "if", "(", "KERNEL_REG_P", "(", "regno", ")", ")", "return", "false", ";", "if", "(", "regno", "==", "STACK_POINTER_REGNUM", ")", "return", "false", ";", "return", "call_really_used_regs", "[", "regno", "]", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "is", "a", "register", "that", "is", "ordinarily", "call-clobbered", "but", "must", "nevertheless", "be", "preserved", "by", "an", "interrupt", "handler", "." ]

[ "mips" ]

[]

[ "<s>", "void", "ARCFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Process function before frame finalized: \"", "<<", "MF", ".", "getFunction", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Current stack size: \"", "<<", "MFI", ".", "getStackSize", "(", ")", "<<", "\"\\n\"", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "&", "ARC", "::", "GPR32RegClass", ";", "if", "(", "MFI", ".", "hasStackObjects", "(", ")", ")", "{", "int", "RegScavFI", "=", "MFI", ".", "CreateStackObject", "(", "RegInfo", "->", "getSpillSize", "(", "*", "RC", ")", ",", "RegInfo", "->", "getSpillAlignment", "(", "*", "RC", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "RegScavFI", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created scavenging index RegScavFI=\"", "<<", "RegScavFI", "<<", "\"\\n\"", ")", ";", "}", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Process function before frame finalized: \"", "\"\\n\"", "\"Current stack size: \"", "\"\\n\"", "ARC::GPR32RegClass", "\"Created scavenging index RegScavFI=\"", "\"\\n\"" ]

[]

[ "<s>", "const", "AArch64Subtarget", "*", "AArch64TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "CPU", "+", "FS", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "AArch64Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Subtarget", ".", "isLittleEndian", "(", ")", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "AArch64GISelActualAccessor", "*", "GISel", "=", "new", "AArch64GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "AArch64CallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "new", "AArch64RegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "\"target-cpu\"", "\"target-features\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "int", "avr_hard_regno_call_part_clobbered", "(", "unsigned", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "!", "avr_hard_regno_mode_ok", "(", "regno", ",", "mode", ")", ")", "return", "0", ";", "return", "(", "(", "regno", "<", "18", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "18", ")", "||", "(", "regno", "<", "REG_Y", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Y", ")", "||", "(", "regno", "<", "REG_Z", "&&", "regno", "+", "GET_MODE_SIZE", "(", "mode", ")", ">", "REG_Z", ")", ")", ";", "}", "</s>" ]

[ "Implement", "`", "HARD_REGNO_CALL_PART_CLOBBERED", "'", "." ]

[ "avr", "0", "18", "18" ]

[]

[ "<s>", "static", "int", "cris_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "rclass", "ATTRIBUTE_UNUSED", ",", "bool", "in", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "return", "4", ";", "else", "return", "6", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_MEMORY_MOVE_COST", ".", "This", "is", "n't", "strictly", "correct", "for", "v0", "..", "3", "in", "buswidth-8bit", "mode", ",", "but", "should", "suffice", "." ]

[ "cris", "4", "6" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"reloc_pcrel_4byte\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_pcrel_1byte\"", ",", "0", ",", "1", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_pcrel_2byte\"", ",", "0", ",", "2", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_movq_load\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCCodeEmitter", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "X86", "\"reloc_pcrel_4byte\"", "0", "4", "8", "\"reloc_pcrel_1byte\"", "0", "1", "8", "\"reloc_pcrel_2byte\"", "0", "2", "8", "\"reloc_riprel_4byte\"", "0", "4", "8", "\"reloc_riprel_4byte_movq_load\"", "0", "4", "8", "\"Invalid kind!\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "FFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "CFSize", "=", "FFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "CFSize", ">=", "(", "(", "1", "<<", "12", ")", "-", "1", ")", "/", "2", ")", "return", "false", ";", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "ARM", "ARM", "1", "12", "1", "2" ]

[]

[ "<s>", "bool", "MipsTargetELFStreamer", "::", "emitDirectiveCpRestore", "(", "int", "Offset", ",", "function_ref", "<", "unsigned", "(", ")", ">", "GetATReg", ",", "SMLoc", "IDLoc", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "{", "MipsTargetStreamer", "::", "emitDirectiveCpRestore", "(", "Offset", ",", "GetATReg", ",", "IDLoc", ",", "STI", ")", ";", "if", "(", "!", "Pic", "||", "(", "getABI", "(", ")", ".", "IsN32", "(", ")", "||", "getABI", "(", ")", ".", "IsN64", "(", ")", ")", ")", "return", "true", ";", "emitStoreWithImmOffset", "(", "Mips", "::", "SW", ",", "GPReg", ",", "Mips", "::", "SP", ",", "Offset", ",", "GetATReg", ",", "IDLoc", ",", "STI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Emit", "a", ".cprestore", "directive", "." ]

[ "Mips", "Mips", "Mips", "Mips::SW", "Mips::SP" ]

[]

[ "<s>", "BitVector", "SystemZRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "SystemZFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "Reserved", ".", "set", "(", "SystemZ", "::", "R11D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R11L", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R11H", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R10Q", ")", ";", "}", "Reserved", ".", "set", "(", "SystemZ", "::", "R15D", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15L", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R15H", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "R14Q", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "A0", ")", ";", "Reserved", ".", "set", "(", "SystemZ", "::", "A1", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ::R11D", "SystemZ::R11L", "SystemZ::R11H", "SystemZ::R10Q", "SystemZ::R15D", "SystemZ::R15L", "SystemZ::R15H", "SystemZ::R14Q", "SystemZ::A0", "SystemZ::A1" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"convert address space of alloca'ed memory to local\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"convert address space of alloca'ed memory to local\"" ]

[]

[ "<s>", "static", "LLT", "getPow2VectorType", "(", "LLT", "Ty", ")", "{", "unsigned", "NElts", "=", "Ty", ".", "getNumElements", "(", ")", ";", "unsigned", "Pow2NElts", "=", "1", "<<", "Log2_32_Ceil", "(", "NElts", ")", ";", "return", "Ty", ".", "changeNumElements", "(", "Pow2NElts", ")", ";", "}", "</s>" ]

[ "Widens", "the", "length", "of", "the", "given", "vector", "MVT", "up", "to", "the", "nearest", "power", "of", "2", "and", "returns", "that", "type", "." ]

[ "AMDGPU", "1" ]

[]

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

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

[ "PowerPC" ]

[]

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

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

[ "XNCM", "XNCM" ]

[]

[ "<s>", "bool", "MipsDAGToDAGISel", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Ret", "=", "SelectionDAGISel", "::", "runOnMachineFunction", "(", "MF", ")", ";", "ProcessFunctionAfterISel", "(", "MF", ")", ";", "return", "Ret", ";", "}", "</s>" ]

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

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "mep_trampoline_init", "(", "rtx", "m_tramp", ",", "tree", "fndecl", ",", "rtx", "static_chain", ")", "{", "rtx", "addr", "=", "XEXP", "(", "m_tramp", ",", "0", ")", ";", "rtx", "fnaddr", "=", "XEXP", "(", "DECL_RTL", "(", "fndecl", ")", ",", "0", ")", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "\"__mep_trampoline_helper\"", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "3", ",", "addr", ",", "Pmode", ",", "fnaddr", ",", "Pmode", ",", "static_chain", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Trampolines", "." ]

[ "mep", "0", "0", "\"__mep_trampoline_helper\"", "3" ]

[]

[ "<s>", "const", "HexagonInstrInfo", "*", "getInstrInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "label_mentioned_p", "(", "rtx", "x", ")", "{", "const", "char", "*", "fmt", ";", "int", "i", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "return", "0", ";", "fmt", "=", "GET_RTX_FORMAT", "(", "GET_CODE", "(", "x", ")", ")", ";", "for", "(", "i", "=", "GET_RTX_LENGTH", "(", "GET_CODE", "(", "x", ")", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "fmt", "[", "i", "]", "==", "'E'", ")", "{", "int", "j", ";", "for", "(", "j", "=", "XVECLEN", "(", "x", ",", "i", ")", "-", "1", ";", "j", ">=", "0", ";", "j", "--", ")", "if", "(", "label_mentioned_p", "(", "XVECEXP", "(", "x", ",", "i", ",", "j", ")", ")", ")", "return", "1", ";", "}", "else", "if", "(", "fmt", "[", "i", "]", "==", "'e'", "&&", "label_mentioned_p", "(", "XEXP", "(", "x", ",", "i", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "references", "a", "LABEL_REF", "." ]

[ "microblaze", "1", "0", "1", "0", "1", "0", "1", "1", "0" ]

[]

[ "<s>", "void", "SICAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "default", ":", "FullSize", "=", "4", ";", "break", ";", "}", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "(", "uint64_t", ")", "(", "(", "uint8_t", ")", "Data", "[", "Offset", "+", "Idx", "]", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "(", "uint64_t", ")", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittle", "?", "i", ":", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "(", "uint8_t", ")", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

[ "SIC", "SIC", "7", "8", "4", "0", "0", "1", "8", "1", "64", "0", "1", "8", "0xff" ]

[]

[ "<s>", "void", "PPCRegisterInfo", "::", "adjustStackMapLiveOutMask", "(", "uint32_t", "*", "Mask", ")", "const", "{", "unsigned", "PseudoRegs", "[", "]", "=", "{", "PPC", "::", "ZERO", ",", "PPC", "::", "ZERO8", ",", "PPC", "::", "RM", "}", ";", "for", "(", "unsigned", "i", "=", "0", ",", "ie", "=", "array_lengthof", "(", "PseudoRegs", ")", ";", "i", "!=", "ie", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "PseudoRegs", "[", "i", "]", ";", "Mask", "[", "Reg", "/", "32", "]", "&=", "~", "(", "1u", "<<", "(", "Reg", "%", "32", ")", ")", ";", "}", "}", "</s>" ]

[ "Prior", "to", "adding", "the", "live-out", "mask", "to", "a", "stackmap", "or", "patchpoint", "instruction", ",", "provide", "the", "target", "the", "opportunity", "to", "adjust", "it", "(", "mainly", "to", "remove", "pseudo-registers", "that", "should", "be", "ignored", ")", "." ]

[ "PowerPC", "PPC", "PPC::ZERO", "PPC::ZERO8", "PPC::RM", "0", "32", "1u", "32" ]

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Idx", ")", "const", "{", "if", "(", "Idx", "==", "AMDGPU", "::", "RegisterPressureSets", "::", "VGPR_32", "||", "Idx", "==", "AMDGPU", "::", "RegisterPressureSets", "::", "AGPR_32", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "VGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "if", "(", "Idx", "==", "AMDGPU", "::", "RegisterPressureSets", "::", "SReg_32", ")", "return", "getRegPressureLimit", "(", "&", "AMDGPU", "::", "SGPR_32RegClass", ",", "const_cast", "<", "MachineFunction", "&", ">", "(", "MF", ")", ")", ";", "llvm_unreachable", "(", "\"Unexpected register pressure set!\"", ")", ";", "}", "</s>" ]

[ "Get", "the", "register", "unit", "pressure", "limit", "for", "this", "dimension", "." ]

[ "AMDGPU", "SI", "AMDGPU::RegisterPressureSets", "AMDGPU::RegisterPressureSets", "AMDGPU::VGPR_32RegClass", "AMDGPU::RegisterPressureSets", "AMDGPU::SGPR_32RegClass", "\"Unexpected register pressure set!\"" ]

[]

[ "<s>", "bool", "MBlazePassConfig", "::", "addPreEmitPass", "(", ")", "{", "PM", "->", "add", "(", "createMBlazeDelaySlotFillerPass", "(", "getMBlazeTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze" ]

[]

[ "<s>", "void", "HexagonEarlyIfConversion", "::", "removeBlock", "(", "MachineBasicBlock", "*", "B", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Removing block \"", "<<", "PrintMB", "(", "B", ")", "<<", "\"\\n\"", ")", ";", "MachineDomTreeNode", "*", "N", "=", "MDT", "->", "getNode", "(", "B", ")", ";", "MachineDomTreeNode", "*", "IDN", "=", "N", "->", "getIDom", "(", ")", ";", "if", "(", "IDN", ")", "{", "MachineBasicBlock", "*", "IDB", "=", "IDN", "->", "getBlock", "(", ")", ";", "typedef", "GraphTraits", "<", "MachineDomTreeNode", "*", ">", "GTN", ";", "typedef", "SmallVector", "<", "MachineDomTreeNode", "*", ",", "4", ">", "DTNodeVectType", ";", "DTNodeVectType", "Cn", "(", "GTN", "::", "child_begin", "(", "N", ")", ",", "GTN", "::", "child_end", "(", "N", ")", ")", ";", "for", "(", "DTNodeVectType", "::", "iterator", "I", "=", "Cn", ".", "begin", "(", ")", ",", "E", "=", "Cn", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "SB", "=", "(", "*", "I", ")", "->", "getBlock", "(", ")", ";", "MDT", "->", "changeImmediateDominator", "(", "SB", ",", "IDB", ")", ";", "}", "}", "while", "(", "B", "->", "succ_size", "(", ")", ">", "0", ")", "B", "->", "removeSuccessor", "(", "B", "->", "succ_begin", "(", ")", ")", ";", "for", "(", "auto", "I", "=", "B", "->", "pred_begin", "(", ")", ",", "E", "=", "B", "->", "pred_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "(", "*", "I", ")", "->", "removeSuccessor", "(", "B", ",", "true", ")", ";", "Deleted", ".", "insert", "(", "B", ")", ";", "MDT", "->", "eraseNode", "(", "B", ")", ";", "MFN", "->", "erase", "(", "B", "->", "getIterator", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "completely", "removes", "BB", "from", "all", "data", "structures", ",", "including", "all", "of", "the", "Loop", "objects", "it", "is", "nested", "in", "and", "our", "mapping", "from", "MachineBasicBlocks", "to", "loops", "." ]

[ "Hexagon", "Hexagon", "\"Removing block \"", "\"\\n\"", "4", "0" ]

[]

[ "<s>", "unsigned", "X86RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "FramePtr", ":", "StackPtr", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "CSKYAsmParser", "::", "processInstruction", "(", "MCInst", "&", "Inst", ",", "SMLoc", "IDLoc", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "switch", "(", "Inst", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "CSKY", "::", "LDQ32", ":", "case", "CSKY", "::", "STQ32", ":", "if", "(", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R4", "||", "Inst", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "!=", "CSKY", "::", "R7", ")", "{", "return", "Error", "(", "IDLoc", ",", "\"Register sequence is not valid. 'r4-r7' expected\"", ")", ";", "}", "Inst", ".", "setOpcode", "(", "Inst", ".", "getOpcode", "(", ")", "==", "CSKY", "::", "LDQ32", "?", "CSKY", "::", "LDM32", ":", "CSKY", "::", "STM32", ")", ";", "break", ";", "case", "CSKY", "::", "SEXT32", ":", "case", "CSKY", "::", "ZEXT32", ":", "if", "(", "Inst", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "break", ";", "case", "CSKY", "::", "INS32", ":", "if", "(", "Inst", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "<", "Inst", ".", "getOperand", "(", "4", ")", ".", "getImm", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"msb must be greater or equal to lsb\"", ")", ";", "break", ";", "case", "CSKY", "::", "IDLY32", ":", "if", "(", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ">", "32", "||", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", "<", "0", ")", "return", "Error", "(", "IDLoc", ",", "\"n must be in range [0,32]\"", ")", ";", "break", ";", "case", "CSKY", "::", "ADDC32", ":", "case", "CSKY", "::", "SUBC32", ":", "case", "CSKY", "::", "ADDC16", ":", "case", "CSKY", "::", "SUBC16", ":", "Inst", ".", "erase", "(", "std", "::", "next", "(", "Inst", ".", "begin", "(", ")", ")", ")", ";", "Inst", ".", "erase", "(", "std", "::", "prev", "(", "Inst", ".", "end", "(", ")", ")", ")", ";", "Inst", ".", "insert", "(", "std", "::", "next", "(", "Inst", ".", "begin", "(", ")", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "Inst", ".", "insert", "(", "Inst", ".", "end", "(", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "break", ";", "case", "CSKY", "::", "CMPNEI32", ":", "case", "CSKY", "::", "CMPNEI16", ":", "case", "CSKY", "::", "CMPNE32", ":", "case", "CSKY", "::", "CMPNE16", ":", "case", "CSKY", "::", "CMPHSI32", ":", "case", "CSKY", "::", "CMPHSI16", ":", "case", "CSKY", "::", "CMPHS32", ":", "case", "CSKY", "::", "CMPHS16", ":", "case", "CSKY", "::", "CMPLTI32", ":", "case", "CSKY", "::", "CMPLTI16", ":", "case", "CSKY", "::", "CMPLT32", ":", "case", "CSKY", "::", "CMPLT16", ":", "case", "CSKY", "::", "BTSTI32", ":", "Inst", ".", "erase", "(", "Inst", ".", "begin", "(", ")", ")", ";", "Inst", ".", "insert", "(", "Inst", ".", "begin", "(", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "break", ";", "case", "CSKY", "::", "MVCV32", ":", "Inst", ".", "erase", "(", "std", "::", "next", "(", "Inst", ".", "begin", "(", ")", ")", ")", ";", "Inst", ".", "insert", "(", "Inst", ".", "end", "(", ")", ",", "MCOperand", "::", "createReg", "(", "CSKY", "::", "C", ")", ")", ";", "break", ";", "}", "emitToStreamer", "(", "Out", ",", "Inst", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY::LDQ32", "CSKY::STQ32", "1", "CSKY::R4", "2", "CSKY::R7", "\"Register sequence is not valid. 'r4-r7' expected\"", "CSKY::LDQ32", "CSKY::LDM32", "CSKY::STM32", "CSKY::SEXT32", "CSKY::ZEXT32", "2", "3", "\"msb must be greater or equal to lsb\"", "CSKY::INS32", "3", "4", "\"msb must be greater or equal to lsb\"", "CSKY::IDLY32", "0", "32", "0", "0", "\"n must be in range [0,32]\"", "CSKY::ADDC32", "CSKY::SUBC32", "CSKY::ADDC16", "CSKY::SUBC16", "CSKY::C", "CSKY::C", "CSKY::CMPNEI32", "CSKY::CMPNEI16", "CSKY::CMPNE32", "CSKY::CMPNE16", "CSKY::CMPHSI32", "CSKY::CMPHSI16", "CSKY::CMPHS32", "CSKY::CMPHS16", "CSKY::CMPLTI32", "CSKY::CMPLTI16", "CSKY::CMPLT32", "CSKY::CMPLT16", "CSKY::BTSTI32", "CSKY::C", "CSKY::MVCV32", "CSKY::C" ]

[]

[ "<s>", "void", "ARM64_ELFTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64" ]

[]

[ "<s>", "static", "void", "workaround_uninit_method_3", "(", "void", ")", "{", "auto_bitmap", "not_pseudo", ";", "bitmap_set_range", "(", "not_pseudo", ",", "0", ",", "LAST_VIRTUAL_REGISTER", ")", ";", "basic_block", "bb", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "if", "(", "single_pred_p", "(", "bb", ")", ")", "continue", ";", "auto_bitmap", "bb_pseudo_uninit", ";", "bitmap_and_compl", "(", "bb_pseudo_uninit", ",", "DF_LIVE_IN", "(", "bb", ")", ",", "DF_MIR_IN", "(", "bb", ")", ")", ";", "bitmap_and_compl_into", "(", "bb_pseudo_uninit", ",", "not_pseudo", ")", ";", "bitmap_iterator", "iterator", ";", "unsigned", "ix", ";", "EXECUTE_IF_SET_IN_BITMAP", "(", "bb_pseudo_uninit", ",", "0", ",", "ix", ",", "iterator", ")", "{", "bool", "have_false", "=", "false", ";", "bool", "have_true", "=", "false", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "{", "if", "(", "bitmap_bit_p", "(", "DF_LIVE_OUT", "(", "e", "->", "src", ")", ",", "ix", ")", ")", "have_true", "=", "true", ";", "else", "have_false", "=", "true", ";", "}", "if", "(", "have_false", "^", "have_true", ")", "continue", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "{", "if", "(", "bitmap_bit_p", "(", "DF_LIVE_OUT", "(", "e", "->", "src", ")", ",", "ix", ")", ")", "continue", ";", "rtx", "reg", "=", "regno_reg_rtx", "[", "ix", "]", ";", "gcc_assert", "(", "CONST0_RTX", "(", "GET_MODE", "(", "reg", ")", ")", ")", ";", "start_sequence", "(", ")", ";", "emit_move_insn", "(", "reg", ",", "CONST0_RTX", "(", "GET_MODE", "(", "reg", ")", ")", ")", ";", "rtx_insn", "*", "inits", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "dump_file", "&&", "(", "dump_flags", "&", "TDF_DETAILS", ")", ")", "for", "(", "rtx_insn", "*", "init", "=", "inits", ";", "init", "!=", "NULL", ";", "init", "=", "NEXT_INSN", "(", "init", ")", ")", "fprintf", "(", "dump_file", ",", "\"Missing init of reg %u inserted on edge: %d -> %d:\"", "\" insn %u\\n\"", ",", "ix", ",", "e", "->", "src", "->", "index", ",", "e", "->", "dest", "->", "index", ",", "INSN_UID", "(", "init", ")", ")", ";", "insert_insn_on_edge", "(", "inits", ",", "e", ")", ";", "}", "}", "}", "if", "(", "nvptx_comment", ")", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "if", "(", "single_pred_p", "(", "bb", ")", ")", "continue", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "bb", "->", "preds", ")", "{", "if", "(", "e", "->", "insns", ".", "r", "==", "NULL_RTX", ")", "continue", ";", "start_sequence", "(", ")", ";", "emit_insn", "(", "gen_comment", "(", "\"Start: Added by -minit-regs=3:\"", ")", ")", ";", "emit_insn", "(", "e", "->", "insns", ".", "r", ")", ";", "emit_insn", "(", "gen_comment", "(", "\"End: Added by -minit-regs=3:\"", ")", ")", ";", "e", "->", "insns", ".", "r", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "}", "}", "commit_edge_insertions", "(", ")", ";", "}", "</s>" ]

[ "Find", "uses", "of", "regs", "that", "are", "not", "defined", "on", "all", "incoming", "paths", ",", "and", "insert", "a", "corresponding", "def", "on", "those", ".", "Advantage", ":", "Does", "n't", "create", "long", "live", "ranges", ".", "Disadvantage", ":", "More", "complex", ",", "and", "potentially", "also", "more", "defs", "." ]

[ "nvptx", "0", "0", "\"Missing init of reg %u inserted on edge: %d -> %d:\"", "\" insn %u\\n\"", "\"Start: Added by -minit-regs=3:\"", "\"End: Added by -minit-regs=3:\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "cris_constant_alignment", "(", "const_tree", ",", "HOST_WIDE_INT", "basic_align", ")", "{", "return", "MAX", "(", "cris_preferred_mininum_alignment", "(", ")", ",", "basic_align", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CONSTANT_ALIGNMENT", ".", "Note", "that", "this", "hook", "has", "the", "effect", "of", "making", "gcc", "believe", "that", "ALL", "references", "to", "constant", "stuff", "(", "in", "code", "segment", ",", "like", "strings", ")", "have", "this", "alignment", ".", "That", "is", "a", "rather", "rushed", "assumption", ".", "Luckily", "we", "do", "not", "care", "about", "the", "``", "alignment", "''", "operand", "to", "builtin", "memcpy", "(", "only", "place", "where", "it", "counts", ")", ",", "so", "it", "does", "n't", "affect", "any", "bad", "spots", "." ]

[ "cris" ]

[]

[ "<s>", "bool", "X86PartialReduction", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "auto", "&", "TM", "=", "TPC", "->", "getTM", "<", "X86TargetMachine", ">", "(", ")", ";", "ST", "=", "TM", ".", "getSubtargetImpl", "(", "F", ")", ";", "DL", "=", "&", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "auto", "&", "BB", ":", "F", ")", "{", "for", "(", "auto", "&", "I", ":", "BB", ")", "{", "auto", "*", "EE", "=", "dyn_cast", "<", "ExtractElementInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "EE", ")", "continue", ";", "Value", "*", "Root", "=", "matchAddReduction", "(", "*", "EE", ")", ";", "if", "(", "!", "Root", ")", "continue", ";", "SmallVector", "<", "Instruction", "*", ",", "8", ">", "Leaves", ";", "collectLeaves", "(", "Root", ",", "Leaves", ")", ";", "for", "(", "Instruction", "*", "I", ":", "Leaves", ")", "{", "if", "(", "tryMAddReplacement", "(", "I", ")", ")", "{", "MadeChange", "=", "true", ";", "continue", ";", "}", "if", "(", "I", "!=", "Root", "&&", "trySADReplacement", "(", "I", ")", ")", "MadeChange", "=", "true", ";", "}", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

[ "<s>", "bool", "avr_emit_movmemhi", "(", "rtx", "*", "xop", ")", "{", "HOST_WIDE_INT", "count", ";", "machine_mode", "loop_mode", ";", "addr_space_t", "as", "=", "MEM_ADDR_SPACE", "(", "xop", "[", "1", "]", ")", ";", "rtx", "loop_reg", ",", "addr1", ",", "a_src", ",", "a_dest", ",", "insn", ",", "xas", ";", "rtx", "a_hi8", "=", "NULL_RTX", ";", "if", "(", "avr_mem_flash_p", "(", "xop", "[", "0", "]", ")", ")", "return", "false", ";", "if", "(", "!", "CONST_INT_P", "(", "xop", "[", "2", "]", ")", ")", "return", "false", ";", "count", "=", "INTVAL", "(", "xop", "[", "2", "]", ")", ";", "if", "(", "count", "<=", "0", ")", "return", "false", ";", "a_src", "=", "XEXP", "(", "xop", "[", "1", "]", ",", "0", ")", ";", "a_dest", "=", "XEXP", "(", "xop", "[", "0", "]", ",", "0", ")", ";", "if", "(", "PSImode", "==", "GET_MODE", "(", "a_src", ")", ")", "{", "gcc_assert", "(", "as", "==", "ADDR_SPACE_MEMX", ")", ";", "loop_mode", "=", "(", "count", "<", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "gen_rtx_REG", "(", "loop_mode", ",", "24", ")", ";", "emit_move_insn", "(", "loop_reg", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "addr1", "=", "simplify_gen_subreg", "(", "HImode", ",", "a_src", ",", "PSImode", ",", "0", ")", ";", "a_hi8", "=", "simplify_gen_subreg", "(", "QImode", ",", "a_src", ",", "PSImode", ",", "2", ")", ";", "}", "else", "{", "int", "segment", "=", "avr_addrspace", "[", "as", "]", ".", "segment", ";", "if", "(", "segment", "&&", "avr_n_flash", ">", "1", ")", "{", "a_hi8", "=", "GEN_INT", "(", "segment", ")", ";", "emit_move_insn", "(", "rampz_rtx", ",", "a_hi8", "=", "copy_to_mode_reg", "(", "QImode", ",", "a_hi8", ")", ")", ";", "}", "else", "if", "(", "!", "ADDR_SPACE_GENERIC_P", "(", "as", ")", ")", "{", "as", "=", "ADDR_SPACE_FLASH", ";", "}", "addr1", "=", "a_src", ";", "loop_mode", "=", "(", "count", "<=", "0x100", ")", "?", "QImode", ":", "HImode", ";", "loop_reg", "=", "copy_to_mode_reg", "(", "loop_mode", ",", "gen_int_mode", "(", "count", ",", "loop_mode", ")", ")", ";", "}", "xas", "=", "GEN_INT", "(", "as", ")", ";", "emit_move_insn", "(", "lpm_addr_reg_rtx", ",", "addr1", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "HImode", ",", "REG_X", ")", ",", "a_dest", ")", ";", "gcc_assert", "(", "TMP_REGNO", "==", "LPM_REGNO", ")", ";", "if", "(", "as", "!=", "ADDR_SPACE_MEMX", ")", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_movmem_qi", ":", "gen_movmem_hi", ";", "insn", "=", "fun", "(", "xas", ",", "loop_reg", ",", "loop_reg", ")", ";", "}", "else", "{", "rtx", "(", "*", "fun", ")", "(", "rtx", ",", "rtx", ")", "=", "QImode", "==", "loop_mode", "?", "gen_movmemx_qi", ":", "gen_movmemx_hi", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "QImode", ",", "23", ")", ",", "a_hi8", ")", ";", "insn", "=", "fun", "(", "xas", ",", "GEN_INT", "(", "avr_addr", ".", "rampz", ")", ")", ";", "}", "set_mem_addr_space", "(", "SET_SRC", "(", "XVECEXP", "(", "insn", ",", "0", ",", "0", ")", ")", ",", "as", ")", ";", "emit_insn", "(", "insn", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Worker", "function", "for", "movmemhi", "expander", ".", "XOP", "[", "0", "]", "Destination", "as", "MEM", ":", "BLK", "XOP", "[", "1", "]", "Source", "``", "``", "XOP", "[", "2", "]", "#", "Bytes", "to", "copy", "Return", "TRUE", "if", "the", "expansion", "is", "accomplished", ".", "Return", "FALSE", "if", "the", "operand", "compination", "is", "not", "supported", "." ]

[ "avr", "1", "0", "2", "2", "0", "1", "0", "0", "0", "0x100", "24", "0", "2", "1", "0x100", "23", "0", "0" ]

[]

[ "<s>", "bool", "AMDGPUMIRFormatter", "::", "parseCustomPseudoSourceValue", "(", "StringRef", "Src", ",", "MachineFunction", "&", "MF", ",", "PerFunctionMIParsingState", "&", "PFS", ",", "const", "PseudoSourceValue", "*", "&", "PSV", ",", "ErrorCallbackType", "ErrorCallback", ")", "const", "{", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "const", "SIInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "Src", "==", "\"BufferResource\"", ")", "{", "PSV", "=", "MFI", "->", "getBufferPSV", "(", "TII", ")", ";", "return", "false", ";", "}", "if", "(", "Src", "==", "\"ImageResource\"", ")", "{", "PSV", "=", "MFI", "->", "getImagePSV", "(", "TII", ")", ";", "return", "false", ";", "}", "if", "(", "Src", "==", "\"GWSResource\"", ")", "{", "PSV", "=", "MFI", "->", "getGWSPSV", "(", "TII", ")", ";", "return", "false", ";", "}", "llvm_unreachable", "(", "\"unknown MIR custom pseudo source value\"", ")", ";", "}", "</s>" ]

[ "Implement", "target", "specific", "parsing", "of", "target", "custom", "pseudo", "source", "value", "." ]

[ "AMDGPU", "AMDGPU", "SI", "SI", "SI", "\"BufferResource\"", "\"ImageResource\"", "\"GWSResource\"", "\"unknown MIR custom pseudo source value\"" ]

[]

[ "<s>", "MVT", "WebAssemblyTargetLowering", "::", "getScalarShiftAmountTy", "(", "const", "DataLayout", "&", "DL", ",", "EVT", "VT", ")", "const", "{", "return", "VT", ".", "getSimpleVT", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "to", "use", "for", "a", "scalar", "shift", "opcode", ",", "given", "the", "shifted", "amount", "type", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "int", "aarch64_comp_type_attributes", "(", "const_tree", "type1", ",", "const_tree", "type2", ")", "{", "if", "(", "lookup_attribute", "(", "\"aarch64_vector_pcs\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "lookup_attribute", "(", "\"aarch64_vector_pcs\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Implement", "TARGET_COMP_TYPE_ATTRIBUTES" ]

[ "aarch64", "\"aarch64_vector_pcs\"", "\"aarch64_vector_pcs\"", "0", "1" ]

[]

[ "<s>", "bool", "tilegx_expand_muldi", "(", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "if", "(", "CONST_INT_P", "(", "op2", ")", ")", "{", "HOST_WIDE_INT", "n", "=", "trunc_int_for_mode", "(", "INTVAL", "(", "op2", ")", ",", "DImode", ")", ";", "return", "tilegx_expand_const_muldi", "(", "op0", ",", "op1", ",", "n", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "the", "muldi", "pattern", "." ]

[ "tilegx" ]

[]

[ "<s>", "void", "NVPTXFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "hasStackObjects", "(", ")", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", "=", "DebugLoc", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "if", "(", "static_cast", "<", "const", "NVPTXTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ".", "is64Bit", "(", ")", ")", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int64RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes_64", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR_64", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "else", "{", "unsigned", "LocalReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "NVPTX", "::", "Int32RegsRegClass", ")", ";", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "cvta_local_yes", ")", ",", "NVPTX", "::", "VRFrame", ")", ".", "addReg", "(", "LocalReg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "dl", ",", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", "->", "get", "(", "NVPTX", "::", "MOV_DEPOT_ADDR", ")", ",", "LocalReg", ")", ".", "addImm", "(", "MF", ".", "getFunctionNumber", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX", "NVPTX::Int64RegsRegClass", "NVPTX::cvta_local_yes_64", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR_64", "NVPTX::Int32RegsRegClass", "NVPTX::cvta_local_yes", "NVPTX::VRFrame", "NVPTX::MOV_DEPOT_ADDR" ]

[]

[ "<s>", "bool", "shouldForceRelocation", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ")", "override", "{", "return", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ";", "}", "</s>" ]

[ "Hook", "to", "check", "if", "a", "relocation", "is", "needed", "for", "some", "target", "specific", "reason", "." ]

[ "RISCV", "RISCV::FeatureRelax" ]

[]

[ "<s>", "static", "bool", "msp430_preserve_reg_p", "(", "int", "regno", ")", "{", "if", "(", "regno", "<=", "3", ")", "return", "false", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "true", ";", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "msp430_is_interrupt_func", "(", ")", ")", "return", "!", "crtl", "->", "is_leaf", "||", "df_regs_ever_live_p", "(", "regno", ")", ";", "if", "(", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "is", "the", "one", "spot", "that", "decides", "if", "a", "register", "is", "to", "be", "saved", "and", "restored", "in", "the", "prologue/epilogue", "." ]

[ "msp430", "3" ]

[]

[ "<s>", "static", "bool", "compute_fp_layout", "(", "const_tree", "field", ",", "HOST_WIDE_INT", "bitpos", ",", "assign_data_t", "*", "data", ",", "int", "*", "pnregs", ",", "machine_mode", "*", "pmode", ")", "{", "const", "int", "this_slotno", "=", "data", "->", "slotno", "+", "bitpos", "/", "BITS_PER_WORD", ";", "machine_mode", "mode", "=", "DECL_MODE", "(", "field", ")", ";", "int", "nregs", ",", "nslots", ";", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "VECTOR_TYPE", "&&", "mode", "==", "BLKmode", ")", "{", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "field", ")", ")", ")", ";", "nregs", "=", "TYPE_VECTOR_SUBPARTS", "(", "TREE_TYPE", "(", "field", ")", ")", ";", "}", "else", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "field", ")", ")", "==", "COMPLEX_TYPE", ")", "{", "mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "field", ")", ")", ")", ";", "nregs", "=", "2", ";", "}", "else", "nregs", "=", "1", ";", "nslots", "=", "CEIL_NWORDS", "(", "nregs", "*", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "if", "(", "nslots", ">", "SPARC_FP_ARG_MAX", "-", "this_slotno", ")", "{", "nslots", "=", "SPARC_FP_ARG_MAX", "-", "this_slotno", ";", "nregs", "=", "(", "nslots", "*", "UNITS_PER_WORD", ")", "/", "GET_MODE_SIZE", "(", "mode", ")", ";", "data", "->", "stack", "=", "1", ";", "if", "(", "nregs", "<=", "0", ")", "return", "false", ";", "}", "*", "pnregs", "=", "nregs", ";", "*", "pmode", "=", "mode", ";", "return", "true", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Compute", "the", "number", "and", "the", "mode", "of", "the", "FP", "registers", "to", "be", "assigned", "for", "FIELD", ".", "Return", "true", "if", "at", "least", "one", "FP", "register", "is", "assigned", "or", "false", "otherwise", "." ]

[ "sparc", "2", "1", "1", "0" ]

[]

[ "<s>", "int", "HexagonInstrInfo", "::", "getMaxValue", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "uint64_t", "F", "=", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", ";", "unsigned", "isSigned", "=", "(", "F", ">>", "HexagonII", "::", "ExtentSignedPos", ")", "&", "HexagonII", "::", "ExtentSignedMask", ";", "unsigned", "bits", "=", "(", "F", ">>", "HexagonII", "::", "ExtentBitsPos", ")", "&", "HexagonII", "::", "ExtentBitsMask", ";", "if", "(", "isSigned", ")", "return", "~", "(", "-", "1U", "<<", "(", "bits", "-", "1", ")", ")", ";", "else", "return", "~", "(", "-", "1U", "<<", "bits", ")", ";", "}", "</s>" ]

[ "Return", "the", "maximal", "unsigned", "value", "possible", "given", "these", "KnownBits", "." ]

[ "Hexagon", "Hexagon", "HexagonII::ExtentSignedPos", "HexagonII::ExtentSignedMask", "HexagonII::ExtentBitsPos", "HexagonII::ExtentBitsMask", "1U", "1", "1U" ]

[]

[ "<s>", "void", "ARMHazardRecognizer", "::", "Reset", "(", ")", "{", "LastMI", "=", "0", ";", "FpMLxStalls", "=", "0", ";", "ScoreboardHazardRecognizer", "::", "Reset", "(", ")", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

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

[]

[ "<s>", "TargetIRAnalysis", "MipsTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "if", "(", "Subtarget", "->", "allowMixed16_32", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"No Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "F", ".", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ")", ";", "}", "DEBUG", "(", "errs", "(", ")", "<<", "\"Target Transform Info Pass Added\\n\"", ")", ";", "return", "TargetTransformInfo", "(", "BasicTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "Mips", "Mips", "\"No Target Transform Info Pass Added\\n\"", "\"Target Transform Info Pass Added\\n\"" ]

[]

[ "<s>", "static", "void", "bpf_init_libfuncs", "(", "void", ")", "{", "set_conv_libfunc", "(", "sext_optab", ",", "DFmode", ",", "SFmode", ",", "\"__bpf_extendsfdf2\"", ")", ";", "set_conv_libfunc", "(", "trunc_optab", ",", "SFmode", ",", "DFmode", ",", "\"__bpf_truncdfsf2\"", ")", ";", "set_conv_libfunc", "(", "sfix_optab", ",", "SImode", ",", "DFmode", ",", "\"__bpf_fix_truncdfsi\"", ")", ";", "set_conv_libfunc", "(", "sfloat_optab", ",", "DFmode", ",", "SImode", ",", "\"__bpf_floatsidf\"", ")", ";", "set_conv_libfunc", "(", "ufloat_optab", ",", "DFmode", ",", "SImode", ",", "\"__bpf_floatunsidf\"", ")", ";", "}", "</s>" ]

[ "Initialize", "target-specific", "function", "library", "calls", ".", "This", "is", "mainly", "used", "to", "call", "library-provided", "soft-fp", "operations", ",", "since", "eBPF", "does", "n't", "support", "floating-point", "in", "``", "hardware", "''", "." ]

[ "bpf", "\"__bpf_extendsfdf2\"", "\"__bpf_truncdfsf2\"", "\"__bpf_fix_truncdfsi\"", "\"__bpf_floatsidf\"", "\"__bpf_floatunsidf\"" ]

[]

[ "<s>", "static", "bool", "insn_uses_reg_p", "(", "rtx_insn", "*", "insn", ",", "unsigned", "int", "reg", ")", "{", "extract_insn", "(", "insn", ")", ";", "return", "(", "(", "REG_P", "(", "recog_data", ".", "operand", "[", "1", "]", ")", "&&", "REGNO", "(", "recog_data", ".", "operand", "[", "1", "]", ")", "==", "reg", ")", "||", "(", "recog_data", ".", "n_operands", "==", "3", "&&", "REG_P", "(", "recog_data", ".", "operand", "[", "2", "]", ")", "&&", "REGNO", "(", "recog_data", ".", "operand", "[", "2", "]", ")", "==", "reg", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "any", "of", "INSN", "'s", "source", "register", "(", "s", ")", "is", "REG", "." ]

[ "sparc", "1", "1", "3", "2", "2" ]

[]

[ "<s>", "static", "bool", "arc_mode_dependent_address_p", "(", "const_rtx", "addr", ",", "addr_space_t", ")", "{", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "&&", "(", "GET_CODE", "(", "XEXP", "(", "(", "addr", ")", ",", "0", ")", ")", "==", "MULT", "||", "(", "CONST_INT_P", "(", "XEXP", "(", "(", "addr", ")", ",", "1", ")", ")", "&&", "!", "SMALL_INT", "(", "INTVAL", "(", "XEXP", "(", "(", "addr", ")", ",", "1", ")", ")", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "iff", "ADDR", "(", "a", "legitimate", "address", "expression", ")", "has", "an", "effect", "that", "depends", "on", "the", "machine", "mode", "it", "is", "used", "for", "." ]

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

[]

[ "<s>", "gimple", "*", "gimple_folder", "::", "fold_to_cstu", "(", "poly_uint64", "val", ")", "{", "return", "gimple_build_assign", "(", "lhs", ",", "build_int_cstu", "(", "TREE_TYPE", "(", "lhs", ")", ",", "val", ")", ")", ";", "}", "</s>" ]

[ "Fold", "the", "call", "to", "constant", "VAL", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "RISCVCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "Register", ">", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "MachineInstrBuilder", "Ret", "=", "MIRBuilder", ".", "buildInstrNoInsert", "(", "RISCV", "::", "PseudoRET", ")", ";", "if", "(", "Val", "!=", "nullptr", ")", "{", "return", "false", ";", "}", "MIRBuilder", ".", "insertInstr", "(", "Ret", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoRET" ]

[]

[ "<s>", "static", "rtx", "sh_allocate_initial_value", "(", "rtx", "hard_reg", ")", "{", "rtx", "x", ";", "if", "(", "REGNO", "(", "hard_reg", ")", "==", "(", "TARGET_SHMEDIA", "?", "PR_MEDIA_REG", ":", "PR_REG", ")", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "!", "sh_pr_n_sets", "(", ")", "&&", "!", "(", "TARGET_SHCOMPACT", "&&", "(", "(", "crtl", "->", "args", ".", "info", ".", "call_cookie", "&", "~", "CALL_COOKIE_RET_TRAMP", "(", "1", ")", ")", "||", "crtl", "->", "saves_all_registers", ")", ")", ")", "x", "=", "hard_reg", ";", "else", "x", "=", "gen_frame_mem", "(", "Pmode", ",", "return_address_pointer_rtx", ")", ";", "}", "else", "x", "=", "NULL_RTX", ";", "return", "x", ";", "}", "</s>" ]

[ "Return", "where", "to", "allocate", "pseudo", "for", "a", "given", "hard", "register", "initial", "value", "." ]

[ "sh", "1" ]

[]

[ "<s>", "const", "RegisterBank", "&", "MipsRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "using", "namespace", "Mips", ";", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "Mips", "::", "GPR32RegClassID", ":", "case", "Mips", "::", "CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", ":", "case", "Mips", "::", "SP32RegClassID", ":", "return", "getRegBank", "(", "Mips", "::", "GPRBRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "Mips", "Mips", "Mips", "Mips::GPR32RegClassID", "Mips::CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::GPRMM16MoveP_and_CPU16Regs_and_GPRMM16ZeroRegClassID", "Mips::SP32RegClassID", "Mips::GPRBRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "bool", "HexagonAsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "const", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "if", "(", "MBB", "->", "hasAddressTaken", "(", ")", ")", "return", "false", ";", "return", "AsmPrinter", "::", "isBlockOnlyReachableByFallthrough", "(", "MBB", ")", ";", "}", "</s>" ]

[ "isBlockOnlyReachableByFallthough", "-", "Return", "true", "if", "the", "basic", "block", "has", "exactly", "one", "predecessor", "and", "the", "control", "transfer", "mechanism", "between", "the", "predecessor", "and", "this", "block", "is", "a", "fall-through", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "int", "function_arg_boundary", "(", "enum", "machine_mode", "mode", ",", "tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "if", "(", "alignment", "<", "PARM_BOUNDARY", ")", "alignment", "=", "PARM_BOUNDARY", ";", "if", "(", "alignment", ">", "STACK_BOUNDARY", ")", "alignment", "=", "STACK_BOUNDARY", ";", "return", "alignment", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "PARM_BOUNDARY", "is", "used", "for", "all", "arguments", ".", "V.4", "wants", "long", "longs", "to", "be", "double", "word", "aligned", ".", "Doubleword", "align", "SPE", "vectors", ".", "Quadword", "align", "Altivec", "vectors", ".", "Quadword", "align", "large", "synthetic", "vector", "types", "." ]

[ "mips" ]

[]

[ "<s>", "unsigned", "MipsSEInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "(", "Opc", "==", "Mips", "::", "LW", ")", "||", "(", "Opc", "==", "Mips", "::", "LW_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "LD", ")", "||", "(", "Opc", "==", "Mips", "::", "LD_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "LWC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LWC1_P8", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC1", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC164", ")", "||", "(", "Opc", "==", "Mips", "::", "LDC164_P8", ")", ")", "{", "if", "(", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "&&", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "&&", "(", "isZeroImm", "(", "MI", "->", "getOperand", "(", "2", ")", ")", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "Mips", "Mips", "Mips::LW", "Mips::LW_P8", "Mips::LD", "Mips::LD_P8", "Mips::LWC1", "Mips::LWC1_P8", "Mips::LDC1", "Mips::LDC164", "Mips::LDC164_P8", "1", "2", "2", "1", "0", "0" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "Optional", "<", "unsigned", ">", "FirstMaskArgument", ";", "if", "(", "Subtarget", ".", "hasStdExtV", "(", ")", ")", "preAssignMask", "(", "Outs", ",", "FirstMaskArgument", ",", "CCInfo", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "MVT", "VT", "=", "Outs", "[", "i", "]", ".", "VT", ";", "ISD", "::", "ArgFlagsTy", "ArgFlags", "=", "Outs", "[", "i", "]", ".", "Flags", ";", "RISCVABI", "::", "ABI", "ABI", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "getTargetABI", "(", ")", ";", "if", "(", "CC_RISCV", "(", "MF", ".", "getDataLayout", "(", ")", ",", "ABI", ",", "i", ",", "VT", ",", "VT", ",", "CCValAssign", "::", "Full", ",", "ArgFlags", ",", "CCInfo", ",", "true", ",", "true", ",", "nullptr", ",", "*", "this", ",", "FirstMaskArgument", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "RISCV", "RISCV", "ISD::OutputArg", "16", "0", "ISD::ArgFlagsTy", "RISCVABI::ABI", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "void", "push_minipool_fix", "(", "rtx_insn", "*", "insn", ",", "HOST_WIDE_INT", "address", ",", "rtx", "*", "loc", ",", "machine_mode", "mode", ",", "rtx", "value", ")", "{", "gcc_assert", "(", "!", "arm_disable_literal_pool", ")", ";", "Mfix", "*", "fix", "=", "(", "Mfix", "*", ")", "obstack_alloc", "(", "&", "minipool_obstack", ",", "sizeof", "(", "*", "fix", ")", ")", ";", "fix", "->", "insn", "=", "insn", ";", "fix", "->", "address", "=", "address", ";", "fix", "->", "loc", "=", "loc", ";", "fix", "->", "mode", "=", "mode", ";", "fix", "->", "fix_size", "=", "MINIPOOL_FIX_SIZE", "(", "mode", ")", ";", "fix", "->", "value", "=", "value", ";", "fix", "->", "forwards", "=", "get_attr_pool_range", "(", "insn", ")", ";", "fix", "->", "backwards", "=", "get_attr_neg_pool_range", "(", "insn", ")", ";", "fix", "->", "minipool", "=", "NULL", ";", "gcc_assert", "(", "fix", "->", "forwards", "||", "fix", "->", "backwards", ")", ";", "if", "(", "ARM_DOUBLEWORD_ALIGN", "&&", "fix", "->", "fix_size", ">=", "8", ")", "minipool_pad", "=", "4", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "INSN_UID", "(", "insn", ")", ",", "(", "unsigned", "long", ")", "address", ",", "-", "1", "*", "(", "long", ")", "fix", "->", "backwards", ",", "(", "long", ")", "fix", "->", "forwards", ")", ";", "arm_print_value", "(", "dump_file", ",", "fix", "->", "value", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n\"", ")", ";", "}", "fix", "->", "next", "=", "NULL", ";", "if", "(", "minipool_fix_head", "!=", "NULL", ")", "minipool_fix_tail", "->", "next", "=", "fix", ";", "else", "minipool_fix_head", "=", "fix", ";", "minipool_fix_tail", "=", "fix", ";", "}", "</s>" ]

[ "Record", "INSN", ",", "which", "will", "need", "fixing", "up", "to", "load", "a", "value", "from", "the", "minipool", ".", "ADDRESS", "is", "the", "offset", "of", "the", "insn", "since", "the", "start", "of", "the", "function", ";", "LOC", "is", "a", "pointer", "to", "the", "part", "of", "the", "insn", "which", "requires", "fixing", ";", "VALUE", "is", "the", "constant", "that", "must", "be", "loaded", ",", "which", "is", "of", "type", "MODE", "." ]

[ "arm", "8", "4", "\";; %smode fixup for i%d; addr %lu, range (%ld,%ld): \"", "1", "\"\\n\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "fixIMPLICITDEF", "(", "MF", ")", ";", "fixNoReturn", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "bool", "loongarch_use_ins_ext_p", "(", "rtx", "op", ",", "HOST_WIDE_INT", "width", ",", "HOST_WIDE_INT", "bitpos", ")", "{", "if", "(", "!", "register_operand", "(", "op", ",", "VOIDmode", ")", "||", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ">", "BITS_PER_WORD", ")", "return", "false", ";", "if", "(", "!", "IN_RANGE", "(", "width", ",", "1", ",", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "-", "1", ")", ")", "return", "false", ";", "if", "(", "bitpos", "<", "0", "||", "bitpos", "+", "width", ">", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "(", "zero_extract", "OP", "WIDTH", "BITPOS", ")", "can", "be", "used", "as", "the", "source", "of", "an", "``", "ext", "''", "instruction", "or", "the", "destination", "of", "an", "``", "ins", "''", "instruction", ".", "OP", "must", "be", "a", "register", "operand", "and", "the", "following", "conditions", "must", "hold", ":", "0", "<", "=", "BITPOS", "<", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "0", "<", "WIDTH", "<", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "0", "<", "BITPOS", "+", "WIDTH", "<", "=", "GET_MODE_BITSIZE", "(", "GET_MODE", "(", "op", ")", ")", "Also", "reject", "lengths", "equal", "to", "a", "word", "as", "they", "are", "better", "handled", "by", "the", "move", "patterns", "." ]

[ "loongarch", "1", "1", "0" ]

[]

[ "<s>", "bool", "R600InstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "false", ";", "if", "(", "isBranch", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "return", "true", ";", "if", "(", "!", "isJump", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "{", "return", "false", ";", "}", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "I", ")", "->", "getOpcode", "(", ")", "==", "AMDGPU", "::", "JUMP", ")", "{", "MachineBasicBlock", "::", "iterator", "PriorI", "=", "std", "::", "prev", "(", "I", ")", ";", "if", "(", "AllowModify", ")", "I", "->", "removeFromParent", "(", ")", ";", "I", "=", "PriorI", ";", "}", "MachineInstr", "&", "LastInst", "=", "*", "I", ";", "unsigned", "LastOpc", "=", "LastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "begin", "(", ")", "||", "!", "isJump", "(", "(", "--", "I", ")", "->", "getOpcode", "(", ")", ")", ")", "{", "if", "(", "LastOpc", "==", "AMDGPU", "::", "JUMP", ")", "{", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "return", "false", ";", "}", "else", "if", "(", "LastOpc", "==", "AMDGPU", "::", "JUMP_COND", ")", "{", "auto", "predSet", "=", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "MachineInstr", "&", "SecondLastInst", "=", "*", "I", ";", "unsigned", "SecondLastOpc", "=", "SecondLastInst", ".", "getOpcode", "(", ")", ";", "if", "(", "SecondLastOpc", "==", "AMDGPU", "::", "JUMP_COND", "&&", "LastOpc", "==", "AMDGPU", "::", "JUMP", ")", "{", "auto", "predSet", "=", "--", "I", ";", "while", "(", "!", "isPredicateSetter", "(", "predSet", "->", "getOpcode", "(", ")", ")", ")", "{", "predSet", "=", "--", "I", ";", "}", "TBB", "=", "SecondLastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "FBB", "=", "LastInst", ".", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "1", ")", ")", ";", "Cond", ".", "push_back", "(", "predSet", "->", "getOperand", "(", "2", ")", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateReg", "(", "AMDGPU", "::", "PRED_SEL_ONE", ",", "false", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "AMDGPU", "R600", "AMDGPU::JUMP", "AMDGPU::JUMP", "0", "AMDGPU::JUMP_COND", "0", "1", "2", "AMDGPU::PRED_SEL_ONE", "AMDGPU::JUMP_COND", "AMDGPU::JUMP", "0", "0", "1", "2", "AMDGPU::PRED_SEL_ONE" ]

[]

[ "<s>", "void", "KudeyarTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getDataRel", "(", ")", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ",", "SectionKind", "::", "getBSS", "(", ")", ")", ";", "}", "</s>" ]

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

[ "Kudeyar", "Kudeyar", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "bool", "addRegAssignAndRewriteFast", "(", ")", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Add", "core", "register", "allocator", "passes", "which", "do", "the", "actual", "register", "assignment", "and", "rewriting", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "unsigned", "PatmosMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "getMachineOpValue", "(", "MI", ",", "MO", ",", "Fixups", ")", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "Patmos", "Patmos" ]

[]

[ "<s>", "const", "uint16_t", "*", "MSP430RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "const", "Function", "*", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsIntr", "[", "]", "=", "{", "MSP430", "::", "FPW", ",", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "static", "const", "uint16_t", "CalleeSavedRegsIntrFP", "[", "]", "=", "{", "MSP430", "::", "R5W", ",", "MSP430", "::", "R6W", ",", "MSP430", "::", "R7W", ",", "MSP430", "::", "R8W", ",", "MSP430", "::", "R9W", ",", "MSP430", "::", "R10W", ",", "MSP430", "::", "R11W", ",", "MSP430", "::", "R12W", ",", "MSP430", "::", "R13W", ",", "MSP430", "::", "R14W", ",", "MSP430", "::", "R15W", ",", "0", "}", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntrFP", ":", "CalleeSavedRegsFP", ")", ";", "else", "return", "(", "F", "->", "getCallingConv", "(", ")", "==", "CallingConv", "::", "MSP430_INTR", "?", "CalleeSavedRegsIntr", ":", "CalleeSavedRegs", ")", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "0", "MSP430::FPW", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430::R5W", "MSP430::R6W", "MSP430::R7W", "MSP430::R8W", "MSP430::R9W", "MSP430::R10W", "MSP430::R11W", "MSP430::R12W", "MSP430::R13W", "MSP430::R14W", "MSP430::R15W", "0", "MSP430", "MSP430" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "CI", ",", "MachineFunction", "&", "MF", ",", "unsigned", "IntrID", ")", "const", "{", "if", "(", "const", "AMDGPU", "::", "RsrcIntrinsic", "*", "RsrcIntr", "=", "AMDGPU", "::", "lookupRsrcIntrinsicByIntr", "(", "IntrID", ")", ")", "{", "AttributeList", "Attr", "=", "Intrinsic", "::", "getAttributes", "(", "CI", ".", "getContext", "(", ")", ",", "(", "Intrinsic", "::", "ID", ")", "IntrID", ")", ";", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "ReadNone", ")", ")", "return", "false", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "RsrcIntr", "->", "IsImage", ")", "{", "Info", ".", "ptrVal", "=", "MFI", "->", "getImagePSV", "(", "*", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "RsrcIntr", "->", "RsrcArg", ")", ")", ";", "Info", ".", "align", "=", "0", ";", "}", "else", "{", "Info", ".", "ptrVal", "=", "MFI", "->", "getBufferPSV", "(", "*", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "RsrcIntr", "->", "RsrcArg", ")", ")", ";", "}", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MODereferenceable", ";", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "ReadOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "}", "else", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "WriteOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "}", "else", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MODereferenceable", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "}", "return", "true", ";", "}", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "align", "=", "0", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Vol", "||", "!", "Vol", "->", "isZero", "(", ")", ")", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "SI", "AMDGPU::RsrcIntrinsic", "AMDGPU::lookupRsrcIntrinsicByIntr", "Intrinsic::getAttributes", "Intrinsic::ID", "SI", "SI", "SI", "0", "SI", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "ISD::INTRINSIC_VOID", "MVT::getVT", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "static", "bool", "frv_sort_insn_group_1", "(", "enum", "frv_insn_group", "group", ",", "unsigned", "int", "lower_slot", ",", "unsigned", "int", "upper_slot", ",", "unsigned", "int", "issued", ",", "unsigned", "int", "num_insns", ",", "state_t", "state", ")", "{", "struct", "frv_packet_group", "*", "packet_group", ";", "unsigned", "int", "i", ";", "state_t", "test_state", ";", "size_t", "dfa_size", ";", "rtx", "insn", ";", "if", "(", "lower_slot", "==", "upper_slot", ")", "return", "true", ";", "packet_group", "=", "&", "frv_packet", ".", "groups", "[", "group", "]", ";", "dfa_size", "=", "state_size", "(", ")", ";", "test_state", "=", "alloca", "(", "dfa_size", ")", ";", "for", "(", "i", "=", "num_insns", "-", "1", ";", "i", "+", "1", "!=", "0", ";", "i", "--", ")", "if", "(", "~", "issued", "&", "(", "1", "<<", "i", ")", ")", "{", "insn", "=", "packet_group", "->", "sorted", "[", "i", "]", ";", "memcpy", "(", "test_state", ",", "state", ",", "dfa_size", ")", ";", "if", "(", "state_transition", "(", "test_state", ",", "insn", ")", "<", "0", "&&", "cpu_unit_reservation_p", "(", "test_state", ",", "NTH_UNIT", "(", "group", ",", "upper_slot", "-", "1", ")", ")", "&&", "frv_sort_insn_group_1", "(", "group", ",", "lower_slot", ",", "upper_slot", "-", "1", ",", "issued", "|", "(", "1", "<<", "i", ")", ",", "num_insns", ",", "test_state", ")", ")", "{", "packet_group", "->", "sorted", "[", "upper_slot", "-", "1", "]", "=", "insn", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Subroutine", "of", "frv_sort_insn_group", ".", "We", "are", "trying", "to", "sort", "frv_packet.groups", "[", "GROUP", "]", ".sorted", "[", "0", "...", "NUM_INSNS-1", "]", "into", "assembly", "language", "order", ".", "We", "have", "already", "picked", "a", "new", "position", "for", "frv_packet.groups", "[", "GROUP", "]", ".sorted", "[", "X", "]", "if", "bit", "X", "of", "ISSUED", "is", "set", ".", "These", "instructions", "will", "occupy", "elements", "[", "0", ",", "LOWER_SLOT", ")", "and", "[", "UPPER_SLOT", ",", "NUM_INSNS", ")", "of", "the", "final", "(", "sorted", ")", "array", ".", "STATE", "is", "the", "DFA", "state", "after", "issuing", "these", "instructions", ".", "Try", "filling", "elements", "[", "LOWER_SLOT", ",", "UPPER_SLOT", ")", "with", "every", "permutation", "of", "the", "unused", "instructions", ".", "Return", "true", "if", "one", "such", "permutation", "gives", "a", "valid", "ordering", ",", "leaving", "the", "successful", "permutation", "in", "sorted", "[", "]", ".", "Do", "not", "modify", "sorted", "[", "]", "until", "a", "valid", "permutation", "is", "found", "." ]

[ "frv", "1", "1", "0", "1", "0", "1", "1", "1", "1" ]

[]

[ "<s>", "SMLoc", "getEndLoc", "(", ")", "const", "{", "return", "EndLoc", ";", "}", "</s>" ]

[ "getEndLoc", "-", "Get", "the", "location", "of", "the", "last", "token", "of", "this", "operand", "." ]

[ "Patmos" ]

[]

[ "<s>", "enum", "machine_mode", "arm_select_dominance_cc_mode", "(", "rtx", "x", ",", "rtx", "y", ",", "HOST_WIDE_INT", "cond_or", ")", "{", "enum", "rtx_code", "cond1", ",", "cond2", ";", "int", "swapped", "=", "0", ";", "if", "(", "(", "arm_select_cc_mode", "(", "cond1", "=", "GET_CODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CCmode", ")", "||", "(", "arm_select_cc_mode", "(", "cond2", "=", "GET_CODE", "(", "y", ")", ",", "XEXP", "(", "y", ",", "0", ")", ",", "XEXP", "(", "y", ",", "1", ")", ")", "!=", "CCmode", ")", ")", "return", "CCmode", ";", "if", "(", "cond_or", "==", "DOM_CC_NX_OR_Y", ")", "cond1", "=", "reverse_condition", "(", "cond1", ")", ";", "if", "(", "cond1", "!=", "cond2", "&&", "!", "comparison_dominates_p", "(", "cond1", ",", "cond2", ")", "&&", "(", "swapped", "=", "1", ",", "!", "comparison_dominates_p", "(", "cond2", ",", "cond1", ")", ")", ")", "return", "CCmode", ";", "if", "(", "swapped", ")", "{", "enum", "rtx_code", "temp", "=", "cond1", ";", "cond1", "=", "cond2", ";", "cond2", "=", "temp", ";", "}", "switch", "(", "cond1", ")", "{", "case", "EQ", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DEQmode", ";", "switch", "(", "cond2", ")", "{", "case", "EQ", ":", "return", "CC_DEQmode", ";", "case", "LE", ":", "return", "CC_DLEmode", ";", "case", "LEU", ":", "return", "CC_DLEUmode", ";", "case", "GE", ":", "return", "CC_DGEmode", ";", "case", "GEU", ":", "return", "CC_DGEUmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "LT", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DLTmode", ";", "switch", "(", "cond2", ")", "{", "case", "LT", ":", "return", "CC_DLTmode", ";", "case", "LE", ":", "return", "CC_DLEmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "GT", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DGTmode", ";", "switch", "(", "cond2", ")", "{", "case", "GT", ":", "return", "CC_DGTmode", ";", "case", "GE", ":", "return", "CC_DGEmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "LTU", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DLTUmode", ";", "switch", "(", "cond2", ")", "{", "case", "LTU", ":", "return", "CC_DLTUmode", ";", "case", "LEU", ":", "return", "CC_DLEUmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "GTU", ":", "if", "(", "cond_or", "==", "DOM_CC_X_AND_Y", ")", "return", "CC_DGTUmode", ";", "switch", "(", "cond2", ")", "{", "case", "GTU", ":", "return", "CC_DGTUmode", ";", "case", "GEU", ":", "return", "CC_DGEUmode", ";", "case", "NE", ":", "return", "CC_DNEmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "case", "NE", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DNEmode", ";", "case", "LE", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DLEmode", ";", "case", "GE", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DGEmode", ";", "case", "LEU", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DLEUmode", ";", "case", "GEU", ":", "gcc_assert", "(", "cond1", "==", "cond2", ")", ";", "return", "CC_DGEUmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Select", "a", "dominance", "comparison", "mode", "if", "possible", "for", "a", "test", "of", "the", "general", "form", "(", "OP", "(", "COND_OR", "(", "X", ")", "(", "Y", ")", ")", "(", "const_int", "0", ")", ")", ".", "We", "support", "three", "forms", ".", "COND_OR", "==", "DOM_CC_X_AND_Y", "=", ">", "(", "X", "&", "&", "Y", ")", "COND_OR", "==", "DOM_CC_NX_OR_Y", "=", ">", "(", "(", "!", "X", ")", "||", "Y", ")", "COND_OR", "==", "DOM_CC_X_OR_Y", "=", ">", "(", "X", "||", "Y", ")", "In", "all", "cases", "OP", "will", "be", "either", "EQ", "or", "NE", ",", "but", "we", "do", "n't", "need", "to", "know", "which", "here", ".", "If", "we", "are", "unable", "to", "support", "a", "dominance", "comparison", "we", "return", "CC", "mode", ".", "This", "will", "then", "fail", "to", "match", "for", "the", "RTL", "expressions", "that", "generate", "this", "call", "." ]

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

[]

[ "<s>", "inline", "static", "rtx", "emit_set_insn", "(", "rtx", "x", ",", "rtx", "y", ")", "{", "return", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "x", ",", "y", ")", ")", ";", "}", "</s>" ]

[ "Emit", "an", "insn", "that", "'s", "a", "simple", "single-set", ".", "Both", "the", "operands", "must", "be", "known", "to", "be", "valid", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "isCheapToSpeculateCttz", "(", ")", "const", "{", "return", "Subtarget", ".", "hasMips32", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "cttz", "." ]

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

[]

[ "<s>", "bool", "RISCVFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "true", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "!", "MI", "->", "isDebugInstr", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "const", "auto", "&", "NonLibcallCSI", "=", "getNonLibcallCSI", "(", "CSI", ")", ";", "for", "(", "auto", "&", "CS", ":", "reverse", "(", "NonLibcallCSI", ")", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "CS", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "MI", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "const", "char", "*", "RestoreLibCall", "=", "getRestoreLibCallName", "(", "*", "MF", ",", "CSI", ")", ";", "if", "(", "RestoreLibCall", ")", "{", "MachineBasicBlock", "::", "iterator", "NewMI", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "RISCV", "::", "PseudoTAIL", ")", ")", ".", "addExternalSymbol", "(", "RestoreLibCall", ",", "RISCVII", "::", "MO_CALL", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", "&&", "MI", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoRET", ")", "{", "NewMI", "->", "copyImplicitOps", "(", "*", "MF", ",", "*", "MI", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "}", "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", "(", ")", "." ]

[ "RI5CY", "RISCV", "\"loadRegFromStackSlot didn't insert any code!\"", "RISCV::PseudoTAIL", "RISCVII::MO_CALL", "RISCV::PseudoRET" ]

[]

[ "<s>", "static", "rtx_insn", "*", "find_cond_jump", "(", "rtx_insn", "*", "insn", ")", "{", "for", "(", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx", "ite", ",", "cc", ";", "if", "(", "LABEL_P", "(", "insn", ")", ")", "break", ";", "if", "(", "!", "JUMP_P", "(", "insn", ")", ")", "{", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ",", "insn", ")", ")", "break", ";", "continue", ";", "}", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "SET", ")", "break", ";", "gcc_assert", "(", "SET_DEST", "(", "PATTERN", "(", "insn", ")", ")", "==", "pc_rtx", ")", ";", "ite", "=", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ";", "if", "(", "GET_CODE", "(", "ite", ")", "!=", "IF_THEN_ELSE", ")", "break", ";", "cc", "=", "XEXP", "(", "XEXP", "(", "ite", ",", "0", ")", ",", "0", ")", ";", "if", "(", "!", "REG_P", "(", "cc", ")", "||", "!", "CC_REGNO_P", "(", "REGNO", "(", "cc", ")", ")", ")", "break", ";", "if", "(", "find_reg_note", "(", "insn", ",", "REG_DEAD", ",", "cc", ")", ")", "return", "insn", ";", "break", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Starting", "from", "INSN", "find_cond_jump", "looks", "downwards", "in", "the", "insn", "stream", "for", "a", "single", "jump", "insn", "which", "is", "the", "last", "user", "of", "the", "condition", "code", "set", "in", "INSN", "." ]

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

[]

[ "<s>", "static", "bool", "arm_promote_prototypes", "(", "tree", "t", "ATTRIBUTE_UNUSED", ")", "{", "return", "!", "TARGET_AAPCS_BASED", ";", "}", "</s>" ]

[ "We", "ca", "n't", "rely", "on", "the", "caller", "doing", "the", "proper", "promotion", "when", "using", "APCS", "or", "ATPCS", "." ]

[ "arm" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SPARC DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Sparc", "\"SPARC DAG->DAG Pattern Instruction Selection\"" ]

[]

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

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

[ "UPT", "UPT", "UPT" ]

[]

[ "<s>", "FuncInfo", "(", ")", ":", "MemInstCount", "(", "0", ")", ",", "InstCount", "(", "0", ")", ",", "IAMInstCount", "(", "0", ")", ",", "LSMInstCount", "(", "0", ")", "{", "}", "</s>" ]

[ "Information", "about", "the", "function", "as", "a", "whole", "." ]

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

[]

[ "<s>", "Candidate", "(", "MachineInstr", "*", "mi", ",", "Register", "reg", ",", "unsigned", "subreg", ",", "unsigned", "freebanks", ")", ":", "MI", "(", "mi", ")", ",", "Reg", "(", "reg", ")", ",", "SubReg", "(", "subreg", ")", ",", "FreeBanks", "(", "freebanks", ")", "{", "}", "</s>" ]

[ "Describes", "the", "region", "of", "code", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "unsigned", "F2003fRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "F2003f", "::", "F5", ";", "}", "</s>" ]

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

[ "F2003f", "F2003f", "F2003f::F5" ]

[]

[ "<s>", "unsigned", "ARMBaseRegisterInfo", "::", "getRegPressureLimit", "(", "const", "TargetRegisterClass", "*", "RC", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "return", "0", ";", "case", "ARM", "::", "tGPRRegClassID", ":", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "4", ":", "5", ";", "case", "ARM", "::", "GPRRegClassID", ":", "{", "unsigned", "FP", "=", "TFI", "->", "hasFP", "(", "MF", ")", "?", "1", ":", "0", ";", "return", "10", "-", "FP", "-", "(", "STI", ".", "isR9Reserved", "(", ")", "?", "1", ":", "0", ")", ";", "}", "case", "ARM", "::", "SPRRegClassID", ":", "case", "ARM", "::", "DPRRegClassID", ":", "return", "32", "-", "10", ";", "}", "}", "</s>" ]

[ "Return", "the", "register", "pressure", "``", "high", "water", "mark", "''", "for", "the", "specific", "register", "class", "." ]

[ "ARM", "ARM", "0", "ARM::tGPRRegClassID", "4", "5", "ARM::GPRRegClassID", "1", "0", "10", "1", "0", "ARM::SPRRegClassID", "ARM::DPRRegClassID", "32", "10" ]

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegReg", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "short", "imm", "=", "0", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", ")", "return", "false", ";", "if", "(", "N", ".", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "PPCISD", "::", "Lo", ")", "return", "false", ";", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "else", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", "{", "if", "(", "isIntS16Immediate", "(", "N", ".", "getOperand", "(", "1", ")", ",", "imm", ")", ")", "return", "false", ";", "APInt", "LHSKnownZero", ",", "LHSKnownOne", ";", "APInt", "RHSKnownZero", ",", "RHSKnownOne", ";", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "0", ")", ",", "LHSKnownZero", ",", "LHSKnownOne", ")", ";", "if", "(", "LHSKnownZero", ".", "getBoolValue", "(", ")", ")", "{", "DAG", ".", "computeKnownBits", "(", "N", ".", "getOperand", "(", "1", ")", ",", "RHSKnownZero", ",", "RHSKnownOne", ")", ";", "if", "(", "~", "(", "LHSKnownZero", "|", "RHSKnownZero", ")", "==", "0", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "SelectAddressRegReg", "-", "Given", "the", "specified", "addressed", ",", "check", "to", "see", "if", "it", "can", "be", "more", "efficiently", "represented", "as", "[", "r+imm", "]", "." ]

[ "PowerPC", "PPC", "0", "ISD::ADD", "1", "1", "PPCISD::Lo", "0", "1", "ISD::OR", "1", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "static", "enum", "mips_ucbranch_type", "mips_classify_branch_p6600", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "insn", "||", "!", "USEFUL_INSN_P", "(", "insn", ")", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "return", "UC_UNDEFINED", ";", "if", "(", "get_attr_jal", "(", "insn", ")", "==", "JAL_INDIRECT", "||", "get_attr_type", "(", "insn", ")", "==", "TYPE_JUMP", ")", "return", "UC_OTHER", ";", "if", "(", "CALL_P", "(", "insn", ")", "&&", "get_attr_jal", "(", "insn", ")", "==", "JAL_DIRECT", ")", "return", "UC_BALC", ";", "return", "UC_UNDEFINED", ";", "}", "</s>" ]

[ "Subroutine", "of", "mips_avoid_hazard", ".", "We", "classify", "unconditional", "branches", "of", "interest", "for", "the", "P6600", "for", "performance", "reasons", ".", "We", "'re", "interested", "in", "differentiating", "BALC", "from", "JIC", ",", "JIALC", "and", "BC", "." ]

[ "mips" ]

[]

[ "<s>", "bool", "enableMachineScheduler", "(", ")", "const", "override", "{", "return", "isCheri", "(", ")", "||", "isBeri", "(", ")", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "nds32_check_isr_attrs_conflict", "(", "tree", "func_decl", ",", "tree", "func_attrs", ")", "{", "int", "save_all_p", ",", "partial_save_p", ";", "int", "nested_p", ",", "not_nested_p", ",", "nested_ready_p", ",", "critical_p", ";", "int", "intr_p", ",", "excp_p", ",", "reset_p", ";", "save_all_p", "=", "partial_save_p", "=", "0", ";", "nested_p", "=", "not_nested_p", "=", "nested_ready_p", "=", "critical_p", "=", "0", ";", "intr_p", "=", "excp_p", "=", "reset_p", "=", "0", ";", "if", "(", "lookup_attribute", "(", "\"save_all\"", ",", "func_attrs", ")", ")", "save_all_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"partial_save\"", ",", "func_attrs", ")", ")", "partial_save_p", "=", "1", ";", "if", "(", "(", "save_all_p", "+", "partial_save_p", ")", ">", "1", ")", "error", "(", "\"multiple save register attributes to function %qD\"", ",", "func_decl", ")", ";", "if", "(", "lookup_attribute", "(", "\"nested\"", ",", "func_attrs", ")", ")", "nested_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"not_nested\"", ",", "func_attrs", ")", ")", "not_nested_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"nested_ready\"", ",", "func_attrs", ")", ")", "nested_ready_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"critical\"", ",", "func_attrs", ")", ")", "critical_p", "=", "1", ";", "if", "(", "(", "nested_p", "+", "not_nested_p", "+", "nested_ready_p", "+", "critical_p", ")", ">", "1", ")", "error", "(", "\"multiple nested types attributes to function %qD\"", ",", "func_decl", ")", ";", "if", "(", "lookup_attribute", "(", "\"interrupt\"", ",", "func_attrs", ")", ")", "intr_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"exception\"", ",", "func_attrs", ")", ")", "excp_p", "=", "1", ";", "if", "(", "lookup_attribute", "(", "\"reset\"", ",", "func_attrs", ")", ")", "reset_p", "=", "1", ";", "if", "(", "(", "intr_p", "+", "excp_p", "+", "reset_p", ")", ">", "1", ")", "error", "(", "\"multiple interrupt attributes to function %qD\"", ",", "func_decl", ")", ";", "if", "(", "TARGET_LINUX_ABI", "&&", "intr_p", ")", "error", "(", "\"cannot use interrupt attributes to function %qD \"", "\"under linux toolchain\"", ",", "func_decl", ")", ";", "if", "(", "TARGET_LINUX_ABI", "&&", "excp_p", ")", "error", "(", "\"cannot use exception attributes to function %qD \"", "\"under linux toolchain\"", ",", "func_decl", ")", ";", "if", "(", "TARGET_LINUX_ABI", "&&", "reset_p", ")", "error", "(", "\"cannot use reset attributes to function %qD \"", "\"under linux toolchain\"", ",", "func_decl", ")", ";", "}", "</s>" ]

[ "Function", "for", "nds32_merge_decl_attributes", "(", ")", "and", "nds32_insert_attributes", "(", ")", "to", "check", "if", "there", "are", "any", "conflict", "isr-specific", "attributes", "being", "set", ".", "We", "need", "to", "check", ":", "1", ".", "Only", "'save_all", "'", "or", "'partial_save", "'", "in", "the", "attributes", ".", "2", ".", "Only", "'nested", "'", ",", "'not_nested", "'", ",", "or", "'nested_ready", "'", "in", "the", "attributes", ".", "3", ".", "Only", "'interrupt", "'", ",", "'exception", "'", ",", "or", "'reset", "'", "in", "the", "attributes", "." ]

[ "nds32", "0", "0", "0", "\"save_all\"", "1", "\"partial_save\"", "1", "1", "\"multiple save register attributes to function %qD\"", "\"nested\"", "1", "\"not_nested\"", "1", "\"nested_ready\"", "1", "\"critical\"", "1", "1", "\"multiple nested types attributes to function %qD\"", "\"interrupt\"", "1", "\"exception\"", "1", "\"reset\"", "1", "1", "\"multiple interrupt attributes to function %qD\"", "\"cannot use interrupt attributes to function %qD \"", "\"under linux toolchain\"", "\"cannot use exception attributes to function %qD \"", "\"under linux toolchain\"", "\"cannot use reset attributes to function %qD \"", "\"under linux toolchain\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "ExpandInlineAsm", "(", "CallInst", "*", "CI", ")", "const", "{", "InlineAsm", "*", "IA", "=", "cast", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ";", "std", "::", "vector", "<", "InlineAsm", "::", "ConstraintInfo", ">", "Constraints", "=", "IA", "->", "ParseConstraints", "(", ")", ";", "std", "::", "string", "AsmStr", "=", "IA", "->", "getAsmString", "(", ")", ";", "std", "::", "vector", "<", "std", "::", "string", ">", "AsmPieces", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "\"\\n\"", ")", ";", "switch", "(", "AsmPieces", ".", "size", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "1", ":", "AsmStr", "=", "AsmPieces", "[", "0", "]", ";", "AsmPieces", ".", "clear", "(", ")", ";", "SplitString", "(", "AsmStr", ",", "AsmPieces", ",", "\" \\t\"", ")", ";", "if", "(", "AsmPieces", ".", "size", "(", ")", "==", "2", "&&", "(", "AsmPieces", "[", "0", "]", "==", "\"bswap\"", "||", "AsmPieces", "[", "0", "]", "==", "\"bswapq\"", "||", "AsmPieces", "[", "0", "]", "==", "\"bswapl\"", ")", "&&", "(", "AsmPieces", "[", "1", "]", "==", "\"$0\"", "||", "AsmPieces", "[", "1", "]", "==", "\"${0:q}\"", ")", ")", "{", "return", "LowerToBSwap", "(", "CI", ")", ";", "}", "if", "(", "CI", "->", "getType", "(", ")", "==", "Type", "::", "getInt16Ty", "(", "CI", "->", "getContext", "(", ")", ")", "&&", "AsmPieces", ".", "size", "(", ")", "==", "3", "&&", "AsmPieces", "[", "0", "]", "==", "\"rorw\"", "&&", "AsmPieces", "[", "1", "]", "==", "\"$$8,\"", "&&", "AsmPieces", "[", "2", "]", "==", "\"${0:w}\"", "&&", "IA", "->", "getConstraintString", "(", ")", "==", "\"=r,0,~{dirflag},~{fpsr},~{flags},~{cc}\"", ")", "{", "return", "LowerToBSwap", "(", "CI", ")", ";", "}", "break", ";", "case", "3", ":", "if", "(", "CI", "->", "getType", "(", ")", "==", "Type", "::", "getInt64Ty", "(", "CI", "->", "getContext", "(", ")", ")", "&&", "Constraints", ".", "size", "(", ")", ">=", "2", "&&", "Constraints", "[", "0", "]", ".", "Codes", ".", "size", "(", ")", "==", "1", "&&", "Constraints", "[", "0", "]", ".", "Codes", "[", "0", "]", "==", "\"A\"", "&&", "Constraints", "[", "1", "]", ".", "Codes", ".", "size", "(", ")", "==", "1", "&&", "Constraints", "[", "1", "]", ".", "Codes", "[", "0", "]", "==", "\"0\"", ")", "{", "std", "::", "vector", "<", "std", "::", "string", ">", "Words", ";", "SplitString", "(", "AsmPieces", "[", "0", "]", ",", "Words", ",", "\" \\t\"", ")", ";", "if", "(", "Words", ".", "size", "(", ")", "==", "2", "&&", "Words", "[", "0", "]", "==", "\"bswap\"", "&&", "Words", "[", "1", "]", "==", "\"%eax\"", ")", "{", "Words", ".", "clear", "(", ")", ";", "SplitString", "(", "AsmPieces", "[", "1", "]", ",", "Words", ",", "\" \\t\"", ")", ";", "if", "(", "Words", ".", "size", "(", ")", "==", "2", "&&", "Words", "[", "0", "]", "==", "\"bswap\"", "&&", "Words", "[", "1", "]", "==", "\"%edx\"", ")", "{", "Words", ".", "clear", "(", ")", ";", "SplitString", "(", "AsmPieces", "[", "2", "]", ",", "Words", ",", "\" \\t,\"", ")", ";", "if", "(", "Words", ".", "size", "(", ")", "==", "3", "&&", "Words", "[", "0", "]", "==", "\"xchgl\"", "&&", "Words", "[", "1", "]", "==", "\"%eax\"", "&&", "Words", "[", "2", "]", "==", "\"%edx\"", ")", "{", "return", "LowerToBSwap", "(", "CI", ")", ";", "}", "}", "}", "}", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "hook", "allows", "the", "target", "to", "expand", "an", "inline", "asm", "call", "to", "be", "explicit", "llvm", "code", "if", "it", "wants", "to", "." ]

[ "X86", "X86", "\"\\n\"", "1", "0", "\" \\t\"", "2", "0", "\"bswap\"", "0", "\"bswapq\"", "0", "\"bswapl\"", "1", "\"$0\"", "1", "\"${0:q}\"", "3", "0", "\"rorw\"", "1", "\"$$8,\"", "2", "\"${0:w}\"", "\"=r,0,~{dirflag},~{fpsr},~{flags},~{cc}\"", "3", "2", "0", "1", "0", "0", "\"A\"", "1", "1", "1", "0", "\"0\"", "0", "\" \\t\"", "2", "0", "\"bswap\"", "1", "\"%eax\"", "1", "\" \\t\"", "2", "0", "\"bswap\"", "1", "\"%edx\"", "2", "\" \\t,\"", "3", "0", "\"xchgl\"", "1", "\"%eax\"", "2", "\"%edx\"" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "const", "TargetMachine", "&", "TM", "=", "AP", ".", "TM", ";", "Mangler", "*", "Mang", "=", "AP", ".", "Mang", ";", "const", "DataLayout", "*", "DL", "=", "TM", ".", "getDataLayout", "(", ")", ";", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "bool", "isDarwin", "=", "Triple", "(", "TM", ".", "getTargetTriple", "(", ")", ")", ".", "isOSDarwin", "(", ")", ";", "SmallString", "<", "128", ">", "Name", ";", "StringRef", "Suffix", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", ")", "{", "if", "(", "isDarwin", ")", "Suffix", "=", "\"$stub\"", ";", "}", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "Suffix", "=", "\"$non_lazy_ptr\"", ";", "if", "(", "!", "Suffix", ".", "empty", "(", ")", ")", "Name", "+=", "DL", "->", "getPrivateGlobalPrefix", "(", ")", ";", "unsigned", "PrefixLen", "=", "Name", ".", "size", "(", ")", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Mang", "->", "getNameWithPrefix", "(", "Name", ",", "MO", ".", "getSymbolName", "(", ")", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "TM", ".", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "*", "Mang", ")", ";", "}", "unsigned", "OrigLen", "=", "Name", ".", "size", "(", ")", "-", "PrefixLen", ";", "Name", "+=", "Suffix", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ")", ";", "StringRef", "OrigName", "=", "StringRef", "(", "Name", ")", ".", "substr", "(", "PrefixLen", ",", "OrigLen", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_PLT_OR_STUB", "&&", "isDarwin", ")", "{", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "GetOrCreateSymbol", "(", "OrigName", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Sym", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "PPCII::MO_PLT_OR_STUB", "\"$stub\"", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "\"Isn't a symbol reference\"", "PPCII::MO_PLT_OR_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_NLP_HIDDEN_FLAG", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "void", "X86FrameLowering", "::", "emitCalleeSavedFrameMovesFullCFA", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MBBI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "!", "hasFP", "(", "MF", ")", ")", "{", "emitCalleeSavedFrameMoves", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "{", "}", ",", "true", ")", ";", "return", ";", "}", "const", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "Register", "FramePtr", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "const", "Register", "MachineFramePtr", "=", "STI", ".", "isTarget64BitILP32", "(", ")", "?", "Register", "(", "getX86SubSuperRegister", "(", "FramePtr", ",", "64", ")", ")", ":", "FramePtr", ";", "unsigned", "DwarfReg", "=", "MRI", "->", "getDwarfRegNum", "(", "MachineFramePtr", ",", "true", ")", ";", "unsigned", "Offset", "=", "(", "Is64Bit", "?", "8", ":", "4", ")", "+", "(", "Uses64BitFramePtr", "?", "8", ":", "4", ")", ";", "BuildCFI", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "{", "}", ",", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DwarfReg", ",", "-", "Offset", ")", ")", ";", "emitCalleeSavedFrameMoves", "(", "MBB", ",", "MBBI", ",", "DebugLoc", "{", "}", ",", "true", ")", ";", "}", "</s>" ]

[ "Emits", "Dwarf", "Info", "specifying", "offsets", "of", "callee", "saved", "registers", "and", "frame", "pointer", "." ]

[ "X86", "X86", "X86", "64", "8", "4", "8", "4" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "reserveIndirectRegisters", "(", "BitVector", "&", "Reserved", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AMDGPUFrameLowering", "*", "TFL", "=", "static_cast", "<", "const", "AMDGPUFrameLowering", "*", ">", "(", "TM", ".", "getFrameLowering", "(", ")", ")", ";", "unsigned", "StackWidth", "=", "TFL", "->", "getStackWidth", "(", "MF", ")", ";", "int", "End", "=", "getIndirectIndexEnd", "(", "MF", ")", ";", "if", "(", "End", "==", "-", "1", ")", "return", ";", "for", "(", "int", "Index", "=", "getIndirectIndexBegin", "(", "MF", ")", ";", "Index", "<=", "End", ";", "++", "Index", ")", "{", "unsigned", "SuperReg", "=", "AMDGPU", "::", "R600_Reg128RegClass", ".", "getRegister", "(", "Index", ")", ";", "Reserved", ".", "set", "(", "SuperReg", ")", ";", "for", "(", "unsigned", "Chan", "=", "0", ";", "Chan", "<", "StackWidth", ";", "++", "Chan", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "R600_TReg32RegClass", ".", "getRegister", "(", "(", "4", "*", "Index", ")", "+", "Chan", ")", ";", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "}", "}", "</s>" ]

[ "Reserve", "the", "registers", "that", "may", "be", "accessed", "using", "indirect", "addressing", "." ]

[ "R600", "1", "0", "4" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "KindTy", "::", "Register", ";", "}", "</s>" ]

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

[ "LoongArch" ]

[]

[ "<s>", "bool", "RISCVInstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "{", "if", "(", "!", "isPreISelGenericOpcode", "(", "I", ".", "getOpcode", "(", ")", ")", ")", "{", "return", "true", ";", "}", "if", "(", "selectImpl", "(", "I", ",", "*", "CoverageInfo", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Select", "the", "(", "possibly", "generic", ")", "instruction", "I", "to", "only", "use", "target-specific", "opcodes", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "void", "rs6000_set_sched_context", "(", "void", "*", "_sc", ")", "{", "rs6000_sched_context_t", "sc", "=", "(", "rs6000_sched_context_t", ")", "_sc", ";", "gcc_assert", "(", "sc", "!=", "NULL", ")", ";", "cached_can_issue_more", "=", "sc", "->", "cached_can_issue_more", ";", "last_scheduled_insn", "=", "sc", "->", "last_scheduled_insn", ";", "load_store_pendulum", "=", "sc", "->", "load_store_pendulum", ";", "divide_cnt", "=", "sc", "->", "divide_cnt", ";", "vec_pairing", "=", "sc", "->", "vec_pairing", ";", "}", "</s>" ]

[ "Sets", "the", "global", "scheduling", "context", "to", "the", "one", "pointed", "to", "by", "_SC", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "m32r_in_small_data_p", "(", "const_tree", "decl", ")", "{", "const", "char", "*", "section", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "!=", "VAR_DECL", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"model\"", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ")", "return", "false", ";", "section", "=", "DECL_SECTION_NAME", "(", "decl", ")", ";", "if", "(", "section", ")", "{", "if", "(", "strcmp", "(", "section", ",", "\".sdata\"", ")", "==", "0", "||", "strcmp", "(", "section", ",", "\".sbss\"", ")", "==", "0", ")", "return", "true", ";", "}", "else", "{", "if", "(", "!", "TREE_READONLY", "(", "decl", ")", "&&", "!", "TARGET_SDATA_NONE", ")", "{", "int", "size", "=", "int_size_in_bytes", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "size", ">", "0", "&&", "size", "<=", "g_switch_value", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Only", "mark", "the", "object", "as", "being", "small", "data", "area", "addressable", "if", "it", "has", "n't", "been", "explicitly", "marked", "with", "a", "code", "model", ".", "The", "user", "can", "explicitly", "put", "an", "object", "in", "the", "small", "data", "area", "with", "the", "section", "attribute", ".", "If", "the", "object", "is", "in", "sdata/sbss", "and", "marked", "with", "a", "code", "model", "do", "both", "[", "put", "the", "object", "in", ".sdata", "and", "mark", "it", "as", "being", "addressed", "with", "a", "specific", "code", "model", "-", "do", "n't", "mark", "it", "as", "being", "addressed", "with", "an", "SDA", "reloc", "though", "]", ".", "This", "is", "ok", "and", "might", "be", "useful", "at", "times", ".", "If", "the", "object", "does", "n't", "fit", "the", "linker", "will", "give", "an", "error", "." ]

[ "m32r", "\"model\"", "\".sdata\"", "0", "\".sbss\"", "0", "0" ]

[]

[ "<s>", "void", "AMDGPUTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Threshold", "=", "300", ";", "UP", ".", "MaxCount", "=", "UINT_MAX", ";", "UP", ".", "Partial", "=", "true", ";", "for", "(", "const", "BasicBlock", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "const", "DataLayout", "&", "DL", "=", "BB", "->", "getModule", "(", ")", "->", "getDataLayout", "(", ")", ";", "for", "(", "const", "Instruction", "&", "I", ":", "*", "BB", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "GEP", "||", "GEP", "->", "getAddressSpace", "(", ")", "!=", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ",", "DL", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "800", ";", "}", "}", "}", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "R600", "300", "AMDGPUAS::PRIVATE_ADDRESS", "800" ]

[]

[ "<s>", "unsigned", "LanaiTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"pc\"", ",", "Lanai", "::", "PC", ")", ".", "Case", "(", "\"sp\"", ",", "Lanai", "::", "SP", ")", ".", "Case", "(", "\"fp\"", ",", "Lanai", "::", "FP", ")", ".", "Case", "(", "\"rr1\"", ",", "Lanai", "::", "RR1", ")", ".", "Case", "(", "\"r10\"", ",", "Lanai", "::", "R10", ")", ".", "Case", "(", "\"rr2\"", ",", "Lanai", "::", "RR2", ")", ".", "Case", "(", "\"r11\"", ",", "Lanai", "::", "R11", ")", ".", "Case", "(", "\"rca\"", ",", "Lanai", "::", "RCA", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "Lanai", "Lanai", "\"pc\"", "Lanai::PC", "\"sp\"", "Lanai::SP", "\"fp\"", "Lanai::FP", "\"rr1\"", "Lanai::RR1", "\"r10\"", "Lanai::R10", "\"rr2\"", "Lanai::RR2", "\"r11\"", "Lanai::R11", "\"rca\"", "Lanai::RCA", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "static", "bool", "m68k_legitimate_constant_address_p", "(", "rtx", "x", ",", "unsigned", "int", "reach", ",", "bool", "strict_p", ")", "{", "rtx", "base", ",", "offset", ";", "if", "(", "!", "CONSTANT_ADDRESS_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "flag_pic", "&&", "!", "(", "strict_p", "&&", "TARGET_PCREL", ")", "&&", "symbolic_operand", "(", "x", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "M68K_OFFSETS_MUST_BE_WITHIN_SECTIONS_P", "&&", "reach", ">", "1", ")", "{", "split_const", "(", "x", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "GET_CODE", "(", "base", ")", "==", "SYMBOL_REF", "&&", "!", "offset_within_block_p", "(", "base", ",", "INTVAL", "(", "offset", ")", "+", "reach", "-", "1", ")", ")", "return", "false", ";", "}", "return", "!", "m68k_tls_reference_p", "(", "x", ",", "false", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "constant", "address", "that", "can", "reach", "bytes", "in", "the", "range", "[", "X", ",", "X", "+", "REACH", ")", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "." ]

[ "m68k", "1", "1" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "XCoreRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "MCPhysReg", "CalleeSavedRegs", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "XCore", "::", "R10", ",", "0", "}", ";", "static", "const", "MCPhysReg", "CalleeSavedRegsFP", "[", "]", "=", "{", "XCore", "::", "R4", ",", "XCore", "::", "R5", ",", "XCore", "::", "R6", ",", "XCore", "::", "R7", ",", "XCore", "::", "R8", ",", "XCore", "::", "R9", ",", "0", "}", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", "->", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "*", "MF", ")", ")", "return", "CalleeSavedRegsFP", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "XCore::R10", "0", "XCore::R4", "XCore::R5", "XCore::R6", "XCore::R7", "XCore::R8", "XCore::R9", "0" ]

[]

[ "<s>", "bool", "WebAssemblySubtarget", "::", "enableMachineScheduler", "(", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Enable", "the", "MachineScheduler", "pass", "for", "all", "X86", "subtargets", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "const", "char", "*", "reg_name_with_mode", "(", "int", "regno", ",", "enum", "machine_mode", "mode", ")", "{", "int", "mlen", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "mlen", "==", "1", ")", "return", "\"r0l\"", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "(", "mlen", "==", "3", "||", "mlen", "==", "4", ")", ")", "return", "\"r2r0\"", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "mlen", "==", "6", ")", "return", "\"r2r1r0\"", ";", "if", "(", "regno", "==", "R0_REGNO", "&&", "mlen", "==", "8", ")", "return", "\"r3r1r2r0\"", ";", "if", "(", "regno", "==", "R1_REGNO", "&&", "mlen", "==", "1", ")", "return", "\"r1l\"", ";", "if", "(", "regno", "==", "R1_REGNO", "&&", "(", "mlen", "==", "3", "||", "mlen", "==", "4", ")", ")", "return", "\"r3r1\"", ";", "if", "(", "regno", "==", "A0_REGNO", "&&", "TARGET_A16", "&&", "(", "mlen", "==", "3", "||", "mlen", "==", "4", ")", ")", "return", "\"a1a0\"", ";", "return", "reg_names", "[", "regno", "]", ";", "}", "</s>" ]

[ "Since", "register", "names", "indicate", "the", "mode", "they", "'re", "used", "in", ",", "we", "need", "a", "way", "to", "determine", "which", "name", "to", "refer", "to", "the", "register", "with", ".", "Called", "by", "print_operand", "(", ")", "." ]

[ "m32c", "1", "\"r0l\"", "3", "4", "\"r2r0\"", "6", "\"r2r1r0\"", "8", "\"r3r1r2r0\"", "1", "\"r1l\"", "3", "4", "\"r3r1\"", "3", "4", "\"a1a0\"" ]

[]