Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "rtx", "arm_function_value", "(", "tree", "type", ",", "tree", "func", "ATTRIBUTE_UNUSED", ")", "{", "enum", "machine_mode", "mode", ";", "int", "unsignedp", "ATTRIBUTE_UNUSED", ";", "rtx", "r", "ATTRIBUTE_UNUSED", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "if", "(", "INTEGRAL_TYPE_P", "(", "type", ")", ")", "PROMOTE_FUNCTION_MODE", "(", "mode", ",", "unsignedp", ",", "type", ")", ";", "if", "(", "arm_return_in_msb", "(", "type", ")", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "size", "%", "UNITS_PER_WORD", "!=", "0", ")", "{", "size", "+=", "UNITS_PER_WORD", "-", "size", "%", "UNITS_PER_WORD", ";", "mode", "=", "mode_for_size", "(", "size", "*", "BITS_PER_UNIT", ",", "MODE_INT", ",", "0", ")", ";", "}", "}", "return", "LIBCALL_VALUE", "(", "mode", ")", ";", "}", "</s>" ]

[ "Define", "how", "to", "find", "the", "value", "returned", "by", "a", "function", "." ]

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

[]

[ "<s>", "bool", "X86InstructionSelector", "::", "select", "(", "MachineInstr", "&", "I", ")", "const", "{", "assert", "(", "I", ".", "getParent", "(", ")", "&&", "\"Instruction should be in a basic block!\"", ")", ";", "assert", "(", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "&&", "\"Instruction should be in a function!\"", ")", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "I", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "unsigned", "Opcode", "=", "I", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opcode", ")", ")", "{", "if", "(", "I", ".", "isCopy", "(", ")", ")", "return", "selectCopy", "(", "I", ",", "MRI", ")", ";", "return", "true", ";", "}", "assert", "(", "I", ".", "getNumOperands", "(", ")", "==", "I", ".", "getNumExplicitOperands", "(", ")", "&&", "\"Generic instruction has unexpected implicit operands\\n\"", ")", ";", "if", "(", "selectImpl", "(", "I", ")", ")", "return", "true", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" C++ instruction selection: \"", ";", "I", ".", "print", "(", "dbgs", "(", ")", ")", ")", ";", "if", "(", "selectLoadStoreOp", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectFrameIndexOrGep", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectGlobalValue", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectConstant", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectTrunc", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectZext", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectCmp", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectUadde", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectUnmergeValues", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectMergeValues", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectExtract", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "if", "(", "selectInsert", "(", "I", ",", "MRI", ",", "MF", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"Instruction should be in a basic block!\"", "\"Instruction should be in a function!\"", "\"Generic instruction has unexpected implicit operands\\n\"", "\" C++ instruction selection: \"" ]

[]

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

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

[ "AArch64", "AArch64", "AArch64", "AArch64", "\"Register liveness not available!\"" ]

[]

[ "<s>", "SDNode", "*", "LEGDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "Constant", ":", "return", "SelectMoveImmediate", "(", "N", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "SelectConditionalBranch", "(", "N", ")", ";", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "ISD::Constant", "ISD::BR_CC" ]

[]

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

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

[ "PTX", "PTX" ]

[]

[ "<s>", "static", "void", "asm_print_register", "(", "FILE", "*", "file", ",", "int", "regno", ")", "{", "const", "char", "*", "name", "=", "reg_names", "[", "regno", "]", ";", "if", "(", "TARGET_NO_DIRECT_MODE", "&&", "name", "[", "0", "]", "==", "'*'", ")", "name", "++", ";", "fprintf", "(", "file", ",", "\"%s\"", ",", "name", ")", ";", "}", "</s>" ]

[ "Print", "the", "name", "of", "register", "'regno", "'", "in", "the", "assembly", "file", "." ]

[ "m68hc11", "0", "\"%s\"" ]

[]

[ "<s>", "bool", "ARMBaseRegisterInfo", "::", "needsFrameBaseReg", "(", "MachineInstr", "*", "MI", ",", "int64_t", "Offset", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "!", "MI", "->", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ";", "++", "i", ")", "{", "assert", "(", "i", "<", "MI", "->", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "STRi12", ":", "case", "ARM", "::", "STRH", ":", "case", "ARM", "::", "STRBi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2STRi12", ":", "case", "ARM", "::", "t2STRi8", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VSTRS", ":", "case", "ARM", "::", "VSTRD", ":", "case", "ARM", "::", "tSTRspi", ":", "case", "ARM", "::", "tLDRspi", ":", "if", "(", "ForceAllBaseRegAlloc", ")", "return", "true", ";", "break", ";", "default", ":", "return", "false", ";", "}", "MachineFunction", "&", "MF", "=", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int64_t", "FPOffset", "=", "Offset", "-", "8", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", "||", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ")", "FPOffset", "-=", "80", ";", "Offset", "=", "-", "Offset", ";", "Offset", "+=", "MFI", "->", "getLocalFrameSize", "(", ")", ";", "Offset", "+=", "128", ";", "unsigned", "StackAlign", "=", "TFI", "->", "getStackAlignment", "(", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "&&", "!", "(", "(", "MFI", "->", "getLocalFrameMaxAlign", "(", ")", ">", "StackAlign", ")", "&&", "canRealignStack", "(", "MF", ")", ")", ")", "{", "if", "(", "isFrameOffsetLegal", "(", "MI", ",", "FPOffset", ")", ")", "return", "false", ";", "}", "if", "(", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", "&&", "isFrameOffsetLegal", "(", "MI", ",", "Offset", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "'s", "frame", "index", "reference", "would", "be", "better", "served", "by", "a", "base", "register", "other", "than", "FP", "or", "SP", "." ]

[ "ARM", "ARM", "0", "\"Instr doesn't have FrameIndex operand!\"", "ARM::LDRi12", "ARM::LDRH", "ARM::LDRBi12", "ARM::STRi12", "ARM::STRH", "ARM::STRBi12", "ARM::t2LDRi12", "ARM::t2LDRi8", "ARM::t2STRi12", "ARM::t2STRi8", "ARM::VLDRS", "ARM::VLDRD", "ARM::VSTRS", "ARM::VSTRD", "ARM::tSTRspi", "ARM::tLDRspi", "ARM", "ARM", "8", "80", "128" ]

[]

[ "<s>", "const", "ELFNote", "*", "getNext", "(", "const", "ELFNote", "&", "N", ")", "{", "return", "reinterpret_cast", "<", "const", "ELFNote", "*", ">", "(", "N", ".", "getDesc", "(", ")", ".", "data", "(", ")", "+", "alignTo", "(", "N", ".", "descsz", ",", "ELFNote", "::", "ALIGN", ")", ")", ";", "}", "</s>" ]

[ "Get", "the", "next", "SDUse", "in", "the", "use", "list", "." ]

[ "AMDGPU" ]

[]

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

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

[ "Blackfin" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "areLoadsFromSameBasePtr", "(", "SDNode", "*", "Load1", ",", "SDNode", "*", "Load2", ",", "int64_t", "&", "Offset1", ",", "int64_t", "&", "Offset2", ")", "const", "{", "if", "(", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Load1", "->", "isMachineOpcode", "(", ")", "||", "!", "Load2", "->", "isMachineOpcode", "(", ")", ")", "return", "false", ";", "switch", "(", "Load1", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "LDRD", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRSB", ":", "case", "ARM", "::", "LDRSH", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRDi8", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "break", ";", "}", "switch", "(", "Load2", "->", "getMachineOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "LDRBi12", ":", "case", "ARM", "::", "LDRD", ":", "case", "ARM", "::", "LDRH", ":", "case", "ARM", "::", "LDRSB", ":", "case", "ARM", "::", "LDRSH", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "case", "ARM", "::", "t2LDRi8", ":", "case", "ARM", "::", "t2LDRDi8", ":", "case", "ARM", "::", "t2LDRSHi8", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "t2LDRSHi12", ":", "break", ";", "}", "if", "(", "Load1", "->", "getOperand", "(", "0", ")", "!=", "Load2", "->", "getOperand", "(", "0", ")", "||", "Load1", "->", "getOperand", "(", "4", ")", "!=", "Load2", "->", "getOperand", "(", "4", ")", ")", "return", "false", ";", "if", "(", "Load1", "->", "getOperand", "(", "3", ")", "!=", "Load2", "->", "getOperand", "(", "3", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "&&", "isa", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "1", ")", ")", ")", "{", "Offset1", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load1", "->", "getOperand", "(", "1", ")", ")", "->", "getSExtValue", "(", ")", ";", "Offset2", "=", "cast", "<", "ConstantSDNode", ">", "(", "Load2", "->", "getOperand", "(", "1", ")", ")", "->", "getSExtValue", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "areLoadsFromSameBasePtr", "-", "This", "is", "used", "by", "the", "pre-regalloc", "scheduler", "to", "determine", "if", "two", "loads", "are", "loading", "from", "the", "same", "base", "address", "." ]

[ "ARM", "ARM", "ARM::LDRi12", "ARM::LDRBi12", "ARM::LDRD", "ARM::LDRH", "ARM::LDRSB", "ARM::LDRSH", "ARM::VLDRD", "ARM::VLDRS", "ARM::t2LDRi8", "ARM::t2LDRDi8", "ARM::t2LDRSHi8", "ARM::t2LDRi12", "ARM::t2LDRSHi12", "ARM::LDRi12", "ARM::LDRBi12", "ARM::LDRD", "ARM::LDRH", "ARM::LDRSB", "ARM::LDRSH", "ARM::VLDRD", "ARM::VLDRS", "ARM::t2LDRi8", "ARM::t2LDRDi8", "ARM::t2LDRSHi8", "ARM::t2LDRi12", "ARM::t2LDRSHi12", "0", "0", "4", "4", "3", "3", "1", "1", "1", "1" ]

[]

[ "<s>", "bool", "FixupLEAPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "IsSlowLEA", "=", "ST", ".", "slowLEA", "(", ")", ";", "bool", "IsSlow3OpsLEA", "=", "ST", ".", "slow3OpsLEA", "(", ")", ";", "bool", "LEAUsesAG", "=", "ST", ".", "LEAusesAG", "(", ")", ";", "bool", "OptIncDec", "=", "!", "ST", ".", "slowIncDec", "(", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasOptSize", "(", ")", ";", "bool", "UseLEAForSP", "=", "ST", ".", "useLeaForSP", "(", ")", ";", "TSM", ".", "init", "(", "&", "ST", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86FixupLEAs\\n\"", ";", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "!", "isLEA", "(", "I", "->", "getOpcode", "(", ")", ")", ")", "continue", ";", "if", "(", "optTwoAddrLEA", "(", "I", ",", "MBB", ",", "OptIncDec", ",", "UseLEAForSP", ")", ")", "continue", ";", "if", "(", "IsSlowLEA", ")", "processInstructionForSlowLEA", "(", "I", ",", "MBB", ")", ";", "else", "if", "(", "IsSlow3OpsLEA", ")", "processInstrForSlow3OpLEA", "(", "I", ",", "MBB", ",", "OptIncDec", ")", ";", "}", "if", "(", "LEAUsesAG", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "processInstruction", "(", "I", ",", "MBB", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86FixupLEAs\\n\"", ";", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"Start X86FixupLEAs\\n\"", "\"End X86FixupLEAs\\n\"" ]

[]

[ "<s>", "AArch64TargetLowering", "::", "ConstraintType", "AArch64TargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'x'", ":", "case", "'w'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'Y'", ":", "case", "'Z'", ":", "return", "C_Immediate", ";", "case", "'z'", ":", "case", "'S'", ":", "return", "C_Other", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "1", "0" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "AArch64RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "assert", "(", "MF", "&&", "\"Invalid MachineFunction pointer.\"", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_LR_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetDarwin", "(", ")", ")", "return", "getDarwinCalleeSavedRegs", "(", "MF", ")", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CFGuard_Check", ")", "return", "CSR_Win_AArch64_CFGuard_Check_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isTargetWindows", "(", ")", ")", "return", "CSR_Win_AArch64_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_VectorCall", ")", "return", "CSR_AArch64_AAVPCS_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "AArch64_SVE_VectorCall", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "if", "(", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", "->", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "SwiftTail", ")", "return", "CSR_AArch64_AAPCS_SwiftTail_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_SaveList", ";", "if", "(", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "Win64", ")", "return", "CSR_AArch64_AAPCS_X18_SaveList", ";", "if", "(", "hasSVEArgsOrReturn", "(", "MF", ")", ")", "return", "CSR_AArch64_SVE_AAPCS_SaveList", ";", "return", "CSR_AArch64_AAPCS_SaveList", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"Invalid MachineFunction pointer.\"", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "static", "void", "mips_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "x", ")", "{", "struct", "mips_address_info", "addr", ";", "if", "(", "mips_classify_address", "(", "&", "addr", ",", "x", ",", "word_mode", ",", "true", ")", ")", "switch", "(", "addr", ".", "type", ")", "{", "case", "ADDRESS_REG", ":", "mips_print_operand", "(", "file", ",", "addr", ".", "offset", ",", "0", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "return", ";", "case", "ADDRESS_LO_SUM", ":", "mips_print_operand_reloc", "(", "file", ",", "addr", ".", "offset", ",", "SYMBOL_CONTEXT_MEM", ",", "mips_lo_relocs", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "return", ";", "case", "ADDRESS_CONST_INT", ":", "output_addr_const", "(", "file", ",", "x", ")", ";", "fprintf", "(", "file", ",", "\"(%s)\"", ",", "reg_names", "[", "GP_REG_FIRST", "]", ")", ";", "return", ";", "case", "ADDRESS_SYMBOLIC", ":", "output_addr_const", "(", "file", ",", "mips_strip_unspec_address", "(", "x", ")", ")", ";", "return", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "mips", "0", "\"(%s)\"", "\"(%s)\"", "\"(%s)\"" ]

[]

[ "<s>", "bool", "nios2_legitimate_pic_operand_p", "(", "rtx", "x", ")", "{", "if", "(", "nios2_large_unspec_reloc_p", "(", "x", ")", ")", "return", "true", ";", "return", "!", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", "||", "GET_CODE", "(", "x", ")", "==", "CONST", ")", ";", "}", "</s>" ]

[ "Nonzero", "if", "the", "constant", "value", "X", "is", "a", "legitimate", "general", "operand", "when", "generating", "PIC", "code", ".", "It", "is", "given", "that", "flag_pic", "is", "on", "and", "that", "X", "satisfies", "CONSTANT_P", "or", "is", "a", "CONST_DOUBLE", "." ]

[ "nios2" ]

[]

[ "<s>", "Liveness", "(", "MachineRegisterInfo", "&", "mri", ",", "const", "DataFlowGraph", "&", "g", ")", ":", "DFG", "(", "g", ")", ",", "TRI", "(", "g", ".", "getTRI", "(", ")", ")", ",", "MDT", "(", "g", ".", "getDT", "(", ")", ")", ",", "MDF", "(", "g", ".", "getDF", "(", ")", ")", ",", "MRI", "(", "mri", ")", ",", "LiveMap", "(", "g", ".", "getTRI", "(", ")", ")", ",", "Empty", "(", ")", ",", "NoRegs", "(", "g", ".", "getTRI", "(", ")", ")", ",", "Trace", "(", "false", ")", "{", "}", "</s>" ]

[ "During", "our", "initial", "pass", "over", "the", "program", ",", "we", "determine", "that", "things", "are", "either", "alive", "or", "maybe", "alive", ".", "More", "..." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "areOnlyUsersOf", "(", "SDNode", "*", "N", ",", "ArrayRef", "<", "SDValue", ">", "ValidUsers", ")", "{", "for", "(", "SDNode", "::", "use_iterator", "I", "=", "N", "->", "use_begin", "(", ")", ",", "E", "=", "N", "->", "use_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "llvm", "::", "all_of", "(", "ValidUsers", ",", "[", "&", "I", "]", "(", "SDValue", "V", ")", "{", "return", "V", ".", "getNode", "(", ")", "!=", "*", "I", ";", "}", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "all", "the", "users", "of", "N", "are", "contained", "in", "Nodes", "." ]

[ "X86" ]

[]

[ "<s>", "static", "void", "save_reg", "(", "int", "regno", ",", "unsigned", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "SImode", ",", "regno", ")", ";", "rtx", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "gen_int_mode", "(", "offset", ",", "Pmode", ")", ")", ";", "rtx", "insn", "=", "emit_move_insn", "(", "gen_frame_mem", "(", "Pmode", ",", "addr", ")", ",", "reg", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "</s>" ]

[ "Generate", "save/restore", "of", "register", "REGNO", "at", "SP", "+", "OFFSET", ".", "Used", "by", "the", "prologue/epilogue", "expand", "routines", "." ]

[ "nios2", "1" ]

[]

[ "<s>", "X86TargetMachine", "::", "X86TargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "TT", ",", "RM", ")", ",", "CM", ",", "OL", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", "{", "if", "(", "Subtarget", ".", "isTargetWin64", "(", ")", "||", "Subtarget", ".", "isTargetPS4", "(", ")", ")", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"sqrtf\"", ",", "true", ",", "1", ")", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"divf\"", ",", "false", ",", "1", ")", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"vec-sqrtf\"", ",", "true", ",", "1", ")", ";", "this", "->", "Options", ".", "Reciprocals", ".", "setDefaults", "(", "\"vec-divf\"", ",", "true", ",", "1", ")", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"sqrtf\"", "1", "\"divf\"", "1", "\"vec-sqrtf\"", "1", "\"vec-divf\"", "1" ]

[]

[ "<s>", "bool", "RISCVMCAsmBackend", "::", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "for", "(", "uint64_t", "I", "=", "0", ";", "I", "!=", "Count", ";", "++", "I", ")", "OW", "->", "write8", "(", "7", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "RISCV", "RISCV", "0", "7" ]

[]

[ "<s>", "void", "aarch64_split_simd_combine", "(", "rtx", "dst", ",", "rtx", "src1", ",", "rtx", "src2", ")", "{", "machine_mode", "src_mode", "=", "GET_MODE", "(", "src1", ")", ";", "machine_mode", "dst_mode", "=", "GET_MODE", "(", "dst", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "dst_mode", ")", ")", ";", "if", "(", "REG_P", "(", "dst", ")", "&&", "REG_P", "(", "src1", ")", "&&", "REG_P", "(", "src2", ")", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "switch", "(", "src_mode", ")", "{", "case", "V8QImode", ":", "gen", "=", "gen_aarch64_simd_combinev8qi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_aarch64_simd_combinev4hi", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_aarch64_simd_combinev2si", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_aarch64_simd_combinev2sf", ";", "break", ";", "case", "DImode", ":", "gen", "=", "gen_aarch64_simd_combinedi", ";", "break", ";", "case", "DFmode", ":", "gen", "=", "gen_aarch64_simd_combinedf", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen", "(", "dst", ",", "src1", ",", "src2", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Split", "a", "complex", "SIMD", "combine", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOLoad", ",", "Size", ",", "Align", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillRestoreOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", "&&", "RC", "->", "getSize", "(", ")", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "DestReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", ")", ";", "}", "return", ";", "}", "if", "(", "!", "ST", ".", "isVGPRSpillingEnabled", "(", "*", "MF", "->", "getFunction", "(", ")", ")", ")", "{", "LLVMContext", "&", "Ctx", "=", "MF", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "Ctx", ".", "emitError", "(", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "DestReg", ")", ";", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillRestoreOpcode", "(", "RC", "->", "getSize", "(", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getScratchWaveOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "AMDGPU::M0", "\"SIInstrInfo::loadRegFromStackSlot - Do not know how to\"", "\" restore register\"", "AMDGPU::IMPLICIT_DEF", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "bool", "Mips16FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "EntryBlock", "=", "&", "MF", "->", "front", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsRAAndRetAddrIsTaken", "=", "(", "Reg", "==", "Mips", "::", "RA", ")", "&&", "MF", "->", "getFrameInfo", "(", ")", ".", "isReturnAddressTaken", "(", ")", ";", "if", "(", "!", "IsRAAndRetAddrIsTaken", ")", "EntryBlock", "->", "addLiveIn", "(", "Reg", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "0", "Mips::RA" ]

[]

[ "<s>", "bool", "mayAlias", "(", "const", "MachineFrameInfo", "*", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "instruction", "'s", "memory", "access", "aliases", "the", "memory", "access", "of", "Other", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsResolved", ",", "const", "MCSubtargetInfo", "*", "STI", ")", "const", "override", "{", "unsigned", "Size", "=", "1", "<<", "getFixupKindLog2Size", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "assert", "(", "Fixup", ".", "getOffset", "(", ")", "+", "Size", "<=", "Data", ".", "size", "(", ")", "&&", "\"Invalid fixup offset!\"", ")", ";", "assert", "(", "isIntN", "(", "Size", "*", "8", "+", "1", ",", "Value", ")", "&&", "\"Value does not fit in the Fixup field\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "Data", "[", "Fixup", ".", "getOffset", "(", ")", "+", "i", "]", "=", "uint8_t", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", ";", "}", "</s>" ]

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

[ "X86", "1", "\"Invalid fixup offset!\"", "8", "1", "\"Value does not fit in the Fixup field\"", "0", "8" ]

[]

[ "<s>", "int", "expand_block_clear", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "orig_dest", "=", "operands", "[", "0", "]", ";", "rtx", "bytes_rtx", "=", "operands", "[", "1", "]", ";", "rtx", "align_rtx", "=", "operands", "[", "3", "]", ";", "bool", "constp", "=", "(", "GET_CODE", "(", "bytes_rtx", ")", "==", "CONST_INT", ")", ";", "HOST_WIDE_INT", "align", ";", "HOST_WIDE_INT", "bytes", ";", "int", "offset", ";", "int", "clear_bytes", ";", "int", "clear_step", ";", "if", "(", "!", "constp", ")", "return", "0", ";", "gcc_assert", "(", "GET_CODE", "(", "align_rtx", ")", "==", "CONST_INT", ")", ";", "align", "=", "INTVAL", "(", "align_rtx", ")", "*", "BITS_PER_UNIT", ";", "bytes", "=", "INTVAL", "(", "bytes_rtx", ")", ";", "if", "(", "bytes", "<=", "0", ")", "return", "1", ";", "if", "(", "TARGET_ALTIVEC", "&&", "align", ">=", "128", ")", "clear_step", "=", "16", ";", "else", "if", "(", "TARGET_POWERPC64", "&&", "align", ">=", "32", ")", "clear_step", "=", "8", ";", "else", "clear_step", "=", "4", ";", "if", "(", "optimize_size", "&&", "bytes", ">", "3", "*", "clear_step", ")", "return", "0", ";", "if", "(", "!", "optimize_size", "&&", "bytes", ">", "8", "*", "clear_step", ")", "return", "0", ";", "for", "(", "offset", "=", "0", ";", "bytes", ">", "0", ";", "offset", "+=", "clear_bytes", ",", "bytes", "-=", "clear_bytes", ")", "{", "enum", "machine_mode", "mode", "=", "BLKmode", ";", "rtx", "dest", ";", "if", "(", "bytes", ">=", "16", "&&", "TARGET_ALTIVEC", "&&", "align", ">=", "128", ")", "{", "clear_bytes", "=", "16", ";", "mode", "=", "V4SImode", ";", "}", "else", "if", "(", "bytes", ">=", "8", "&&", "TARGET_POWERPC64", "&&", "(", "align", ">=", "64", "||", "(", "!", "STRICT_ALIGNMENT", "&&", "align", ">=", "32", ")", ")", ")", "{", "clear_bytes", "=", "8", ";", "mode", "=", "DImode", ";", "}", "else", "if", "(", "bytes", ">=", "4", "&&", "(", "align", ">=", "32", "||", "!", "STRICT_ALIGNMENT", ")", ")", "{", "clear_bytes", "=", "4", ";", "mode", "=", "SImode", ";", "}", "else", "if", "(", "bytes", ">=", "2", "&&", "(", "align", ">=", "16", "||", "!", "STRICT_ALIGNMENT", ")", ")", "{", "clear_bytes", "=", "2", ";", "mode", "=", "HImode", ";", "}", "else", "{", "clear_bytes", "=", "1", ";", "mode", "=", "QImode", ";", "}", "dest", "=", "adjust_address", "(", "orig_dest", ",", "mode", ",", "offset", ")", ";", "emit_move_insn", "(", "dest", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Expand", "a", "block", "clear", "operation", ",", "and", "return", "1", "if", "successful", ".", "Return", "0", "if", "we", "should", "let", "the", "compiler", "generate", "normal", "code", ".", "operands", "[", "0", "]", "is", "the", "destination", "operands", "[", "1", "]", "is", "the", "length", "operands", "[", "3", "]", "is", "the", "alignment" ]

[ "rs6000", "0", "1", "3", "0", "0", "1", "128", "16", "32", "8", "4", "3", "0", "8", "0", "0", "0", "16", "128", "16", "8", "64", "32", "8", "4", "32", "4", "2", "16", "2", "1", "1" ]

[]

[ "<s>", "static", "rtx", "frv_expand_prefetches", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "force_reg", "(", "Pmode", ",", "op0", ")", ")", ";", "if", "(", "!", "pat", ")", "return", "0", ";", "emit_insn", "(", "pat", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Expand", "prefetch", "builtins", ".", "These", "take", "a", "single", "address", "as", "argument", "." ]

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

[]

[ "<s>", "unsigned", "SIRegisterInfo", "::", "getRegPressureSetLimit", "(", "unsigned", "Idx", ")", "const", "{", "unsigned", "SGPRLimit", "=", "getNumSGPRsAllowed", "(", "ST", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "unsigned", "VGPRLimit", "=", "getNumVGPRsAllowed", "(", "ST", ".", "getMaxWavesPerCU", "(", ")", ")", ";", "for", "(", "regclass_iterator", "I", "=", "regclass_begin", "(", ")", ",", "E", "=", "regclass_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "NumSubRegs", "=", "std", "::", "max", "(", "(", "int", ")", "(", "*", "I", ")", "->", "getSize", "(", ")", "/", "4", ",", "1", ")", ";", "unsigned", "Limit", ";", "if", "(", "isSGPRClass", "(", "*", "I", ")", ")", "{", "Limit", "=", "SGPRLimit", "/", "NumSubRegs", ";", "}", "else", "{", "Limit", "=", "VGPRLimit", "/", "NumSubRegs", ";", "}", "const", "int", "*", "Sets", "=", "getRegClassPressureSets", "(", "*", "I", ")", ";", "assert", "(", "Sets", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "Sets", "[", "i", "]", "!=", "-", "1", ";", "++", "i", ")", "{", "if", "(", "Sets", "[", "i", "]", "==", "(", "int", ")", "Idx", ")", "return", "Limit", ";", "}", "}", "return", "256", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "GCNUpwardRPTracker", "::", "isValid", "(", ")", "const", "{", "const", "auto", "&", "SI", "=", "LIS", ".", "getInstructionIndex", "(", "*", "LastTrackedMI", ")", ".", "getBaseIndex", "(", ")", ";", "const", "auto", "LISLR", "=", "llvm", "::", "getLiveRegs", "(", "SI", ",", "LIS", ",", "*", "MRI", ")", ";", "const", "auto", "&", "TrackedLR", "=", "LiveRegs", ";", "if", "(", "!", "isEqual", "(", "LISLR", ",", "TrackedLR", ")", ")", "{", "dbgs", "(", ")", "<<", "\"\\nGCNUpwardRPTracker error: Tracked and\"", "\" LIS reported livesets mismatch:\\n\"", ";", "printLivesAt", "(", "SI", ",", "LIS", ",", "*", "MRI", ")", ";", "reportMismatch", "(", "LISLR", ",", "TrackedLR", ",", "MRI", "->", "getTargetRegisterInfo", "(", ")", ")", ";", "return", "false", ";", "}", "auto", "LISPressure", "=", "getRegPressure", "(", "*", "MRI", ",", "LISLR", ")", ";", "if", "(", "LISPressure", "!=", "CurPressure", ")", "{", "dbgs", "(", ")", "<<", "\"GCNUpwardRPTracker error: Pressure sets different\\nTracked: \"", ";", "CurPressure", ".", "print", "(", "dbgs", "(", ")", ")", ";", "dbgs", "(", ")", "<<", "\"LIS rpt: \"", ";", "LISPressure", ".", "print", "(", "dbgs", "(", ")", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "this", "iterator", "is", "still", "pointing", "at", "a", "valid", "entry", "." ]

[ "AMDGPU", "SI", "SI", "\"\\nGCNUpwardRPTracker error: Tracked and\"", "\" LIS reported livesets mismatch:\\n\"", "SI", "\"GCNUpwardRPTracker error: Pressure sets different\\nTracked: \"", "\"LIS rpt: \"" ]

[]

[ "<s>", "const", "char", "*", "nvptx_output_mov_insn", "(", "rtx", "dst", ",", "rtx", "src", ")", "{", "machine_mode", "dst_mode", "=", "GET_MODE", "(", "dst", ")", ";", "machine_mode", "dst_inner", "=", "(", "GET_CODE", "(", "dst", ")", "==", "SUBREG", "?", "GET_MODE", "(", "XEXP", "(", "dst", ",", "0", ")", ")", ":", "dst_mode", ")", ";", "machine_mode", "src_inner", "=", "(", "GET_CODE", "(", "src", ")", "==", "SUBREG", "?", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", ":", "dst_mode", ")", ";", "rtx", "sym", "=", "src", ";", "if", "(", "GET_CODE", "(", "sym", ")", "==", "CONST", ")", "sym", "=", "XEXP", "(", "XEXP", "(", "sym", ",", "0", ")", ",", "0", ")", ";", "if", "(", "SYMBOL_REF_P", "(", "sym", ")", ")", "{", "if", "(", "SYMBOL_DATA_AREA", "(", "sym", ")", "!=", "DATA_AREA_GENERIC", ")", "return", "\"%.\\tcvta%D1%t0\\t%0, %1;\"", ";", "nvptx_maybe_record_fnsym", "(", "sym", ")", ";", "}", "if", "(", "src_inner", "==", "dst_inner", ")", "return", "\"%.\\tmov%t0\\t%0, %1;\"", ";", "if", "(", "CONSTANT_P", "(", "src", ")", ")", "return", "(", "GET_MODE_CLASS", "(", "dst_inner", ")", "==", "MODE_INT", "&&", "GET_MODE_CLASS", "(", "src_inner", ")", "!=", "MODE_FLOAT", "?", "\"%.\\tmov%t0\\t%0, %1;\"", ":", "\"%.\\tmov.b%T0\\t%0, %1;\"", ")", ";", "if", "(", "GET_MODE_SIZE", "(", "dst_inner", ")", "==", "GET_MODE_SIZE", "(", "src_inner", ")", ")", "return", "\"%.\\tmov.b%T0\\t%0, %1;\"", ";", "return", "\"%.\\tcvt%t0%t1\\t%0, %1;\"", ";", "}", "</s>" ]

[ "Output", "a", "pattern", "for", "a", "move", "instruction", "." ]

[ "nvptx", "0", "0", "0", "0", "\"%.\\tcvta%D1%t0\\t%0, %1;\"", "\"%.\\tmov%t0\\t%0, %1;\"", "\"%.\\tmov%t0\\t%0, %1;\"", "\"%.\\tmov.b%T0\\t%0, %1;\"", "\"%.\\tmov.b%T0\\t%0, %1;\"", "\"%.\\tcvt%t0%t1\\t%0, %1;\"" ]

[]

[ "<s>", "Liveness", "(", "MachineRegisterInfo", "&", "mri", ",", "const", "DataFlowGraph", "&", "g", ")", ":", "DFG", "(", "g", ")", ",", "TRI", "(", "g", ".", "getTRI", "(", ")", ")", ",", "PRI", "(", "g", ".", "getPRI", "(", ")", ")", ",", "MDT", "(", "g", ".", "getDT", "(", ")", ")", ",", "MDF", "(", "g", ".", "getDF", "(", ")", ")", ",", "LiveMap", "(", "g", ".", "getPRI", "(", ")", ")", ",", "Empty", "(", ")", ",", "NoRegs", "(", "g", ".", "getPRI", "(", ")", ")", ",", "Trace", "(", "false", ")", "{", "}", "</s>" ]

[ "During", "our", "initial", "pass", "over", "the", "program", ",", "we", "determine", "that", "things", "are", "either", "alive", "or", "maybe", "alive", ".", "More", "..." ]

[ "Hexagon" ]

[]

[ "<s>", "const", "char", "*", "getSymbol", "(", ")", "const", "{", "return", "S", ";", "}", "</s>" ]

[ "Get", "the", "target", "address", "and", "flags", "for", "the", "named", "symbol", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "xstormy16_asm_output_aligned_common", "(", "FILE", "*", "stream", ",", "tree", "decl", ",", "const", "char", "*", "name", ",", "int", "size", ",", "int", "align", ",", "int", "global", ")", "{", "rtx", "mem", "=", "decl", "==", "NULL_TREE", "?", "NULL_RTX", ":", "DECL_RTL", "(", "decl", ")", ";", "rtx", "symbol", ";", "if", "(", "mem", "!=", "NULL_RTX", "&&", "MEM_P", "(", "mem", ")", "&&", "GET_CODE", "(", "symbol", "=", "XEXP", "(", "mem", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FLAGS", "(", "symbol", ")", "&", "SYMBOL_FLAG_XSTORMY16_BELOW100", ")", "{", "const", "char", "*", "name2", ";", "int", "p2align", "=", "0", ";", "switch_to_section", "(", "bss100_section", ")", ";", "while", "(", "align", ">", "8", ")", "{", "align", "/=", "2", ";", "p2align", "++", ";", "}", "name2", "=", "default_strip_name_encoding", "(", "name", ")", ";", "if", "(", "global", ")", "fprintf", "(", "stream", ",", "\"\\t.globl\\t%s\\n\"", ",", "name2", ")", ";", "if", "(", "p2align", ")", "fprintf", "(", "stream", ",", "\"\\t.p2align %d\\n\"", ",", "p2align", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.type\\t%s, @object\\n\"", ",", "name2", ")", ";", "fprintf", "(", "stream", ",", "\"\\t.size\\t%s, %d\\n\"", ",", "name2", ",", "size", ")", ";", "fprintf", "(", "stream", ",", "\"%s:\\n\\t.space\\t%d\\n\"", ",", "name2", ",", "size", ")", ";", "return", ";", "}", "if", "(", "!", "global", ")", "{", "fprintf", "(", "stream", ",", "\"\\t.local\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "fprintf", "(", "stream", ",", "\"\\t.comm\\t\"", ")", ";", "assemble_name", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\",%u,%u\\n\"", ",", "size", ",", "align", "/", "BITS_PER_UNIT", ")", ";", "}", "</s>" ]

[ "The", "purpose", "of", "this", "function", "is", "to", "override", "the", "default", "behavior", "of", "BSS", "objects", ".", "Normally", ",", "they", "go", "into", ".bss", "or", ".sbss", "via", "``", ".common", "''", "directives", ",", "but", "we", "need", "to", "override", "that", "and", "put", "them", "in", ".bss_below100", ".", "We", "ca", "n't", "just", "use", "a", "section", "override", "(", "like", "we", "do", "for", ".data_below100", ")", ",", "because", "that", "makes", "them", "initialized", "rather", "than", "uninitialized", "." ]

[ "stormy16", "0", "0", "8", "2", "\"\\t.globl\\t%s\\n\"", "\"\\t.p2align %d\\n\"", "\"\\t.type\\t%s, @object\\n\"", "\"\\t.size\\t%s, %d\\n\"", "\"%s:\\n\\t.space\\t%d\\n\"", "\"\\t.local\\t\"", "\"\\n\"", "\"\\t.comm\\t\"", "\",%u,%u\\n\"" ]

[]

[ "<s>", "const", "unsigned", "*", "ARMRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "CalleeSavedRegs", "[", "]", "=", "{", "ARM", "::", "LR", ",", "ARM", "::", "R11", ",", "ARM", "::", "R10", ",", "ARM", "::", "R9", ",", "ARM", "::", "R8", ",", "ARM", "::", "R7", ",", "ARM", "::", "R6", ",", "ARM", "::", "R5", ",", "ARM", "::", "R4", ",", "ARM", "::", "D15", ",", "ARM", "::", "D14", ",", "ARM", "::", "D13", ",", "ARM", "::", "D12", ",", "ARM", "::", "D11", ",", "ARM", "::", "D10", ",", "ARM", "::", "D9", ",", "ARM", "::", "D8", ",", "0", "}", ";", "static", "const", "unsigned", "DarwinCalleeSavedRegs", "[", "]", "=", "{", "ARM", "::", "LR", ",", "ARM", "::", "R7", ",", "ARM", "::", "R6", ",", "ARM", "::", "R5", ",", "ARM", "::", "R4", ",", "ARM", "::", "R11", ",", "ARM", "::", "R10", ",", "ARM", "::", "R9", ",", "ARM", "::", "R8", ",", "ARM", "::", "D15", ",", "ARM", "::", "D14", ",", "ARM", "::", "D13", ",", "ARM", "::", "D12", ",", "ARM", "::", "D11", ",", "ARM", "::", "D10", ",", "ARM", "::", "D9", ",", "ARM", "::", "D8", ",", "0", "}", ";", "return", "STI", ".", "isTargetDarwin", "(", ")", "?", "DarwinCalleeSavedRegs", ":", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::LR", "ARM::R11", "ARM::R10", "ARM::R9", "ARM::R8", "ARM::R7", "ARM::R6", "ARM::R5", "ARM::R4", "ARM::D15", "ARM::D14", "ARM::D13", "ARM::D12", "ARM::D11", "ARM::D10", "ARM::D9", "ARM::D8", "0", "ARM::LR", "ARM::R7", "ARM::R6", "ARM::R5", "ARM::R4", "ARM::R11", "ARM::R10", "ARM::R9", "ARM::R8", "ARM::D15", "ARM::D14", "ARM::D13", "ARM::D12", "ARM::D11", "ARM::D10", "ARM::D9", "ARM::D8", "0" ]

[]

[ "<s>", "static", "bool", "s390_adjust_loop_scan_osc", "(", "struct", "loop", "*", "loop", ")", "{", "HARD_REG_SET", "modregs", ",", "newregs", ";", "rtx_insn", "*", "insn", ",", "*", "store_insn", "=", "NULL", ";", "rtx", "set", ";", "struct", "s390_address", "addr_store", ",", "addr_load", ";", "subrtx_iterator", "::", "array_type", "array", ";", "int", "insn_count", ";", "CLEAR_HARD_REG_SET", "(", "modregs", ")", ";", "insn_count", "=", "0", ";", "FOR_BB_INSNS_REVERSE", "(", "loop", "->", "latch", ",", "insn", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "<=", "0", ")", "continue", ";", "insn_count", "++", ";", "if", "(", "insn_count", ">", "S390_OSC_SCAN_INSN_NUM", ")", "return", "false", ";", "find_all_hard_reg_sets", "(", "insn", ",", "&", "newregs", ",", "true", ")", ";", "modregs", "|=", "newregs", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "continue", ";", "if", "(", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", "&&", "s390_decompose_address", "(", "XEXP", "(", "SET_DEST", "(", "set", ")", ",", "0", ")", ",", "&", "addr_store", ")", ")", "{", "store_insn", "=", "insn", ";", "break", ";", "}", "}", "if", "(", "store_insn", "==", "NULL_RTX", ")", "return", "false", ";", "insn_count", "=", "0", ";", "FOR_BB_INSNS", "(", "loop", "->", "header", ",", "insn", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "<=", "0", ")", "continue", ";", "if", "(", "insn", "==", "store_insn", ")", "return", "false", ";", "insn_count", "++", ";", "if", "(", "insn_count", ">", "S390_OSC_SCAN_INSN_NUM", ")", "return", "false", ";", "find_all_hard_reg_sets", "(", "insn", ",", "&", "newregs", ",", "true", ")", ";", "modregs", "|=", "newregs", ";", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "continue", ";", "if", "(", "MEM_P", "(", "SET_DEST", "(", "set", ")", ")", "&&", "s390_decompose_address", "(", "XEXP", "(", "SET_DEST", "(", "set", ")", ",", "0", ")", ",", "NULL", ")", ")", "return", "false", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "SET_SRC", "(", "set", ")", ",", "NONCONST", ")", "if", "(", "MEM_P", "(", "*", "iter", ")", "&&", "s390_decompose_address", "(", "XEXP", "(", "*", "iter", ",", "0", ")", ",", "&", "addr_load", ")", "&&", "rtx_equal_p", "(", "addr_load", ".", "base", ",", "addr_store", ".", "base", ")", "&&", "rtx_equal_p", "(", "addr_load", ".", "indx", ",", "addr_store", ".", "indx", ")", "&&", "rtx_equal_p", "(", "addr_load", ".", "disp", ",", "addr_store", ".", "disp", ")", ")", "{", "if", "(", "(", "addr_load", ".", "base", "!=", "NULL_RTX", "&&", "TEST_HARD_REG_BIT", "(", "modregs", ",", "REGNO", "(", "addr_load", ".", "base", ")", ")", ")", "||", "(", "addr_load", ".", "indx", "!=", "NULL_RTX", "&&", "TEST_HARD_REG_BIT", "(", "modregs", ",", "REGNO", "(", "addr_load", ".", "indx", ")", ")", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Scan", "LOOP", "for", "static", "OSC", "collisions", "and", "return", "true", "if", "a", "osc_break", "should", "be", "issued", "for", "this", "loop", "." ]

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

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "AMDGPU_KERNEL", ")", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "EVT", "ScalarVT", "=", "VT", ".", "getScalarType", "(", ")", ";", "unsigned", "Size", "=", "ScalarVT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "Size", "==", "16", "&&", "Subtarget", "->", "has16BitInsts", "(", ")", ")", "return", "(", "NumElts", "+", "1", ")", "/", "2", ";", "if", "(", "Size", "<=", "32", ")", "return", "NumElts", ";", "if", "(", "Size", ">", "32", ")", "return", "NumElts", "*", "(", "(", "Size", "+", "31", ")", "/", "32", ")", ";", "}", "else", "if", "(", "VT", ".", "getSizeInBits", "(", ")", ">", "32", ")", "return", "(", "VT", ".", "getSizeInBits", "(", ")", "+", "31", ")", "/", "32", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "AMDGPU", "SI", "AMDGPU", "16", "1", "2", "32", "32", "31", "32", "32", "31", "32" ]

[]

[ "<s>", "SDValue", "TLCS900TargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "doesNotRet", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "TLCS900_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "TLCS900", "TLCS900", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"", "TLCS900", "\"ISRs cannot be called directly\"" ]

[]

[ "<s>", "int", "arm_const_double_inline_cost", "(", "rtx", "val", ")", "{", "rtx", "lowpart", ",", "highpart", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "val", ")", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "DImode", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", ")", ";", "lowpart", "=", "gen_lowpart", "(", "SImode", ",", "val", ")", ";", "highpart", "=", "gen_highpart_mode", "(", "SImode", ",", "mode", ",", "val", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "lowpart", ")", ")", ";", "gcc_assert", "(", "CONST_INT_P", "(", "highpart", ")", ")", ";", "return", "(", "arm_gen_constant", "(", "SET", ",", "SImode", ",", "NULL_RTX", ",", "INTVAL", "(", "lowpart", ")", ",", "NULL_RTX", ",", "NULL_RTX", ",", "0", ",", "0", ")", "+", "arm_gen_constant", "(", "SET", ",", "SImode", ",", "NULL_RTX", ",", "INTVAL", "(", "highpart", ")", ",", "NULL_RTX", ",", "NULL_RTX", ",", "0", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "synthesizing", "a", "64-bit", "constant", "VAL", "inline", ".", "Returns", "the", "number", "of", "insns", "needed", ",", "or", "99", "if", "we", "do", "n't", "know", "how", "to", "do", "it", "." ]

[ "arm", "8", "0", "0", "0", "0" ]

[]

[ "<s>", "EVT", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "override", "{", "return", "MVT", "::", "i257", ";", "}", "</s>" ]

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

[ "TVM", "MVT::i257" ]

[]

[ "<s>", "bool", "MVELaneInterleaving", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableInterleave", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "SmallPtrSet", "<", "Instruction", "*", ",", "16", ">", "Visited", ";", "for", "(", "Instruction", "&", "I", ":", "reverse", "(", "instructions", "(", "F", ")", ")", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", "&&", "(", "isa", "<", "TruncInst", ">", "(", "I", ")", "||", "isa", "<", "FPTruncInst", ">", "(", "I", ")", ")", "&&", "!", "Visited", ".", "count", "(", "&", "I", ")", ")", "Changed", "|=", "tryInterleave", "(", "&", "I", ",", "Visited", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "symbolic_memory_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "SYMBOL_REF", ":", "case", "LABEL_REF", ":", "return", "1", ";", "case", "CONST", ":", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "LABEL_REF", ")", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "case", "CONST_DOUBLE", ":", "return", "GET_MODE", "(", "op", ")", "==", "mode", ";", "case", "PLUS", ":", "return", "symbolic_memory_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ")", "&&", "symbolic_memory_operand", "(", "XEXP", "(", "op", ",", "1", ")", ",", "mode", ")", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Returns", "1", "if", "OP", "is", "a", "memory", "reference", "involving", "a", "symbolic", "constant", "that", "is", "not", "in", "the", "constant", "pool", "." ]

[ "m68hc11", "1", "0", "0", "0", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "X86RegisterAllocator", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "outs", "(", ")", "<<", "\"\\n\"", "<<", "\"=====================\\n\"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"()\\n=====================\"", "<<", "\"\\n\"", ";", "MachineRegisterInfo", "&", "regInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "reloop", ":", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "auto", "mi", "=", "&", "MI", ";", "if", "(", "mi", "->", "isInsertSubreg", "(", ")", ")", "{", "unsigned", "SubIdx", "=", "mi", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "mi", "->", "RemoveOperand", "(", "3", ")", ";", "assert", "(", "mi", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "\"Unexpected subreg idx\"", ")", ";", "mi", "->", "getOperand", "(", "0", ")", ".", "setSubReg", "(", "SubIdx", ")", ";", "mi", "->", "getOperand", "(", "0", ")", ".", "setIsUndef", "(", "mi", "->", "getOperand", "(", "1", ")", ".", "isUndef", "(", ")", ")", ";", "mi", "->", "RemoveOperand", "(", "1", ")", ";", "mi", "->", "setDesc", "(", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ")", ";", "(", "--", "getIterForMI", "(", "MI", ")", ")", "->", "eraseFromParent", "(", ")", ";", "goto", "reloop", ";", "}", "}", "outs", "(", ")", "<<", "\"Contents of MachineBasicBlock:\\n\"", ";", "outs", "(", ")", "<<", "MBB", "<<", "\"\\n\"", ";", "outs", "(", ")", ".", "flush", "(", ")", ";", "}", "spilledRegisters", ".", "clear", "(", ")", ";", "BEGINNING", ":", "for", "(", "LiveRange", "*", "LR", ":", "interferenceGraph", ")", "{", "delete", "LR", ";", "}", "interferenceGraph", ".", "clear", "(", ")", ";", "interferenceGraphRetrieval", ".", "clear", "(", ")", ";", "livenessInformation", ".", "clear", "(", ")", ";", "phiNodes", ".", "clear", "(", ")", ";", "calcGlobalLivenessInfo", "(", "MF", ",", "regInfo", ")", ";", "if", "(", "interferenceGraph", ".", "size", "(", ")", ">", "0", "&&", "color", "(", "MF", ",", "regInfo", ")", "==", "EXIT_STATUS_T", "::", "SPILLED", ")", "{", "goto", "BEGINNING", ";", "}", "for", "(", "MachineInstr", "*", "MI", ":", "getPhiNodes", "(", ")", ")", "{", "MI", "->", "eraseFromParent", "(", ")", ";", "}", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "NoPHIs", ")", ";", "MF", ".", "getProperties", "(", ")", ".", "set", "(", "MachineFunctionProperties", "::", "Property", "::", "NoVRegs", ")", ";", "outs", "(", ")", "<<", "\"\\n\\n\"", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "outs", "(", ")", "<<", "\"Contents of MachineBasicBlock:\\n\"", ";", "outs", "(", ")", "<<", "MBB", "<<", "\"\\n\"", ";", "outs", "(", ")", ".", "flush", "(", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"\\n\"", "\"=====================\\n\"", "\"()\\n=====================\"", "\"\\n\"", "3", "3", "0", "0", "\"Unexpected subreg idx\"", "0", "0", "1", "1", "\"Contents of MachineBasicBlock:\\n\"", "\"\\n\"", "0", "\"\\n\\n\"", "\"Contents of MachineBasicBlock:\\n\"", "\"\\n\"" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "AMDGPU", "SI" ]

[]

[ "<s>", "static", "rtx", "ix86_function_arg", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "omode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "machine_mode", "mode", "=", "omode", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "rtx", "arg", ";", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "cum", "->", "bnds_in_bt", ")", "arg", "=", "NULL", ";", "else", "if", "(", "cum", "->", "bnd_regno", "<=", "LAST_BND_REG", ")", "arg", "=", "gen_rtx_REG", "(", "BNDmode", ",", "cum", "->", "bnd_regno", ")", ";", "else", "arg", "=", "GEN_INT", "(", "cum", "->", "bnd_regno", "-", "LAST_BND_REG", "-", "1", ")", ";", "return", "arg", ";", "}", "if", "(", "mode", "==", "BLKmode", ")", "bytes", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "CEIL", "(", "bytes", ",", "UNITS_PER_WORD", ")", ";", "if", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "mode", "=", "type_natural_mode", "(", "type", ",", "cum", ",", "false", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "enum", "calling_abi", "call_abi", "=", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ";", "if", "(", "call_abi", "==", "MS_ABI", ")", "arg", "=", "function_arg_ms_64", "(", "cum", ",", "mode", ",", "omode", ",", "named", ",", "bytes", ")", ";", "else", "arg", "=", "function_arg_64", "(", "cum", ",", "mode", ",", "omode", ",", "type", ",", "named", ")", ";", "}", "else", "arg", "=", "function_arg_32", "(", "cum", ",", "mode", ",", "omode", ",", "type", ",", "bytes", ",", "words", ")", ";", "return", "arg", ";", "}", "</s>" ]

[ "Return", "where", "to", "put", "the", "arguments", "to", "a", "function", ".", "Return", "zero", "to", "push", "the", "argument", "on", "the", "stack", ",", "or", "a", "hard", "register", "in", "which", "to", "store", "the", "argument", ".", "MODE", "is", "the", "argument", "'s", "machine", "mode", ".", "TYPE", "is", "the", "data", "type", "of", "the", "argument", ".", "It", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", "CUM", "gives", "information", "about", "the", "preceding", "args", "and", "about", "the", "function", "being", "called", ".", "NAMED", "is", "nonzero", "if", "this", "argument", "is", "a", "named", "parameter", "(", "otherwise", "it", "is", "an", "extra", "parameter", "matching", "an", "ellipsis", ")", "." ]

[ "i386", "1" ]

[]

[ "<s>", "bool", "isFPImm", "(", ")", "const", "{", "if", "(", "!", "isImm", "(", ")", ")", "return", "false", ";", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "getImm", "(", ")", ")", ";", "if", "(", "!", "CE", ")", "return", "false", ";", "int", "Val", "=", "ARM_AM", "::", "getFP32Imm", "(", "APInt", "(", "32", ",", "CE", "->", "getValue", "(", ")", ")", ")", ";", "return", "Val", "!=", "-", "1", ";", "}", "</s>" ]

[ "isFPImm", "-", "Tests", "if", "this", "is", "a", "MO_FPImmediate", "operand", "." ]

[ "ARM", "ARM_AM::getFP32Imm", "32", "1" ]

[]

[ "<s>", "static", "bool", "arm_have_conditional_execution", "(", "void", ")", "{", "bool", "has_cond_exec", ",", "enable_ifcvt_trans", ";", "has_cond_exec", "=", "!", "TARGET_THUMB1", ";", "enable_ifcvt_trans", "=", "TARGET_COND_ARITH", "&&", "!", "reload_completed", ";", "return", "has_cond_exec", "&&", "!", "enable_ifcvt_trans", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_HAVE_CONDITIONAL_EXECUTION", "hook", ".", "All", "modes", "except", "THUMB1", "have", "conditional", "execution", ".", "If", "we", "have", "conditional", "arithmetic", ",", "return", "false", "before", "reload", "to", "enable", "some", "ifcvt", "transformations", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "rl78_regno_mode_code_ok_for_base_p", "(", "int", "regno", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "addr_space_t", "address_space", "ATTRIBUTE_UNUSED", ",", "int", "outer_code", "ATTRIBUTE_UNUSED", ",", "int", "index_code", ")", "{", "if", "(", "regno", "<=", "SP_REG", "&&", "regno", ">=", "16", ")", "return", "true", ";", "if", "(", "index_code", "==", "REG", ")", "return", "(", "regno", "==", "HL_REG", ")", ";", "if", "(", "regno", "==", "C_REG", "||", "regno", "==", "B_REG", "||", "regno", "==", "E_REG", "||", "regno", "==", "L_REG", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "REGNO_MODE_CODE_OK_FOR_BASE_P", "." ]

[ "rl78", "16" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "R600", "ISD::OutputArg", "AMDGPUISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "bool", "ix86_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "darwin_local_data_pic", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOT", ":", "case", "UNSPEC_GOTOFF", ":", "case", "UNSPEC_PLTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "case", "UNSPEC_NTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "case", "UNSPEC_DTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "SYMBOL_REF_DLLIMPORT_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "MACHO_DYNAMIC_NO_PIC_P", ")", "return", "machopic_symbol_defined_p", "(", "x", ")", ";", "if", "(", "ix86_force_load_from_GOT_p", "(", "x", ")", ")", "return", "false", ";", "break", ";", "CASE_CONST_SCALAR_INT", ":", "switch", "(", "mode", ")", "{", "case", "TImode", ":", "if", "(", "TARGET_64BIT", ")", "return", "true", ";", "case", "OImode", ":", "case", "XImode", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ",", "mode", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "break", ";", "case", "CONST_VECTOR", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ",", "mode", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]

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

[]

[ "<s>", "bool", "HexagonCommonGEP", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "for", "(", "Function", "::", "iterator", "A", "=", "F", ".", "begin", "(", ")", ",", "Z", "=", "F", ".", "end", "(", ")", ";", "A", "!=", "Z", ";", "++", "A", ")", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "A", "->", "begin", "(", ")", ",", "E", "=", "A", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "isa", "<", "InvokeInst", ">", "(", "I", ")", "||", "isa", "<", "LandingPadInst", ">", "(", "I", ")", ")", "return", "false", ";", "Fn", "=", "&", "F", ";", "DT", "=", "&", "getAnalysis", "<", "DominatorTreeWrapperPass", ">", "(", ")", ".", "getDomTree", "(", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "PostDominatorTreeWrapperPass", ">", "(", ")", ".", "getPostDomTree", "(", ")", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "Ctx", "=", "&", "F", ".", "getContext", "(", ")", ";", "Nodes", ".", "clear", "(", ")", ";", "Uses", ".", "clear", "(", ")", ";", "NodeOrder", ".", "clear", "(", ")", ";", "SpecificBumpPtrAllocator", "<", "GepNode", ">", "Allocator", ";", "Mem", "=", "&", "Allocator", ";", "collect", "(", ")", ";", "common", "(", ")", ";", "NodeToValueMap", "Loc", ";", "computeNodePlacement", "(", "Loc", ")", ";", "materialize", "(", "Loc", ")", ";", "removeDeadCode", "(", ")", ";", "if", "(", "verifyFunction", "(", "F", ",", "&", "dbgs", "(", ")", ")", ")", "report_fatal_error", "(", "\"Broken function\"", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "\"Broken function\"" ]

[]

[ "<s>", "static", "void", "ix86_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "HOST_WIDE_INT", "bytes", ",", "words", ";", "int", "nregs", ";", "if", "(", "mode", "==", "BLKmode", ")", "bytes", "=", "int_size_in_bytes", "(", "type", ")", ";", "else", "bytes", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "words", "=", "(", "bytes", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "type", ")", "mode", "=", "type_natural_mode", "(", "type", ",", "NULL", ",", "false", ")", ";", "if", "(", "(", "type", "&&", "POINTER_BOUNDS_TYPE_P", "(", "type", ")", ")", "||", "POINTER_BOUNDS_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "cum", "->", "bnds_in_bt", ")", "{", "cum", "->", "bnds_in_bt", "--", ";", "return", ";", "}", "if", "(", "cum", "->", "force_bnd_pass", ")", "cum", "->", "force_bnd_pass", "--", ";", "cum", "->", "bnd_regno", "++", ";", "return", ";", "}", "cum", "->", "bnds_in_bt", "=", "0", ";", "if", "(", "cum", "->", "force_bnd_pass", ")", "{", "cum", "->", "bnd_regno", "+=", "cum", "->", "force_bnd_pass", ";", "cum", "->", "force_bnd_pass", "=", "0", ";", "}", "if", "(", "TARGET_64BIT", "&&", "(", "cum", "?", "cum", "->", "call_abi", ":", "ix86_abi", ")", "==", "MS_ABI", ")", "nregs", "=", "function_arg_advance_ms_64", "(", "cum", ",", "bytes", ",", "words", ")", ";", "else", "if", "(", "TARGET_64BIT", ")", "nregs", "=", "function_arg_advance_64", "(", "cum", ",", "mode", ",", "type", ",", "words", ",", "named", ")", ";", "else", "nregs", "=", "function_arg_advance_32", "(", "cum", ",", "mode", ",", "type", ",", "bytes", ",", "words", ")", ";", "if", "(", "cum", "->", "stdarg", ")", "cum", "->", "force_bnd_pass", "=", "nregs", ";", "if", "(", "!", "nregs", ")", "cum", "->", "bnds_in_bt", "=", "chkp_type_bounds_count", "(", "type", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

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

[]

[ "<s>", "static", "void", "s390_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "s390_function_arg_float", "(", "mode", ",", "type", ")", ")", "{", "cum", "->", "fprs", "+=", "1", ";", "}", "else", "if", "(", "s390_function_arg_integer", "(", "mode", ",", "type", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "mode", ",", "type", ")", ";", "cum", "->", "gprs", "+=", "(", "(", "size", "+", "UNITS_PER_LONG", "-", "1", ")", "/", "UNITS_PER_LONG", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available.", ")", ".", "The", "boolean", "NAMED", "specifies", "whether", "the", "argument", "is", "a", "named", "argument", "(", "as", "opposed", "to", "an", "unnamed", "argument", "matching", "an", "ellipsis", ")", "." ]

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

[]

[ "<s>", "void", "function_builder", "::", "register_function_group", "(", "const", "function_group_info", "&", "group", ")", "{", "(", "*", "group", ".", "shape", ")", "->", "build", "(", "*", "this", ",", "group", ")", ";", "}", "</s>" ]

[ "Register", "all", "the", "functions", "in", "GROUP", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldOutlineFromFunctionByDefault", "(", "MachineFunction", "&", "MF", ")", "const", "{", "return", "MF", ".", "getFunction", "(", ")", ".", "optForMinSize", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "should", "be", "outlined", "from", "by", "default", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "ia64_expand_load_address", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "dest", ")", "==", "REG", ")", ";", "if", "(", "GET_MODE", "(", "dest", ")", "!=", "Pmode", ")", "dest", "=", "gen_rtx_REG_offset", "(", "dest", ",", "Pmode", ",", "REGNO", "(", "dest", ")", ",", "byte_lowpart_offset", "(", "Pmode", ",", "GET_MODE", "(", "dest", ")", ")", ")", ";", "if", "(", "TARGET_NO_PIC", ")", "return", "false", ";", "if", "(", "small_addr_symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "return", "false", ";", "if", "(", "TARGET_AUTO_PIC", ")", "emit_insn", "(", "gen_load_gprel64", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_FUNCTION_P", "(", "src", ")", ")", "emit_insn", "(", "gen_load_fptr", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "sdata_symbolic_operand", "(", "src", ",", "VOIDmode", ")", ")", "emit_insn", "(", "gen_load_gprel", "(", "dest", ",", "src", ")", ")", ";", "else", "if", "(", "local_symbolic_operand64", "(", "src", ",", "VOIDmode", ")", ")", "{", "emit_insn", "(", "gen_load_gprel64", "(", "dest", ",", "src", ")", ")", ";", "}", "else", "{", "HOST_WIDE_INT", "addend", "=", "0", ";", "rtx", "tmp", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "CONST", ")", "{", "HOST_WIDE_INT", "hi", ",", "lo", ";", "hi", "=", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "1", ")", ")", ";", "lo", "=", "(", "(", "hi", "&", "0x3fff", ")", "^", "0x2000", ")", "-", "0x2000", ";", "hi", "=", "hi", "-", "lo", ";", "if", "(", "lo", "!=", "0", ")", "{", "addend", "=", "lo", ";", "src", "=", "plus_constant", "(", "Pmode", ",", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ",", "hi", ")", ";", "}", "}", "tmp", "=", "gen_rtx_HIGH", "(", "Pmode", ",", "src", ")", ";", "tmp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "tmp", ",", "pic_offset_table_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_LO_SUM", "(", "Pmode", ",", "gen_const_mem", "(", "Pmode", ",", "dest", ")", ",", "src", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "tmp", ")", ")", ";", "if", "(", "addend", ")", "{", "tmp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "dest", ",", "GEN_INT", "(", "addend", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "tmp", ")", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "symbolic", "constant", "load", "." ]

[ "ia64", "0", "0", "1", "0x3fff", "0x2000", "0x2000", "0", "0", "0" ]

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "AArch64" ]

[]

[ "<s>", "bool", "RISCVTargetMachine", "::", "parseMachineFunctionInfo", "(", "const", "yaml", "::", "MachineFunctionInfo", "&", "MFI", ",", "PerFunctionMIParsingState", "&", "PFS", ",", "SMDiagnostic", "&", "Error", ",", "SMRange", "&", "SourceRange", ")", "const", "{", "const", "auto", "&", "YamlMFI", "=", "static_cast", "<", "const", "yaml", "::", "RISCVMachineFunctionInfo", "&", ">", "(", "MFI", ")", ";", "PFS", ".", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", "->", "initializeBaseYamlFields", "(", "YamlMFI", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Parse", "out", "the", "target", "'s", "MachineFunctionInfo", "from", "the", "YAML", "reprsentation", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "static", "bool", "quad_aligned_load_p", "(", "swap_web_entry", "*", "insn_entry", ",", "rtx_insn", "*", "insn", ")", "{", "unsigned", "uid", "=", "INSN_UID", "(", "insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid", "]", ".", "is_swap", "||", "insn_entry", "[", "uid", "]", ".", "is_load", ")", "return", "false", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "use", "=", "DF_INSN_INFO_USES", "(", "insn_info", ")", ";", "struct", "df_link", "*", "def_link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "if", "(", "!", "def_link", "||", "!", "def_link", "->", "ref", "||", "DF_REF_IS_ARTIFICIAL", "(", "def_link", "->", "ref", ")", "||", "def_link", "->", "next", ")", "return", "false", ";", "rtx", "def_insn", "=", "DF_REF_INSN", "(", "def_link", "->", "ref", ")", ";", "unsigned", "uid2", "=", "INSN_UID", "(", "def_insn", ")", ";", "if", "(", "!", "insn_entry", "[", "uid2", "]", ".", "is_load", "||", "!", "insn_entry", "[", "uid2", "]", ".", "is_swap", ")", "return", "false", ";", "rtx", "body", "=", "PATTERN", "(", "def_insn", ")", ";", "if", "(", "GET_CODE", "(", "body", ")", "!=", "SET", "||", "!", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "VEC_SELECT", "||", "pattern_is_rotate64", "(", "body", ")", ")", "||", "!", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", "return", "false", ";", "rtx", "mem", "=", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "rtx", "base_reg", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "return", "(", "(", "REG_P", "(", "base_reg", ")", "||", "rs6000_sum_of_two_registers_p", "(", "base_reg", ")", ")", "&&", "MEM_ALIGN", "(", "mem", ")", ">=", "128", ")", "?", "true", ":", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "INSN", "represents", "a", "swap", "of", "a", "swapped", "load", "from", "memory", "and", "the", "memory", "address", "is", "quad-word", "aligned", "." ]

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

[]

[ "<s>", "void", "RISCVTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDLoc", "DL", "(", "N", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom type legalize this operation!\"", ")", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "assert", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"READCYCLECOUNTER only has custom type legalization on riscv32\"", ")", ";", "SDVTList", "VTs", "=", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MVT", "::", "Other", ")", ";", "SDValue", "RCW", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "READ_CYCLE_WIDE", ",", "DL", ",", "VTs", ",", "N", "->", "getOperand", "(", "0", ")", ")", ";", "Results", ".", "push_back", "(", "RCW", ")", ";", "Results", ".", "push_back", "(", "RCW", ".", "getValue", "(", "1", ")", ")", ";", "Results", ".", "push_back", "(", "RCW", ".", "getValue", "(", "2", ")", ")", ";", "break", ";", "}", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SRL", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "case", "ISD", "::", "UREM", ":", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "if", "(", "N", "->", "getOperand", "(", "0", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", "||", "N", "->", "getOperand", "(", "1", ")", ".", "getOpcode", "(", ")", "==", "ISD", "::", "Constant", ")", "return", ";", "Results", ".", "push_back", "(", "customLegalizeToWOp", "(", "N", ",", "DAG", ")", ")", ";", "break", ";", "case", "ISD", "::", "BITCAST", ":", "{", "assert", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i32", "&&", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasStdExtF", "(", ")", "&&", "\"Unexpected custom legalisation\"", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", ".", "getValueType", "(", ")", "!=", "MVT", "::", "f32", ")", "return", ";", "SDValue", "FPConv", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "FMV_X_ANYEXTW_RV64", ",", "DL", ",", "MVT", "::", "i64", ",", "Op0", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "TRUNCATE", ",", "DL", ",", "MVT", "::", "i32", ",", "FPConv", ")", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "RISCV", "RISCV", "\"Don't know how to custom type legalize this operation!\"", "ISD::READCYCLECOUNTER", "\"READCYCLECOUNTER only has custom type legalization on riscv32\"", "MVT::i32", "MVT::i32", "MVT::Other", "RISCVISD::READ_CYCLE_WIDE", "0", "1", "2", "ISD::SHL", "ISD::SRA", "ISD::SRL", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "1", "ISD::Constant", "ISD::SDIV", "ISD::UDIV", "ISD::UREM", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "ISD::Constant", "1", "ISD::Constant", "ISD::BITCAST", "0", "MVT::i32", "\"Unexpected custom legalisation\"", "0", "MVT::f32", "RISCVISD::FMV_X_ANYEXTW_RV64", "MVT::i64", "ISD::TRUNCATE", "MVT::i32" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "if", "(", "RC", "==", "&", "SP", "::", "I64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDXri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntPairRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "FPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "DFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "if", "(", "SP", "::", "QFPRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDQFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::LDXri", "0", "SP::IntRegsRegClass", "SP::LDri", "0", "SP::IntPairRegClass", "SP::LDDri", "0", "SP::FPRegsRegClass", "SP::LDFri", "0", "SP::DFPRegsRegClass", "SP::LDDFri", "0", "SP::QFPRegsRegClass", "SP::LDQFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreEmitPass2", "(", ")", "{", "addPass", "(", "createARMBranchTargetsPass", "(", ")", ")", ";", "addPass", "(", "createARMConstantIslandPass", "(", ")", ")", ";", "addPass", "(", "createARMLowOverheadLoopsPass", "(", ")", ")", ";", "if", "(", "TM", "->", "getTargetTriple", "(", ")", ".", "isOSWindows", "(", ")", ")", "{", "addPass", "(", "createCFGuardLongjmpPass", "(", ")", ")", ";", "addPass", "(", "createEHContGuardCatchretPass", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Targets", "may", "add", "passes", "immediately", "before", "machine", "code", "is", "emitted", "in", "this", "callback", "." ]

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

[]

[ "<s>", "rtx", "function_expander", "::", "get_nonoverlapping_reg_target", "(", ")", "{", "if", "(", "possible_target", "&&", "overlaps_input_p", "(", "possible_target", ")", ")", "possible_target", "=", "NULL_RTX", ";", "return", "get_reg_target", "(", ")", ";", "}", "</s>" ]

[ "As", "for", "get_reg_target", ",", "but", "make", "sure", "that", "the", "returned", "REG", "does", "not", "overlap", "any", "inputs", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "legitimate_constant_pool_address_p", "(", "const_rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict", ")", "{", "return", "(", "toc_relative_expr_p", "(", "x", ",", "strict", ")", "&&", "(", "TARGET_CMODEL", "!=", "CMODEL_MEDIUM", "||", "constant_pool_expr_p", "(", "XVECEXP", "(", "tocrel_base", ",", "0", ",", "0", ")", ")", "||", "mode", "==", "QImode", "||", "offsettable_ok_by_alignment", "(", "XVECEXP", "(", "tocrel_base", ",", "0", ",", "0", ")", ",", "INTVAL", "(", "tocrel_offset", ")", ",", "mode", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "constant", "pool", "address", ",", "and", "also", "for", "cmodel=medium", "if", "X", "is", "a", "toc-relative", "address", "known", "to", "be", "offsettable", "within", "MODE", "." ]

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

[]

[ "<s>", "static", "void", "csky_function_arg_advance", "(", "cumulative_args_t", "pcum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "pcum", "=", "get_cumulative_args", "(", "pcum_v", ")", ";", "int", "param_size", "=", "csky_num_arg_regs", "(", "mode", ",", "type", ")", ";", "if", "(", "*", "pcum", "+", "param_size", ">", "CSKY_NPARM_REGS", ")", "*", "pcum", "=", "CSKY_NPARM_REGS", ";", "else", "*", "pcum", "+=", "param_size", ";", "}", "</s>" ]

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

[ "csky" ]

[]

[ "<s>", "unsigned", "SparcRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "SP", "::", "I6", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::I6" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "AMDGPU", "::", "SI_INIT_M0", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", "->", "getIterator", "(", ")", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "AMDGPU", "::", "M0", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "GET_GROUPSTATICSIZE", ":", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "MachineFunction", "*", "MF", "=", "BB", "->", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "MI", ",", "DL", ",", "TII", "->", "get", "(", "AMDGPU", "::", "S_MOVK_I32", ")", ")", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "MFI", "->", "LDSSize", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "return", "BB", ";", "}", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "}", "return", "BB", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::SI_INIT_M0", "SI", "SI", "AMDGPU::S_MOV_B32", "AMDGPU::M0", "0", "AMDGPU::BRANCH", "AMDGPU::GET_GROUPSTATICSIZE", "SI", "SI", "SI", "SI", "AMDGPU::S_MOVK_I32", "0", "AMDGPU" ]

[]

[ "<s>", "static", "bool", "split_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "maybe_split_mode", "(", "mode", ")", "!=", "VOIDmode", ";", "}", "</s>" ]

[ "Return", "true", "if", "mode", "should", "be", "treated", "as", "two", "registers", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "bool", "or1k_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "return", "true", ";", "HOST_WIDE_INT", "size", "=", "arg", ".", "type_size_in_bytes", "(", ")", ";", "return", "size", "<", "0", "||", "size", ">", "8", ";", "}", "</s>" ]

[ "Worker", "for", "TARGET_PASS_BY_REFERENCE", ".", "Returns", "true", "if", "an", "argument", "of", "TYPE", "in", "MODE", "should", "be", "passed", "by", "reference", "as", "required", "by", "the", "OpenRISC", "ABI", ".", "On", "OpenRISC", "structures", ",", "unions", "and", "arguments", "larger", "than", "64-bits", "are", "passed", "by", "reference", "." ]

[ "or1k", "0", "8" ]

[]

[ "<s>", "const", "char", "*", "mips16e_output_save_restore", "(", "rtx", "pattern", ",", "HOST_WIDE_INT", "adjust", ")", "{", "static", "char", "buffer", "[", "300", "]", ";", "struct", "mips16e_save_restore_info", "info", ";", "unsigned", "int", "i", ",", "end", ";", "char", "*", "s", ";", "if", "(", "!", "mips16e_save_restore_pattern_p", "(", "pattern", ",", "adjust", ",", "&", "info", ")", ")", "gcc_unreachable", "(", ")", ";", "s", "=", "strcpy", "(", "buffer", ",", "adjust", ">", "0", "?", "\"restore\\t\"", ":", "\"save\\t\"", ")", ";", "s", "+=", "strlen", "(", "s", ")", ";", "if", "(", "info", ".", "nargs", ">", "1", ")", "s", "+=", "sprintf", "(", "s", ",", "\"%s-%s,\"", ",", "reg_names", "[", "GP_ARG_FIRST", "]", ",", "reg_names", "[", "GP_ARG_FIRST", "+", "info", ".", "nargs", "-", "1", "]", ")", ";", "else", "if", "(", "info", ".", "nargs", "==", "1", ")", "s", "+=", "sprintf", "(", "s", ",", "\"%s,\"", ",", "reg_names", "[", "GP_ARG_FIRST", "]", ")", ";", "s", "+=", "sprintf", "(", "s", ",", "\"%d\"", ",", "(", "int", ")", "info", ".", "size", ")", ";", "if", "(", "BITSET_P", "(", "info", ".", "mask", ",", "16", ")", ")", "s", "+=", "sprintf", "(", "s", ",", "\",%s\"", ",", "reg_names", "[", "GP_REG_FIRST", "+", "16", "]", ")", ";", "if", "(", "BITSET_P", "(", "info", ".", "mask", ",", "17", ")", ")", "s", "+=", "sprintf", "(", "s", ",", "\",%s\"", ",", "reg_names", "[", "GP_REG_FIRST", "+", "17", "]", ")", ";", "end", "=", "ARRAY_SIZE", "(", "mips16e_s2_s8_regs", ")", ";", "i", "=", "mips16e_find_first_register", "(", "info", ".", "mask", ",", "mips16e_s2_s8_regs", ",", "end", ")", ";", "if", "(", "i", "<", "end", ")", "s", "=", "mips16e_add_register_range", "(", "s", ",", "mips16e_s2_s8_regs", "[", "end", "-", "1", "]", ",", "mips16e_s2_s8_regs", "[", "i", "]", ")", ";", "end", "=", "ARRAY_SIZE", "(", "mips16e_a0_a3_regs", ")", ";", "i", "=", "mips16e_find_first_register", "(", "info", ".", "mask", ",", "mips16e_a0_a3_regs", ",", "end", ")", ";", "if", "(", "i", "<", "end", ")", "s", "=", "mips16e_add_register_range", "(", "s", ",", "mips16e_a0_a3_regs", "[", "i", "]", ",", "mips16e_a0_a3_regs", "[", "end", "-", "1", "]", ")", ";", "if", "(", "BITSET_P", "(", "info", ".", "mask", ",", "RETURN_ADDR_REGNUM", ")", ")", "s", "+=", "sprintf", "(", "s", ",", "\",%s\"", ",", "reg_names", "[", "RETURN_ADDR_REGNUM", "]", ")", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "the", "assembly", "instruction", "for", "a", "MIPS16e", "SAVE", "or", "RESTORE", "instruction", ".", "PATTERN", "and", "ADJUST", "are", "as", "for", "mips16e_save_restore_pattern_p", "." ]

[ "mips", "300", "0", "\"restore\\t\"", "\"save\\t\"", "1", "\"%s-%s,\"", "1", "1", "\"%s,\"", "\"%d\"", "16", "\",%s\"", "16", "17", "\",%s\"", "17", "1", "1", "\",%s\"" ]

[]

[ "<s>", "const", "MCPhysReg", "*", "X86RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX512", "(", ")", ";", "assert", "(", "MF", "&&", "\"MachineFunction required\"", ")", ";", "switch", "(", "MF", "->", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_SaveList", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_SaveList", ";", "return", "CSR_64_AllRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_SaveList", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_SaveList", ";", "return", "CSR_64_RT_AllRegs_SaveList", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_SaveList", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_SaveList", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_SaveList", ";", "break", ";", "}", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_SaveList", ";", "break", ";", "default", ":", "break", ";", "}", "bool", "CallsEHReturn", "=", "MF", "->", "getMMI", "(", ")", ".", "callsEHReturn", "(", ")", ";", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_SaveList", ";", "if", "(", "CallsEHReturn", ")", "return", "CSR_64EHRet_SaveList", ";", "return", "CSR_64_SaveList", ";", "}", "if", "(", "CallsEHReturn", ")", "return", "CSR_32EHRet_SaveList", ";", "return", "CSR_32_SaveList", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"MachineFunction required\"" ]

[]

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

[ "Get", "ma", "according", "to", "operand", "[", "mask_op_idx", "]", "." ]

[ "riscv" ]

[]

[ "<s>", "bool", "MSP430FrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "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", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "const", "RegisterBank", "&", "M68kRegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ",", "LLT", ")", "const", "{", "return", "getRegBank", "(", "M68k", "::", "GPRRegBankID", ")", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k::GPRRegBankID" ]

[]

[ "<s>", "InstructionCost", "GCNTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsUnsigned", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getHalfRateInstrCost", "(", "CostKind", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "unsigned", "int", "getNumFixupKinds", "(", ")", "const", "{", "return", "AArch64", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "AArch64", "AArch64::NumTargetFixupKinds" ]

[]

[ "<s>", "rtx", "tilepro_simd_int", "(", "rtx", "num", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "n", "=", "0", ";", "gcc_assert", "(", "CONST_INT_P", "(", "num", ")", ")", ";", "n", "=", "INTVAL", "(", "num", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "n", "=", "0x01010101", "*", "(", "n", "&", "0x000000FF", ")", ";", "break", ";", "case", "E_HImode", ":", "n", "=", "0x00010001", "*", "(", "n", "&", "0x0000FFFF", ")", ";", "break", ";", "case", "E_SImode", ":", "break", ";", "case", "E_DImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "gen_int_si", "(", "n", ")", ";", "}", "</s>" ]

[ "Return", "the", "simd", "variant", "of", "the", "constant", "NUM", "of", "mode", "MODE", ",", "by", "replicating", "it", "to", "fill", "an", "interger", "of", "mode", "SImode", ".", "NUM", "is", "first", "truncated", "to", "fit", "in", "MODE", "." ]

[ "tilepro", "0", "0x01010101", "0x000000FF", "0x00010001", "0x0000FFFF" ]

[]

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

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

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

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Patmos Stack Cache Analysis\"", ";", "}", "</s>" ]

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

[ "Patmos", "\"Patmos Stack Cache Analysis\"" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Argument Move\"", ";", "}", "</s>" ]

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

[ "WebAssembly", "\"WebAssembly Argument Move\"" ]

[]

[ "<s>", "static", "void", "frv_ifcvt_add_insn", "(", "rtx", "pattern", ",", "rtx", "insn", ",", "int", "before_p", ")", "{", "rtx", "link", "=", "alloc_EXPR_LIST", "(", "VOIDmode", ",", "pattern", ",", "insn", ")", ";", "link", "->", "jump", "=", "before_p", ";", "frv_ifcvt", ".", "added_insns_list", "=", "alloc_EXPR_LIST", "(", "VOIDmode", ",", "link", ",", "frv_ifcvt", ".", "added_insns_list", ")", ";", "if", "(", "TARGET_DEBUG_COND_EXEC", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n:::::::::: frv_ifcvt_add_insn: add the following %s insn %d:\\n\"", ",", "(", "before_p", ")", "?", "\"before\"", ":", "\"after\"", ",", "(", "int", ")", "INSN_UID", "(", "insn", ")", ")", ";", "debug_rtx", "(", "pattern", ")", ";", "}", "}", "</s>" ]

[ "Internal", "function", "to", "add", "a", "potential", "insn", "to", "the", "list", "of", "insns", "to", "be", "inserted", "if", "the", "conditional", "execution", "conversion", "is", "successful", "." ]

[ "frv", "\"\\n:::::::::: frv_ifcvt_add_insn: add the following %s insn %d:\\n\"", "\"before\"", "\"after\"" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getNumRegistersForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "unsigned", "NumElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "RegisterVT", ";", "unsigned", "NumRegisters", ";", "std", "::", "tie", "(", "RegisterVT", ",", "NumRegisters", ")", "=", "handleMaskRegisterForCallingConv", "(", "NumElts", ",", "CC", ",", "Subtarget", ")", ";", "if", "(", "RegisterVT", "!=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ")", "return", "NumRegisters", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v3f16", "&&", "Subtarget", ".", "hasFP16", "(", ")", ")", "return", "1", ";", "return", "TargetLowering", "::", "getNumRegistersForCallingConv", "(", "Context", ",", "CC", ",", "VT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "require", "unusual", "breakdowns", "of", "certain", "types", "." ]

[ "X86", "X86", "MVT::i1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::v3f16", "1" ]

[]

[ "<s>", "enum", "rtx_code", "xtensa_shlrd_which_direction", "(", "rtx", "op0", ",", "rtx", "op1", ")", "{", "if", "(", "GET_CODE", "(", "op0", ")", "==", "ASHIFT", "&&", "GET_CODE", "(", "op1", ")", "==", "LSHIFTRT", ")", "return", "ASHIFT", ";", "if", "(", "GET_CODE", "(", "op0", ")", "==", "LSHIFTRT", "&&", "GET_CODE", "(", "op1", ")", "==", "ASHIFT", ")", "return", "LSHIFTRT", ";", "return", "UNKNOWN", ";", "}", "</s>" ]

[ "Helper", "function", "for", "``", "*", "shlrd_", "...", "''", "patterns", "." ]

[ "xtensa" ]

[]

[ "<s>", "bool", "WebAssemblySetP2AlignOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"********** Set p2align Operands **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "}", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "LOAD_I32", ":", "case", "WebAssembly", "::", "LOAD_I64", ":", "case", "WebAssembly", "::", "LOAD_F32", ":", "case", "WebAssembly", "::", "LOAD_F64", ":", "case", "WebAssembly", "::", "LOAD8_S_I32", ":", "case", "WebAssembly", "::", "LOAD8_U_I32", ":", "case", "WebAssembly", "::", "LOAD16_S_I32", ":", "case", "WebAssembly", "::", "LOAD16_U_I32", ":", "case", "WebAssembly", "::", "LOAD8_S_I64", ":", "case", "WebAssembly", "::", "LOAD8_U_I64", ":", "case", "WebAssembly", "::", "LOAD16_S_I64", ":", "case", "WebAssembly", "::", "LOAD16_U_I64", ":", "case", "WebAssembly", "::", "LOAD32_S_I64", ":", "case", "WebAssembly", "::", "LOAD32_U_I64", ":", "case", "WebAssembly", "::", "STORE_I32", ":", "case", "WebAssembly", "::", "STORE_I64", ":", "case", "WebAssembly", "::", "STORE_F32", ":", "case", "WebAssembly", "::", "STORE_F64", ":", "case", "WebAssembly", "::", "STORE8_I32", ":", "case", "WebAssembly", "::", "STORE16_I32", ":", "case", "WebAssembly", "::", "STORE8_I64", ":", "case", "WebAssembly", "::", "STORE16_I64", ":", "case", "WebAssembly", "::", "STORE32_I64", ":", "{", "assert", "(", "MI", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", "&&", "\"ISel should set p2align operands to 0\"", ")", ";", "assert", "(", "MI", ".", "hasOneMemOperand", "(", ")", "&&", "\"Load and store instructions have exactly one mem operand\"", ")", ";", "assert", "(", "(", "*", "MI", ".", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", "==", "(", "UINT64_C", "(", "1", ")", "<<", "WebAssembly", "::", "GetDefaultP2Align", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "&&", "\"Default p2align value should be natural\"", ")", ";", "assert", "(", "MI", ".", "getDesc", "(", ")", ".", "OpInfo", "[", "3", "]", ".", "OperandType", "==", "WebAssembly", "::", "OPERAND_P2ALIGN", "&&", "\"Load and store instructions should have a p2align operand\"", ")", ";", "uint64_t", "P2Align", "=", "Log2_64", "(", "(", "*", "MI", ".", "memoperands_begin", "(", ")", ")", "->", "getAlignment", "(", ")", ")", ";", "P2Align", "=", "std", "::", "min", "(", "P2Align", ",", "uint64_t", "(", "WebAssembly", "::", "GetDefaultP2Align", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", ")", ";", "MI", ".", "getOperand", "(", "3", ")", ".", "setImm", "(", "P2Align", ")", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** Set p2align Operands **********\\n\"", "\"********** Function: \"", "WebAssembly::LOAD_I32", "WebAssembly::LOAD_I64", "WebAssembly::LOAD_F32", "WebAssembly::LOAD_F64", "WebAssembly::LOAD8_S_I32", "WebAssembly::LOAD8_U_I32", "WebAssembly::LOAD16_S_I32", "WebAssembly::LOAD16_U_I32", "WebAssembly::LOAD8_S_I64", "WebAssembly::LOAD8_U_I64", "WebAssembly::LOAD16_S_I64", "WebAssembly::LOAD16_U_I64", "WebAssembly::LOAD32_S_I64", "WebAssembly::LOAD32_U_I64", "WebAssembly::STORE_I32", "WebAssembly::STORE_I64", "WebAssembly::STORE_F32", "WebAssembly::STORE_F64", "WebAssembly::STORE8_I32", "WebAssembly::STORE16_I32", "WebAssembly::STORE8_I64", "WebAssembly::STORE16_I64", "WebAssembly::STORE32_I64", "3", "0", "\"ISel should set p2align operands to 0\"", "\"Load and store instructions have exactly one mem operand\"", "1", "WebAssembly::GetDefaultP2Align", "\"Default p2align value should be natural\"", "3", "WebAssembly::OPERAND_P2ALIGN", "\"Load and store instructions should have a p2align operand\"", "WebAssembly::GetDefaultP2Align", "3" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "HexagonTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'q'", ":", "case", "'v'", ":", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "return", "C_Register", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "floating_exact_log2", "(", "rtx", "x", ")", "{", "REAL_VALUE_TYPE", "r", ",", "r1", ";", "int", "exp", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "r", ",", "x", ")", ";", "if", "(", "REAL_VALUES_LESS", "(", "r", ",", "dconst1", ")", ")", "return", "0", ";", "exp", "=", "real_exponent", "(", "&", "r", ")", ";", "real_2expN", "(", "&", "r1", ",", "exp", ",", "DFmode", ")", ";", "if", "(", "REAL_VALUES_EQUAL", "(", "r1", ",", "r", ")", ")", "return", "exp", ";", "return", "0", ";", "}", "</s>" ]

[ "If", "X", "is", "a", "floating-point", "constant", ",", "return", "the", "logarithm", "of", "X", "base", "2", ",", "or", "0", "if", "X", "is", "not", "a", "power", "of", "2", "." ]

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

[]

[ "<s>", "void", "BT", "::", "run", "(", ")", "{", "reset", "(", ")", ";", "assert", "(", "FlowQ", ".", "empty", "(", ")", ")", ";", "typedef", "GraphTraits", "<", "const", "MachineFunction", "*", ">", "MachineFlowGraphTraits", ";", "const", "MachineBasicBlock", "*", "Entry", "=", "MachineFlowGraphTraits", "::", "getEntryNode", "(", "&", "MF", ")", ";", "unsigned", "MaxBN", "=", "0", ";", "for", "(", "MachineFunction", "::", "const_iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "assert", "(", "I", "->", "getNumber", "(", ")", ">=", "0", "&&", "\"Disconnected block\"", ")", ";", "unsigned", "BN", "=", "I", "->", "getNumber", "(", ")", ";", "if", "(", "BN", ">", "MaxBN", ")", "MaxBN", "=", "BN", ";", "}", "BitVector", "BlockScanned", "(", "MaxBN", "+", "1", ")", ";", "int", "EntryN", "=", "Entry", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "-", "1", ",", "EntryN", ")", ")", ";", "while", "(", "!", "FlowQ", ".", "empty", "(", ")", ")", "{", "CFGEdge", "Edge", "=", "FlowQ", ".", "front", "(", ")", ";", "FlowQ", ".", "pop", "(", ")", ";", "if", "(", "EdgeExec", ".", "count", "(", "Edge", ")", ")", "continue", ";", "EdgeExec", ".", "insert", "(", "Edge", ")", ";", "const", "MachineBasicBlock", "&", "B", "=", "*", "MF", ".", "getBlockNumbered", "(", "Edge", ".", "second", ")", ";", "MachineBasicBlock", "::", "const_iterator", "It", "=", "B", ".", "begin", "(", ")", ",", "End", "=", "B", ".", "end", "(", ")", ";", "while", "(", "It", "!=", "End", "&&", "It", "->", "isPHI", "(", ")", ")", "{", "const", "MachineInstr", "&", "PI", "=", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "&", "PI", ")", ";", "visitPHI", "(", "PI", ")", ";", "}", "if", "(", "BlockScanned", "[", "Edge", ".", "second", "]", ")", "continue", ";", "BlockScanned", "[", "Edge", ".", "second", "]", "=", "true", ";", "while", "(", "It", "!=", "End", "&&", "!", "It", "->", "isBranch", "(", ")", ")", "{", "const", "MachineInstr", "&", "MI", "=", "*", "It", "++", ";", "InstrExec", ".", "insert", "(", "&", "MI", ")", ";", "visitNonBranch", "(", "MI", ")", ";", "}", "if", "(", "It", "==", "End", ")", "{", "MachineFunction", "::", "const_iterator", "BIt", "=", "B", ".", "getIterator", "(", ")", ";", "MachineFunction", "::", "const_iterator", "Next", "=", "std", "::", "next", "(", "BIt", ")", ";", "if", "(", "Next", "!=", "MF", ".", "end", "(", ")", "&&", "B", ".", "isSuccessor", "(", "&", "*", "Next", ")", ")", "{", "int", "ThisN", "=", "B", ".", "getNumber", "(", ")", ";", "int", "NextN", "=", "Next", "->", "getNumber", "(", ")", ";", "FlowQ", ".", "push", "(", "CFGEdge", "(", "ThisN", ",", "NextN", ")", ")", ";", "}", "}", "else", "{", "visitBranchesFrom", "(", "*", "It", ")", ";", "}", "}", "if", "(", "Trace", ")", "{", "dbgs", "(", ")", "<<", "\"Cells after propagation:\\n\"", ";", "for", "(", "CellMapType", "::", "iterator", "I", "=", "Map", ".", "begin", "(", ")", ",", "E", "=", "Map", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "dbgs", "(", ")", "<<", "PrintReg", "(", "I", "->", "first", ",", "&", "ME", ".", "TRI", ")", "<<", "\" -> \"", "<<", "I", "->", "second", "<<", "\"\\n\"", ";", "}", "}", "</s>" ]

[ "Run", "the", "analysis", "pass", "over", "a", "function", "and", "produce", "a", "dominator", "tree", "." ]

[ "Hexagon", "0", "0", "\"Disconnected block\"", "1", "1", "\"Cells after propagation:\\n\"", "\" -> \"", "\"\\n\"" ]

[]

[ "<s>", "static", "void", "loongarch_print_operand_address", "(", "FILE", "*", "file", ",", "machine_mode", ",", "rtx", "x", ")", "{", "struct", "loongarch_address_info", "addr", ";", "if", "(", "loongarch_classify_address", "(", "&", "addr", ",", "x", ",", "word_mode", ",", "true", ")", ")", "switch", "(", "addr", ".", "type", ")", "{", "case", "ADDRESS_REG", ":", "fprintf", "(", "file", ",", "\"%s,\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "loongarch_print_operand", "(", "file", ",", "addr", ".", "offset", ",", "0", ")", ";", "return", ";", "case", "ADDRESS_REG_REG", ":", "fprintf", "(", "file", ",", "\"%s,%s\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "offset", ")", "]", ")", ";", "return", ";", "case", "ADDRESS_LO_SUM", ":", "fprintf", "(", "file", ",", "\"%s,\"", ",", "reg_names", "[", "REGNO", "(", "addr", ".", "reg", ")", "]", ")", ";", "loongarch_print_operand_reloc", "(", "file", ",", "addr", ".", "offset", ",", "false", ",", "false", ")", ";", "return", ";", "case", "ADDRESS_CONST_INT", ":", "fprintf", "(", "file", ",", "\"%s,\"", ",", "reg_names", "[", "GP_REG_FIRST", "]", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "return", ";", "case", "ADDRESS_SYMBOLIC", ":", "output_addr_const", "(", "file", ",", "loongarch_strip_unspec_address", "(", "x", ")", ")", ";", "return", ";", "}", "if", "(", "CONST_INT_P", "(", "x", ")", ")", "output_addr_const", "(", "file", ",", "x", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_PRINT_OPERAND_ADDRESS", "." ]

[ "loongarch", "\"%s,\"", "0", "\"%s,%s\"", "\"%s,\"", "\"%s,\"" ]

[]

[ "<s>", "static", "rtx", "mmix_struct_value_rtx", "(", "tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "incoming", "ATTRIBUTE_UNUSED", ")", "{", "return", "gen_rtx_REG", "(", "Pmode", ",", "MMIX_STRUCT_VALUE_REGNUM", ")", ";", "}", "</s>" ]

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

[ "mmix" ]

[]

[ "<s>", "static", "bool", "sh_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fndecl", ")", "{", "return", "TYPE_MODE", "(", "type", ")", "==", "BLKmode", "||", "(", "(", "TARGET_HITACHI", "||", "sh_attr_renesas_p", "(", "fndecl", ")", ")", "&&", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", ";", "}", "</s>" ]

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

[ "sh" ]

[]

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

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

[ "AAP" ]

[]

[ "<s>", "const", "char", "*", "AVRTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "case", "AVRISD", "::", "name", ":", "\\", "return", "#", "name", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "nullptr", ";", "NODE", "(", "RET_FLAG", ")", ";", "NODE", "(", "RETI_FLAG", ")", ";", "NODE", "(", "CALL", ")", ";", "NODE", "(", "WRAPPER", ")", ";", "NODE", "(", "LSL", ")", ";", "NODE", "(", "LSR", ")", ";", "NODE", "(", "ROL", ")", ";", "NODE", "(", "ROR", ")", ";", "NODE", "(", "ASR", ")", ";", "NODE", "(", "LSLLOOP", ")", ";", "NODE", "(", "LSRLOOP", ")", ";", "NODE", "(", "ROLLOOP", ")", ";", "NODE", "(", "RORLOOP", ")", ";", "NODE", "(", "ASRLOOP", ")", ";", "NODE", "(", "BRCOND", ")", ";", "NODE", "(", "CMP", ")", ";", "NODE", "(", "CMPC", ")", ";", "NODE", "(", "TST", ")", ";", "NODE", "(", "SELECT_CC", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVRISD::name" ]

[]

[ "<s>", "const", "RegisterBankInfo", "::", "InstructionMapping", "&", "X86RegisterBankInfo", "::", "getInstrMapping", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "isPreISelGenericOpcode", "(", "Opc", ")", "||", "Opc", "==", "TargetOpcode", "::", "G_PHI", ")", "{", "const", "InstructionMapping", "&", "Mapping", "=", "getInstrMappingImpl", "(", "MI", ")", ";", "if", "(", "Mapping", ".", "isValid", "(", ")", ")", "return", "Mapping", ";", "}", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_ADD", ":", "case", "TargetOpcode", "::", "G_SUB", ":", "case", "TargetOpcode", "::", "G_MUL", ":", "case", "TargetOpcode", "::", "G_SHL", ":", "case", "TargetOpcode", "::", "G_LSHR", ":", "case", "TargetOpcode", "::", "G_ASHR", ":", "return", "getSameOperandsMapping", "(", "MI", ",", "false", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_FADD", ":", "case", "TargetOpcode", "::", "G_FSUB", ":", "case", "TargetOpcode", "::", "G_FMUL", ":", "case", "TargetOpcode", "::", "G_FDIV", ":", "return", "getSameOperandsMapping", "(", "MI", ",", "true", ")", ";", "break", ";", "default", ":", "break", ";", "}", "unsigned", "NumOperands", "=", "MI", ".", "getNumOperands", "(", ")", ";", "SmallVector", "<", "PartialMappingIdx", ",", "4", ">", "OpRegBankIdx", "(", "NumOperands", ")", ";", "switch", "(", "Opc", ")", "{", "case", "TargetOpcode", "::", "G_FPEXT", ":", "case", "TargetOpcode", "::", "G_FCONSTANT", ":", "getInstrPartialMappingIdxs", "(", "MI", ",", "MRI", ",", "true", ",", "OpRegBankIdx", ")", ";", "break", ";", "case", "TargetOpcode", "::", "G_TRUNC", ":", "case", "TargetOpcode", "::", "G_ANYEXT", ":", "{", "auto", "&", "Op0", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "auto", "&", "Op1", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "const", "LLT", "Ty0", "=", "MRI", ".", "getType", "(", "Op0", ".", "getReg", "(", ")", ")", ";", "const", "LLT", "Ty1", "=", "MRI", ".", "getType", "(", "Op1", ".", "getReg", "(", ")", ")", ";", "bool", "isFPTrunc", "=", "(", "Ty0", ".", "getSizeInBits", "(", ")", "==", "32", "||", "Ty0", ".", "getSizeInBits", "(", ")", "==", "64", ")", "&&", "Ty1", ".", "getSizeInBits", "(", ")", "==", "128", "&&", "Opc", "==", "TargetOpcode", "::", "G_TRUNC", ";", "bool", "isFPAnyExt", "=", "Ty0", ".", "getSizeInBits", "(", ")", "==", "128", "&&", "(", "Ty1", ".", "getSizeInBits", "(", ")", "==", "32", "||", "Ty1", ".", "getSizeInBits", "(", ")", "==", "64", ")", "&&", "Opc", "==", "TargetOpcode", "::", "G_ANYEXT", ";", "getInstrPartialMappingIdxs", "(", "MI", ",", "MRI", ",", "isFPTrunc", "||", "isFPAnyExt", ",", "OpRegBankIdx", ")", ";", "}", "break", ";", "default", ":", "getInstrPartialMappingIdxs", "(", "MI", ",", "MRI", ",", "false", ",", "OpRegBankIdx", ")", ";", "break", ";", "}", "SmallVector", "<", "const", "ValueMapping", "*", ",", "8", ">", "OpdsMapping", "(", "NumOperands", ")", ";", "if", "(", "!", "getInstrValueMapping", "(", "MI", ",", "OpRegBankIdx", ",", "OpdsMapping", ")", ")", "return", "getInvalidInstructionMapping", "(", ")", ";", "return", "getInstructionMapping", "(", "DefaultMappingID", ",", "1", ",", "getOperandsMapping", "(", "OpdsMapping", ")", ",", "NumOperands", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "4", "0", "1", "32", "64", "128", "128", "32", "64", "8", "1" ]

[]

[ "<s>", "bool", "TGSITTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "{", "if", "(", "const", "Argument", "*", "Arg", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "isKernelFunction", "(", "Arg", "->", "getParent", "(", ")", ")", ";", "if", "(", "const", "Instruction", "*", "I", "=", "dyn_cast", "<", "Instruction", ">", "(", "V", ")", ")", "{", "if", "(", "const", "LoadInst", "*", "LI", "=", "dyn_cast", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "unsigned", "AS", "=", "LI", "->", "getPointerAddressSpace", "(", ")", ";", "return", "AS", "==", "tgsi", "::", "PRIVATE", "||", "AS", "==", "tgsi", "::", "LOCAL", ";", "}", "if", "(", "I", "->", "isAtomic", "(", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "I", ")", ")", "{", "switch", "(", "II", "->", "getIntrinsicID", "(", ")", ")", "{", "case", "Intrinsic", "::", "tgsi_read_blockid_x", ":", "case", "Intrinsic", "::", "tgsi_read_blockid_y", ":", "case", "Intrinsic", "::", "tgsi_read_blockid_z", ":", "case", "Intrinsic", "::", "tgsi_read_threadid_x", ":", "case", "Intrinsic", "::", "tgsi_read_threadid_y", ":", "case", "Intrinsic", "::", "tgsi_read_threadid_z", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "if", "(", "isa", "<", "CallInst", ">", "(", "V", ")", "||", "isa", "<", "InvokeInst", ">", "(", "V", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "V", "is", "a", "source", "of", "divergence", "." ]

[ "TGSI", "TGSI", "tgsi::PRIVATE", "tgsi::LOCAL", "Intrinsic::tgsi_read_blockid_x", "Intrinsic::tgsi_read_blockid_y", "Intrinsic::tgsi_read_blockid_z", "Intrinsic::tgsi_read_threadid_x", "Intrinsic::tgsi_read_threadid_y", "Intrinsic::tgsi_read_threadid_z" ]

[]

[ "<s>", "StackOffset", "NVPTXFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "FrameReg", "=", "NVPTX", "::", "VRDepot", ";", "return", "StackOffset", "::", "getFixed", "(", "MFI", ".", "getObjectOffset", "(", "FI", ")", "-", "getOffsetOfLocalArea", "(", ")", ")", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "NVPTX::VRDepot" ]

[]

[ "<s>", "static", "int", "cbranch_predicted_taken_p", "(", "rtx", "insn", ")", "{", "rtx", "x", "=", "find_reg_note", "(", "insn", ",", "REG_BR_PROB", ",", "0", ")", ";", "if", "(", "x", ")", "{", "return", "profile_probability", "::", "from_reg_br_prob_note", "(", "XINT", "(", "x", ",", "0", ")", ")", ">=", "profile_probability", "::", "even", "(", ")", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "INSN", "is", "annotated", "with", "a", "REG_BR_PROB", "note", "that", "indicates", "it", "'s", "a", "branch", "that", "'s", "predicted", "taken", "." ]

[ "bfin", "0", "0", "0" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "void", "pass_vsetvl", "::", "lazy_vsetvl", "(", "void", ")", "{", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nEntering Lazy VSETVL PASS and Handling %d basic blocks for \"", "\"function:%s\\n\"", ",", "n_basic_blocks_for_fn", "(", "cfun", ")", ",", "function_name", "(", "cfun", ")", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nPhase 1: Compute local backward vector infos\\n\"", ")", ";", "for", "(", "const", "bb_info", "*", "bb", ":", "crtl", "->", "ssa", "->", "bbs", "(", ")", ")", "compute_local_backward_infos", "(", "bb", ")", ";", "if", "(", "dump_file", ")", "m_vector_manager", "->", "dump", "(", "dump_file", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nPhase 2: Emit vsetvl instruction within each block\\n\"", ")", ";", "for", "(", "const", "bb_info", "*", "bb", ":", "crtl", "->", "ssa", "->", "bbs", "(", ")", ")", "emit_local_forward_vsetvls", "(", "bb", ")", ";", "if", "(", "dump_file", ")", "m_vector_manager", "->", "dump", "(", "dump_file", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nPhase 3: Demands propagation across blocks\\n\"", ")", ";", "demand_fusion", "(", ")", ";", "if", "(", "dump_file", ")", "m_vector_manager", "->", "dump", "(", "dump_file", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nPhase 4: PRE vsetvl by Lazy code motion (LCM)\\n\"", ")", ";", "pre_vsetvl", "(", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nPhase 5: Cleanup AVL and VL operands\\n\"", ")", ";", "cleanup_insns", "(", ")", ";", "if", "(", "dump_file", ")", "fprintf", "(", "dump_file", ",", "\"\\nPhase 6: Rebuild RTL_SSA to propagate AVL between vsetvls\\n\"", ")", ";", "propagate_avl", "(", ")", ";", "}", "</s>" ]

[ "Lazy", "vsetvl", "insertion", "for", "optimize", ">", "0", "." ]

[ "riscv", "\"\\nEntering Lazy VSETVL PASS and Handling %d basic blocks for \"", "\"function:%s\\n\"", "\"\\nPhase 1: Compute local backward vector infos\\n\"", "\"\\nPhase 2: Emit vsetvl instruction within each block\\n\"", "\"\\nPhase 3: Demands propagation across blocks\\n\"", "\"\\nPhase 4: PRE vsetvl by Lazy code motion (LCM)\\n\"", "\"\\nPhase 5: Cleanup AVL and VL operands\\n\"", "\"\\nPhase 6: Rebuild RTL_SSA to propagate AVL between vsetvls\\n\"" ]

[]

[ "<s>", "static", "rtx", "find_addr_reg", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "0", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "XEXP", "(", "addr", ",", "1", ")", ")", "==", "REG", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "else", "if", "(", "CONSTANT_P", "(", "XEXP", "(", "addr", ",", "1", ")", ")", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "gcc_assert", "(", "GET_CODE", "(", "addr", ")", "==", "REG", ")", ";", "return", "addr", ";", "}", "</s>" ]

[ "Return", "a", "REG", "that", "occurs", "in", "ADDR", "with", "coefficient", "1", ".", "ADDR", "can", "be", "effectively", "incremented", "by", "incrementing", "REG", ".", "r0", "is", "special", "and", "we", "must", "not", "select", "it", "as", "an", "address", "register", "by", "this", "routine", "since", "our", "caller", "will", "try", "to", "increment", "the", "returned", "register", "via", "an", "``", "la", "''", "instruction", "." ]

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

[]

[ "<s>", "static", "bool", "have_compare_and_set_mask", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_SFmode", ":", "case", "E_DFmode", ":", "return", "TARGET_P9_MINMAX", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "function", "to", "return", "true", "if", "the", "target", "has", "instructions", "to", "do", "a", "compare", "and", "set", "mask", "instruction", "that", "can", "be", "used", "with", "XXSEL", "to", "implement", "a", "conditional", "move", ".", "It", "is", "also", "assumed", "that", "such", "a", "target", "also", "supports", "the", "``", "C", "''", "minimum", "and", "maximum", "instructions", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "bool", "aarch64_legitimate_address_hook_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "strict_p", ")", "{", "struct", "aarch64_address_info", "addr", ";", "return", "aarch64_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "MEM", ",", "strict_p", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "X", "is", "a", "legitimate", "address", "for", "accessing", "memory", "in", "mode", "MODE", "." ]

[ "aarch64" ]

[]