Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "void", "R600InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "VectorComponents", "=", "0", ";", "if", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "&&", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "VectorComponents", "=", "4", ";", "}", "else", "if", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "DestReg", ")", "&&", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "SrcReg", ")", ")", "{", "VectorComponents", "=", "2", ";", "}", "if", "(", "VectorComponents", ">", "0", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "VectorComponents", ";", "I", "++", ")", "{", "unsigned", "SubRegIndex", "=", "RI", ".", "getSubRegFromChannel", "(", "I", ")", ";", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubRegIndex", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SubRegIndex", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "}", "}", "else", "{", "MachineInstr", "*", "NewMI", "=", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "DestReg", ",", "SrcReg", ")", ";", "NewMI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "NewMI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ".", "setIsKill", "(", "KillSrc", ")", ";", "}", "}", "</s>" ]

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

[ "R600", "0", "4", "2", "0", "0" ]

[]

[ "<s>", "bool", "MSP430TargetMachine", "::", "addPreEmitPass", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "PM", ".", "add", "(", "createMSP430BranchSelectionPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "ix86_builtin_mpx_function", "(", "unsigned", "fcode", ")", "{", "switch", "(", "fcode", ")", "{", "case", "BUILT_IN_CHKP_BNDMK", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDMK", "]", ";", "case", "BUILT_IN_CHKP_BNDSTX", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDSTX", "]", ";", "case", "BUILT_IN_CHKP_BNDLDX", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDLDX", "]", ";", "case", "BUILT_IN_CHKP_BNDCL", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDCL", "]", ";", "case", "BUILT_IN_CHKP_BNDCU", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDCU", "]", ";", "case", "BUILT_IN_CHKP_BNDRET", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDRET", "]", ";", "case", "BUILT_IN_CHKP_INTERSECT", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDINT", "]", ";", "case", "BUILT_IN_CHKP_NARROW", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDNARROW", "]", ";", "case", "BUILT_IN_CHKP_SIZEOF", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_SIZEOF", "]", ";", "case", "BUILT_IN_CHKP_EXTRACT_LOWER", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDLOWER", "]", ";", "case", "BUILT_IN_CHKP_EXTRACT_UPPER", ":", "return", "ix86_builtins", "[", "IX86_BUILTIN_BNDUPPER", "]", ";", "default", ":", "return", "NULL_TREE", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "function", "decl", "for", "target", "specific", "builtin", "for", "given", "MPX", "builtin", "passed", "i", "FCODE", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "PatmosAsmPrinter", "::", "PrintAsmMemoryOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "OS", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "return", "true", ";", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "assert", "(", "MO", ".", "isReg", "(", ")", "&&", "\"unexpected inline asm memory operand\"", ")", ";", "OS", "<<", "\"[$\"", "<<", "PatmosInstPrinter", "::", "getRegisterName", "(", "MO", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "</s>" ]

[ "Print", "the", "specified", "operand", "of", "MI", ",", "an", "INLINEASM", "instruction", ",", "using", "the", "specified", "assembler", "variant", "as", "an", "address", "." ]

[ "Patmos", "Patmos", "0", "\"unexpected inline asm memory operand\"", "\"[$\"", "Patmos", "\"]\"" ]

[]

[ "<s>", "void", "aarch64_gen_atomic_cas", "(", "rtx", "rval", ",", "rtx", "mem", ",", "rtx", "expected", ",", "rtx", "desired", ",", "rtx", "model", ")", "{", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "machine_mode", "mode", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "gen", "=", "gen_aarch64_atomic_casqi", ";", "break", ";", "case", "E_HImode", ":", "gen", "=", "gen_aarch64_atomic_cashi", ";", "break", ";", "case", "E_SImode", ":", "gen", "=", "gen_aarch64_atomic_cassi", ";", "break", ";", "case", "E_DImode", ":", "gen", "=", "gen_aarch64_atomic_casdi", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "emit_insn", "(", "gen_rtx_SET", "(", "rval", ",", "expected", ")", ")", ";", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "desired", ",", "model", ")", ")", ";", "aarch64_gen_compare_reg", "(", "EQ", ",", "rval", ",", "expected", ")", ";", "}", "</s>" ]

[ "Emit", "an", "atomic", "compare-and-swap", "operation", ".", "RVAL", "is", "the", "destination", "register", "for", "the", "data", "in", "memory", ".", "EXPECTED", "is", "the", "value", "expected", "to", "be", "in", "memory", ".", "DESIRED", "is", "the", "value", "to", "store", "to", "memory", ".", "MEM", "is", "the", "memory", "location", ".", "MODEL", "is", "the", "memory", "ordering", "to", "use", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "isMem", "(", "RegisterKind", "RegKind", ",", "MemoryKind", "MemKind", ")", "const", "{", "return", "(", "Kind", "==", "KindMem", "&&", "Mem", ".", "RegKind", "==", "RegKind", "&&", "(", "MemKind", "==", "BDXMem", "||", "!", "Mem", ".", "Index", ")", "&&", "(", "MemKind", "==", "BDLMem", ")", "==", "(", "Mem", ".", "Length", "!=", "nullptr", ")", ")", ";", "}", "</s>" ]

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

[ "SystemZ" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "const", "uint16_t", "*", "Cpu0RegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "uint16_t", "CalleeSavedRegs", "[", "]", "=", "{", "0", "}", ";", "return", "CalleeSavedRegs", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0", "0" ]

[]

[ "<s>", "bool", "SystemZXPLINKFrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "SystemZMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SystemZMachineFunctionInfo", ">", "(", ")", ";", "const", "SystemZSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SystemZSubtarget", ">", "(", ")", ";", "auto", "&", "Regs", "=", "Subtarget", ".", "getSpecialRegisters", "<", "SystemZXPLINK64Registers", ">", "(", ")", ";", "unsigned", "LowGPR", "=", "0", ";", "int", "LowOffset", "=", "INT32_MAX", ";", "unsigned", "HighGPR", "=", "LowGPR", ";", "int", "HighOffset", "=", "-", "1", ";", "unsigned", "RegSP", "=", "Regs", ".", "getStackPointerRegister", "(", ")", ";", "auto", "&", "GRRegClass", "=", "SystemZ", "::", "GR64BitRegClass", ";", "const", "unsigned", "RegSize", "=", "8", ";", "auto", "ProcessCSI", "=", "[", "&", "]", "(", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSIList", ")", "{", "for", "(", "auto", "&", "CS", ":", "CSIList", ")", "{", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "int", "Offset", "=", "RegSpillOffsets", "[", "Reg", "]", ";", "if", "(", "Offset", ">=", "0", ")", "{", "if", "(", "GRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "if", "(", "LowOffset", ">", "Offset", ")", "{", "LowOffset", "=", "Offset", ";", "LowGPR", "=", "Reg", ";", "}", "if", "(", "Offset", ">", "HighOffset", ")", "{", "HighOffset", "=", "Offset", ";", "HighGPR", "=", "Reg", ";", "}", "}", "int", "FrameIdx", "=", "MFFrame", ".", "CreateFixedSpillStackObject", "(", "RegSize", ",", "Offset", ")", ";", "CS", ".", "setFrameIdx", "(", "FrameIdx", ")", ";", "}", "else", "CS", ".", "setFrameIdx", "(", "INT32_MAX", ")", ";", "}", "}", ";", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "Spills", ";", "Spills", ".", "push_back", "(", "CalleeSavedInfo", "(", "Regs", ".", "getAddressOfCalleeRegister", "(", ")", ")", ")", ";", "if", "(", "hasFP", "(", "MF", ")", "||", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "\"backchain\"", ")", ")", "Spills", ".", "push_back", "(", "CalleeSavedInfo", "(", "RegSP", ")", ")", ";", "ProcessCSI", "(", "CSI", ")", ";", "MFI", "->", "setRestoreGPRRegs", "(", "LowGPR", ",", "HighGPR", ",", "LowOffset", ")", ";", "ProcessCSI", "(", "Spills", ")", ";", "MFI", "->", "setSpillGPRRegs", "(", "LowGPR", ",", "HighGPR", ",", "LowOffset", ")", ";", "for", "(", "auto", "&", "CS", ":", "CSI", ")", "{", "if", "(", "CS", ".", "getFrameIdx", "(", ")", "!=", "INT32_MAX", ")", "continue", ";", "Register", "Reg", "=", "CS", ".", "getReg", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "Align", "Alignment", "=", "TRI", "->", "getSpillAlign", "(", "*", "RC", ")", ";", "unsigned", "Size", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "Alignment", "=", "std", "::", "min", "(", "Alignment", ",", "getStackAlign", "(", ")", ")", ";", "int", "FrameIdx", "=", "MFFrame", ".", "CreateStackObject", "(", "Size", ",", "Alignment", ",", "true", ")", ";", "CS", ".", "setFrameIdx", "(", "FrameIdx", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "will", "assign", "callee", "saved", "gprs", "to", "volatile", "vector", "registers", "for", "prologue", "spills", "when", "applicable", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "SystemZ", "0", "1", "SystemZ::GR64BitRegClass", "8", "0", "\"backchain\"" ]

[]

[ "<s>", "void", "GCNPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "const", "AMDGPUSubtarget", "&", "ST", "=", "*", "getAMDGPUTargetMachine", "(", ")", ".", "getSubtargetImpl", "(", ")", ";", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SIFixControlFlowLiveIntervalsID", ")", ";", "}", "if", "(", "getOptLevel", "(", ")", ">", "CodeGenOpt", "::", "None", "&&", "ST", ".", "loadStoreOptEnabled", "(", ")", ")", "{", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "SILoadStoreOptimizerID", ")", ";", "insertPass", "(", "&", "MachineSchedulerID", ",", "&", "RegisterCoalescerID", ")", ";", "}", "addPass", "(", "createSIShrinkInstructionsPass", "(", ")", ",", "false", ")", ";", "addPass", "(", "createSIWholeQuadModePass", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "HSAILRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "HSAIL", "HSAIL" ]

[]

[ "<s>", "SDValue", "TOYTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_TOY", ")", ";", "SDValue", "ArgValue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", ";", "if", "(", "RegVT", "==", "MVT", "::", "i32", ")", "RC", "=", "&", "TOY", "::", "GRRegsRegClass", ";", "else", "llvm_unreachable", "(", "\"LowerFormalArgments: Other types are not Implemented\\n\"", ")", ";", "unsigned", "Reg", "=", "MF", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "RC", ")", ";", "ArgValue", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "Reg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgValue", ")", ";", "}", "else", "{", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "SDValue", "FIPtr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "getPointerTy", "(", ")", ")", ";", "SDValue", "Load", ";", "if", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i32", ")", "{", "Load", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "4", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Other types in stack are not supported yet!\"", ")", ";", "}", "InVals", ".", "push_back", "(", "Load", ")", ";", "}", "}", "return", "Chain", ";", "}", "</s>" ]

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

[ "TOY", "TOY", "ISD::InputArg", "16", "TOY", "0", "MVT::i32", "TOY::GRRegsRegClass", "\"LowerFormalArgments: Other types are not Implemented\\n\"", "4", "MVT::i32", "4", "\"Other types in stack are not supported yet!\"" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isEligibleForTailCallOptimization", "(", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CalleeCC", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "!", "mayTailCallThisCC", "(", "CalleeCC", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "const", "Function", "&", "CallerF", "=", "MF", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", ".", "getCallingConv", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "getSubtarget", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "!", "CallerPreserved", ")", "return", "false", ";", "bool", "CCMatch", "=", "CallerCC", "==", "CalleeCC", ";", "if", "(", "DAG", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "{", "if", "(", "canGuaranteeTCO", "(", "CalleeCC", ")", "&&", "CCMatch", ")", "return", "true", ";", "return", "false", ";", "}", "if", "(", "IsVarArg", ")", "return", "false", ";", "for", "(", "const", "Argument", "&", "Arg", ":", "CallerF", ".", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasByValAttr", "(", ")", ")", "return", "false", ";", "}", "LLVMContext", "&", "Ctx", "=", "*", "DAG", ".", "getContext", "(", ")", ";", "if", "(", "!", "CCState", "::", "resultsCompatible", "(", "CalleeCC", ",", "CallerCC", ",", "MF", ",", "Ctx", ",", "Ins", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "IsVarArg", ")", ",", "CCAssignFnForCall", "(", "CallerCC", ",", "IsVarArg", ")", ")", ")", "return", "false", ";", "if", "(", "!", "CCMatch", ")", "{", "const", "uint32_t", "*", "CalleePreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CalleeCC", ")", ";", "if", "(", "!", "TRI", "->", "regmaskSubsetEqual", "(", "CallerPreserved", ",", "CalleePreserved", ")", ")", "return", "false", ";", "}", "if", "(", "Outs", ".", "empty", "(", ")", ")", "return", "true", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CalleeCC", ",", "IsVarArg", ",", "MF", ",", "ArgLocs", ",", "Ctx", ")", ";", "CCInfo", ".", "AnalyzeCallOperands", "(", "Outs", ",", "CCAssignFnForCall", "(", "CalleeCC", ",", "IsVarArg", ")", ")", ";", "const", "SIMachineFunctionInfo", "*", "FuncInfo", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", ">", "FuncInfo", "->", "getBytesInStackArgArea", "(", ")", ")", "return", "false", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "return", "parametersInCSRMatch", "(", "MRI", ",", "CallerPreserved", ",", "ArgLocs", ",", "OutVals", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "AMDGPU", "SI", "ISD::OutputArg", "ISD::InputArg", "SI", "16", "SI", "SI" ]

[]

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

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

[ "X86", "X86", "X86", "\"all\"", "1" ]

[]

[ "<s>", "void", "GBZ80FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "GBZ80MachineFunctionInfo", "*", "GBZ80FI", "=", "MF", ".", "getInfo", "<", "GBZ80MachineFunctionInfo", ">", "(", ")", ";", "const", "GBZ80InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "GBZ80InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RetOpcode", "!=", "GBZ80", "::", "RET", ")", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "uint64_t", "CallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "uint64_t", "FrameSize", "=", "GBZ80FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "StackSize", "+", "CallFrameSize", "-", "FrameSize", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "std", "::", "prev", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "GBZ80", "::", "POP16r", "&&", "!", "I", "->", "isTerminator", "(", ")", ")", "break", ";", "MBBI", "--", ";", "}", "if", "(", "NumBytes", ")", "{", "unsigned", "FP", "=", "TII", ".", "getRegisterInfo", "(", ")", ".", "getFrameRegister", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "LD16ri", ")", ",", "FP", ")", ".", "addImm", "(", "NumBytes", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "ADD16rSP", ")", ",", "FP", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "GBZ80", "::", "LD16SPr", ")", ")", ".", "addReg", "(", "FP", ",", "RegState", "::", "Kill", ")", ";", "}", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB", "GB", "GB", "GB", "GB", "GBZ80::RET", "\"Can only insert epilog into returning blocks\"", "GB", "GBZ80::POP16r", "GBZ80::LD16ri", "GBZ80::ADD16rSP", "GBZ80::LD16SPr" ]

[]

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

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

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

[]

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

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

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

[]

[ "<s>", "static", "bool", "use_push_rts_p", "(", "int", "nregs", ")", "{", "if", "(", "TARGET_INSNS_64PLUS", "&&", "optimize_function_for_size_p", "(", "cfun", ")", "&&", "!", "cfun", "->", "machine", "->", "contains_sibcall", "&&", "!", "cfun", "->", "returns_struct", "&&", "!", "TARGET_LONG_CALLS", "&&", "nregs", ">=", "6", "&&", "!", "frame_pointer_needed", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Examine", "the", "number", "of", "regs", "NREGS", "we", "'ve", "determined", "we", "must", "save", ".", "Return", "true", "if", "we", "should", "use", "__c6xabi_push_rts/__c6xabi_pop_rts", "for", "prologue", "and", "epilogue", "." ]

[ "c6x", "6" ]

[]

[ "<s>", "void", "GBZ80AsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "GBZ80MCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "I", ";", "MCInstLowering", ".", "lowerInstruction", "(", "*", "MI", ",", "I", ")", ";", "EmitToStreamer", "(", "*", "OutStreamer", ",", "I", ")", ";", "}", "</s>" ]

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

[ "GBZ80", "GB", "GB" ]

[]

[ "<s>", "rtx", "s390_function_value", "(", "tree", "type", ",", "enum", "machine_mode", "mode", ")", "{", "if", "(", "type", ")", "{", "int", "unsignedp", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "mode", "=", "promote_mode", "(", "type", ",", "TYPE_MODE", "(", "type", ")", ",", "&", "unsignedp", ",", "1", ")", ";", "}", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", ";", "gcc_assert", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "8", ")", ";", "if", "(", "TARGET_HARD_FLOAT", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "gen_rtx_REG", "(", "mode", ",", "16", ")", ";", "else", "return", "gen_rtx_REG", "(", "mode", ",", "2", ")", ";", "}", "</s>" ]

[ "Define", "where", "to", "return", "a", "(", "scalar", ")", "value", "of", "type", "TYPE", ".", "If", "TYPE", "is", "null", ",", "define", "where", "to", "return", "a", "(", "scalar", ")", "value", "of", "mode", "MODE", "from", "a", "libcall", "." ]

[ "s390", "1", "8", "16", "2" ]

[]

[ "<s>", "void", "mips16_expand_get_fcsr", "(", "rtx", "target", ")", "{", "if", "(", "!", "mips16_get_fcsr_stub", ")", "mips16_get_fcsr_stub", "=", "new", "mips16_get_fcsr_one_only_stub", "(", ")", ";", "rtx", "fn", "=", "mips16_stub_call_address", "(", "mips16_get_fcsr_stub", ")", ";", "emit_insn", "(", "PMODE_INSN", "(", "gen_mips_get_fcsr_mips16", ",", "(", "fn", ")", ")", ")", ";", "emit_move_insn", "(", "target", ",", "gen_rtx_REG", "(", "SImode", ",", "GET_FCSR_REGNUM", ")", ")", ";", "}", "</s>" ]

[ "Implement", "``", "TARGET", "=", "__builtin_mips_get_fcsr", "(", ")", "''", "for", "MIPS16", ",", "using", "a", "stub", "." ]

[ "mips" ]

[]

[ "<s>", "static", "unsigned", "int", "rs6000_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "machine_mode", "elt_mode", ";", "int", "n_elts", ";", "rs6000_discover_homogeneous_aggregate", "(", "mode", ",", "type", ",", "&", "elt_mode", ",", "&", "n_elts", ")", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "8", "||", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_FPRS", "&&", "(", "mode", "==", "TFmode", "||", "mode", "==", "TDmode", ")", ")", ")", ")", "return", "64", ";", "else", "if", "(", "SPE_VECTOR_MODE", "(", "mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "8", "&&", "int_size_in_bytes", "(", "type", ")", "<", "16", ")", ")", "return", "64", ";", "else", "if", "(", "ALTIVEC_OR_VSX_VECTOR_MODE", "(", "elt_mode", ")", "||", "(", "type", "&&", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", "&&", "int_size_in_bytes", "(", "type", ")", ">=", "16", ")", ")", "return", "128", ";", "if", "(", "(", "(", "DEFAULT_ABI", "==", "ABI_AIX", "&&", "!", "rs6000_compat_align_parm", ")", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "{", "bool", "aggregate_p", "=", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "!", "SCALAR_FLOAT_MODE_P", "(", "elt_mode", ")", ")", ";", "if", "(", "aggregate_p", "!=", "(", "mode", "==", "BLKmode", ")", ")", "{", "static", "bool", "warned", ";", "if", "(", "!", "warned", "&&", "warn_psabi", ")", "{", "warned", "=", "true", ";", "inform", "(", "input_location", ",", "\"the ABI of passing aggregates with %d-byte alignment\"", "\" has changed in GCC 5\"", ",", "(", "int", ")", "TYPE_ALIGN", "(", "type", ")", "/", "BITS_PER_UNIT", ")", ";", "}", "}", "if", "(", "aggregate_p", ")", "return", "128", ";", "}", "if", "(", "TARGET_MACHO", "&&", "rs6000_darwin64_abi", "&&", "mode", "==", "BLKmode", "&&", "type", "&&", "TYPE_ALIGN", "(", "type", ")", ">", "64", ")", "return", "128", ";", "return", "PARM_BOUNDARY", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "expression", "that", "gives", "the", "alignment", "boundary", ",", "in", "bits", ",", "of", "an", "argument", "with", "the", "specified", "mode", "and", "type", ".", "If", "it", "is", "not", "defined", ",", "PARM_BOUNDARY", "is", "used", "for", "all", "arguments", ".", "V.4", "wants", "long", "longs", "and", "doubles", "to", "be", "double", "word", "aligned", ".", "Just", "testing", "the", "mode", "size", "is", "a", "boneheaded", "way", "to", "do", "this", "as", "it", "means", "that", "other", "types", "such", "as", "complex", "int", "are", "also", "double", "word", "aligned", ".", "However", ",", "we", "'re", "stuck", "with", "this", "because", "changing", "the", "ABI", "might", "break", "existing", "library", "interfaces", ".", "Quadword", "align", "Altivec/VSX", "vectors", ".", "Quadword", "align", "large", "synthetic", "vector", "types", "." ]

[ "rs6000", "8", "64", "8", "16", "64", "16", "128", "64", "\"the ABI of passing aggregates with %d-byte alignment\"", "\" has changed in GCC 5\"", "128", "64", "128" ]

[]

[ "<s>", "bool", "alpha_legitimate_constant_p", "(", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "HOST_WIDE_INT", "i0", ",", "i1", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "LABEL_REF", ":", "case", "HIGH", ":", "return", "true", ";", "case", "CONST", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "else", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "true", ";", "case", "SYMBOL_REF", ":", "return", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "0", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_VECTOR", ":", "if", "(", "x", "==", "CONST0_RTX", "(", "mode", ")", ")", "return", "true", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "!=", "MODE_VECTOR_INT", ")", "return", "false", ";", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "!=", "8", ")", "return", "false", ";", "goto", "do_integer", ";", "case", "CONST_INT", ":", "do_integer", ":", "if", "(", "TARGET_BUILD_CONSTANTS", ")", "return", "true", ";", "alpha_extract_integer", "(", "x", ",", "&", "i0", ",", "&", "i1", ")", ";", "if", "(", "HOST_BITS_PER_WIDE_INT", ">=", "64", "||", "i1", "==", "(", "-", "i0", "<", "0", ")", ")", "return", "alpha_emit_set_const_1", "(", "x", ",", "mode", ",", "i0", ",", "3", ",", "true", ")", "!=", "NULL", ";", "return", "false", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Implement", "LEGITIMATE_CONSTANT_P", ".", "This", "is", "all", "constants", "for", "which", "we", "are", "willing", "to", "load", "the", "value", "into", "a", "register", "via", "a", "move", "pattern", ".", "Normally", "this", "is", "all", "symbolic", "constants", ",", "integral", "constants", "that", "take", "three", "or", "fewer", "instructions", ",", "and", "floating-point", "zero", "." ]

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

[]

[ "<s>", "const", "MMIXRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RegInfo", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", "||", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "std", "::", "prev", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI_end", "=", "MBB", ".", "end", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "EH_RETURN_JMPR", ")", "{", "assert", "(", "MBBI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "\"Offset should be in register!\"", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOCFRAME", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "ADD_rr", ")", ",", "Hexagon", "::", "R29", ")", ".", "addReg", "(", "Hexagon", "::", "R29", ")", ".", "addReg", "(", "Hexagon", "::", "R28", ")", ";", "return", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "hasV4TOps", "(", ")", "&&", "MBBI", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "JMPret", "&&", "!", "DisableDeallocRet", ")", "{", "MachineBasicBlock", "::", "iterator", "BeforeJMPR", "=", "MBB", ".", "begin", "(", ")", "==", "MBBI", "?", "MBBI", ":", "std", "::", "prev", "(", "MBBI", ")", ";", "if", "(", "BeforeJMPR", "!=", "MBBI", "&&", "BeforeJMPR", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "RESTORE_DEALLOC_RET_JMP_V4", ")", "{", "MBB", ".", "erase", "(", "MBBI", ")", ";", "return", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MBBI_end", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOC_RET_V4", ")", ")", ";", "MIB", "->", "copyImplicitOps", "(", "*", "MBB", ".", "getParent", "(", ")", ",", "&", "*", "MBBI", ")", ";", "MBB", ".", "erase", "(", "MBBI", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "Term", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "Term", "==", "MBB", ".", "begin", "(", ")", "?", "MBB", ".", "end", "(", ")", ":", "std", "::", "prev", "(", "Term", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", "&&", "I", "->", "getOpcode", "(", ")", "==", "Hexagon", "::", "RESTORE_DEALLOC_BEFORE_TAILCALL_V4", ")", "return", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Hexagon", "::", "DEALLOCFRAME", ")", ")", ";", "}", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::EH_RETURN_JMPR", "0", "\"Offset should be in register!\"", "Hexagon::DEALLOCFRAME", "Hexagon::ADD_rr", "Hexagon::R29", "Hexagon::R29", "Hexagon::R28", "Hexagon", "Hexagon::JMPret", "Hexagon::RESTORE_DEALLOC_RET_JMP_V4", "Hexagon::DEALLOC_RET_V4", "Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4", "Hexagon::DEALLOCFRAME" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "isEligibleForTailCallOptimization", "(", "MachineIRBuilder", "&", "B", ",", "CallLoweringInfo", "&", "Info", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "InArgs", ",", "SmallVectorImpl", "<", "ArgInfo", ">", "&", "OutArgs", ")", "const", "{", "if", "(", "!", "Info", ".", "IsTailCall", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "B", ".", "getMF", "(", ")", ";", "const", "Function", "&", "CallerF", "=", "MF", ".", "getFunction", "(", ")", ";", "CallingConv", "::", "ID", "CalleeCC", "=", "Info", ".", "CallConv", ";", "CallingConv", "::", "ID", "CallerCC", "=", "CallerF", ".", "getCallingConv", "(", ")", ";", "const", "SIRegisterInfo", "*", "TRI", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "uint32_t", "*", "CallerPreserved", "=", "TRI", "->", "getCallPreservedMask", "(", "MF", ",", "CallerCC", ")", ";", "if", "(", "!", "CallerPreserved", ")", "return", "false", ";", "if", "(", "!", "mayTailCallThisCC", "(", "CalleeCC", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"... Calling convention cannot be tail called.\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "any_of", "(", "CallerF", ".", "args", "(", ")", ",", "[", "]", "(", "const", "Argument", "&", "A", ")", "{", "return", "A", ".", "hasByValAttr", "(", ")", "||", "A", ".", "hasSwiftErrorAttr", "(", ")", ";", "}", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"... Cannot tail call from callers with byval \"", "\"or swifterror arguments\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", ")", "return", "canGuaranteeTCO", "(", "CalleeCC", ")", "&&", "CalleeCC", "==", "CallerF", ".", "getCallingConv", "(", ")", ";", "if", "(", "!", "doCallerAndCalleePassArgsTheSameWay", "(", "Info", ",", "MF", ",", "InArgs", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"... Caller and callee have incompatible calling conventions.\\n\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "areCalleeOutgoingArgsTailCallable", "(", "Info", ",", "MF", ",", "OutArgs", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"... Call is eligible for tail call optimization.\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "call", "can", "be", "lowered", "as", "a", "tail", "call", "." ]

[ "AMDGPU", "AMDGPU", "SI", "\"... Calling convention cannot be tail called.\\n\"", "\"... Cannot tail call from callers with byval \"", "\"or swifterror arguments\\n\"", "\"... Caller and callee have incompatible calling conventions.\\n\"", "\"... Call is eligible for tail call optimization.\\n\"" ]

[]

[ "<s>", "static", "bool", "rs6000_vectorize_vec_perm_const", "(", "machine_mode", "vmode", ",", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "const", "vec_perm_indices", "&", "sel", ")", "{", "bool", "testing_p", "=", "!", "target", ";", "if", "(", "TARGET_ALTIVEC", "&&", "testing_p", ")", "return", "true", ";", "if", "(", "op0", ")", "{", "rtx", "nop0", "=", "force_reg", "(", "vmode", ",", "op0", ")", ";", "if", "(", "op0", "==", "op1", ")", "op1", "=", "nop0", ";", "op0", "=", "nop0", ";", "}", "if", "(", "op1", ")", "op1", "=", "force_reg", "(", "vmode", ",", "op1", ")", ";", "if", "(", "(", "vmode", "==", "V2DFmode", "||", "vmode", "==", "V2DImode", ")", "&&", "VECTOR_MEM_VSX_P", "(", "vmode", ")", ")", "{", "if", "(", "testing_p", ")", "{", "op0", "=", "gen_raw_REG", "(", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "op1", "=", "gen_raw_REG", "(", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "}", "if", "(", "rs6000_expand_vec_perm_const_1", "(", "target", ",", "op0", ",", "op1", ",", "sel", "[", "0", "]", ",", "sel", "[", "1", "]", ")", ")", "return", "true", ";", "}", "if", "(", "TARGET_ALTIVEC", ")", "{", "if", "(", "vmode", "!=", "V16QImode", ")", "return", "false", ";", "if", "(", "altivec_expand_vec_perm_const", "(", "target", ",", "op0", ",", "op1", ",", "sel", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_VEC_PERM_CONST", "." ]

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

[]

[ "<s>", "bool", "XCoreRegisterInfo", "::", "trackLivenessAfterRegAlloc", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "requiresRegisterScavenging", "(", "MF", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "live-ins", "should", "be", "tracked", "after", "register", "allocation", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "LoadInst", "*", "X86TargetLowering", "::", "lowerIdempotentRMWIntoFencedLoad", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "unsigned", "NativeWidth", "=", "Subtarget", ".", "is64Bit", "(", ")", "?", "64", ":", "32", ";", "Type", "*", "MemType", "=", "AI", "->", "getType", "(", ")", ";", "if", "(", "MemType", "->", "getPrimitiveSizeInBits", "(", ")", ">", "NativeWidth", ")", "return", "nullptr", ";", "auto", "Builder", "=", "IRBuilder", "<", ">", "(", "AI", ")", ";", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "auto", "SynchScope", "=", "AI", "->", "getSynchScope", "(", ")", ";", "auto", "Order", "=", "AtomicCmpXchgInst", "::", "getStrongestFailureOrdering", "(", "AI", "->", "getOrdering", "(", ")", ")", ";", "auto", "Ptr", "=", "AI", "->", "getPointerOperand", "(", ")", ";", "if", "(", "SynchScope", "==", "SingleThread", ")", "return", "nullptr", ";", "if", "(", "!", "Subtarget", ".", "hasMFence", "(", ")", ")", "return", "nullptr", ";", "Function", "*", "MFence", "=", "llvm", "::", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Intrinsic", "::", "x86_sse2_mfence", ")", ";", "Builder", ".", "CreateCall", "(", "MFence", ",", "{", "}", ")", ";", "LoadInst", "*", "Loaded", "=", "Builder", ".", "CreateAlignedLoad", "(", "Ptr", ",", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ")", ";", "Loaded", "->", "setAtomic", "(", "Order", ",", "SynchScope", ")", ";", "AI", "->", "replaceAllUsesWith", "(", "Loaded", ")", ";", "AI", "->", "eraseFromParent", "(", ")", ";", "return", "Loaded", ";", "}", "</s>" ]

[ "On", "some", "platforms", ",", "an", "AtomicRMW", "that", "never", "actually", "modifies", "the", "value", "(", "such", "as", "fetch_add", "of", "0", ")", "can", "be", "turned", "into", "a", "fence", "followed", "by", "an", "atomic", "load", "." ]

[ "X86", "X86", "64", "32", "Intrinsic::getDeclaration", "Intrinsic::x86_sse2_mfence" ]

[]

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

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

[ "BPF" ]

[]

[ "<s>", "void", "pass_vsetvl", "::", "transfer_before", "(", "vector_insn_info", "&", "info", ",", "insn_info", "*", "insn", ")", "const", "{", "if", "(", "!", "has_vtype_op", "(", "insn", "->", "rtl", "(", ")", ")", ")", "return", ";", "const", "vector_insn_info", "require", "=", "m_vector_manager", "->", "vector_insn_infos", "[", "insn", "->", "uid", "(", ")", "]", ";", "if", "(", "info", ".", "valid_p", "(", ")", "&&", "!", "need_vsetvl", "(", "require", ",", "info", ")", ")", "return", ";", "info", "=", "require", ";", "}", "</s>" ]

[ "Given", "an", "incoming", "state", "reaching", "INSN", ",", "modifies", "that", "state", "so", "that", "it", "is", "minimally", "compatible", "with", "INSN", ".", "The", "resulting", "state", "is", "guaranteed", "to", "be", "semantically", "legal", "for", "INSN", ",", "but", "may", "not", "be", "the", "state", "requested", "by", "INSN", "." ]

[ "riscv" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AMDGPU Control Flow Graph structurizer Pass\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"AMDGPU Control Flow Graph structurizer Pass\"" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "avr_starting_frame_offset", "(", "void", ")", "{", "return", "1", "+", "avr_outgoing_args_size", "(", ")", ";", "}", "</s>" ]

[ "This", "is", "the", "offset", "from", "the", "frame", "pointer", "register", "to", "the", "first", "stack", "slot", "that", "contains", "a", "variable", "living", "in", "the", "frame", "." ]

[ "avr", "1" ]

[]

[ "<s>", "unsigned", "int", "arm_dbx_register_number", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "<", "16", ")", "return", "regno", ";", "if", "(", "IS_FPA_REGNUM", "(", "regno", ")", ")", "return", "(", "TARGET_AAPCS_BASED", "?", "96", ":", "16", ")", "+", "regno", "-", "FIRST_FPA_REGNUM", ";", "if", "(", "IS_VFP_REGNUM", "(", "regno", ")", ")", "return", "64", "+", "regno", "-", "FIRST_VFP_REGNUM", ";", "if", "(", "IS_IWMMXT_GR_REGNUM", "(", "regno", ")", ")", "return", "104", "+", "regno", "-", "FIRST_IWMMXT_GR_REGNUM", ";", "if", "(", "IS_IWMMXT_REGNUM", "(", "regno", ")", ")", "return", "112", "+", "regno", "-", "FIRST_IWMMXT_REGNUM", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Map", "internal", "gcc", "register", "numbers", "to", "DWARF2", "register", "numbers", "." ]

[ "arm", "16", "96", "16", "64", "104", "112" ]

[]

[ "<s>", "bool", "AMDGPUAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Name", "=", "parseMnemonicSuffix", "(", "Name", ")", ";", "applyMnemonicAliases", "(", "Name", ",", "getAvailableFeatures", "(", ")", ",", "0", ")", ";", "Operands", ".", "push_back", "(", "AMDGPUOperand", "::", "CreateToken", "(", "this", ",", "Name", ",", "NameLoc", ")", ")", ";", "bool", "IsMIMG", "=", "Name", ".", "startswith", "(", "\"image_\"", ")", ";", "while", "(", "!", "trySkipToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "OperandMode", "Mode", "=", "OperandMode_Default", ";", "if", "(", "IsMIMG", "&&", "isGFX10Plus", "(", ")", "&&", "Operands", ".", "size", "(", ")", "==", "2", ")", "Mode", "=", "OperandMode_NSA", ";", "CPolSeen", "=", "0", ";", "OperandMatchResultTy", "Res", "=", "parseOperand", "(", "Operands", ",", "Name", ",", "Mode", ")", ";", "if", "(", "Res", "!=", "MatchOperand_Success", ")", "{", "checkUnsupportedInstruction", "(", "Name", ",", "NameLoc", ")", ";", "if", "(", "!", "Parser", ".", "hasPendingError", "(", ")", ")", "{", "StringRef", "Msg", "=", "(", "Res", "==", "MatchOperand_ParseFail", ")", "?", "\"failed parsing operand.\"", ":", "\"not a valid operand.\"", ";", "Error", "(", "getLoc", "(", ")", ",", "Msg", ")", ";", "}", "while", "(", "!", "trySkipToken", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "lex", "(", ")", ";", "}", "return", "true", ";", "}", "trySkipToken", "(", "AsmToken", "::", "Comma", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AMDGPU", "AMDGPU", "0", "AMDGPU", "\"image_\"", "2", "0", "\"failed parsing operand.\"", "\"not a valid operand.\"" ]

[]

[ "<s>", "rtx", "mve_bool_vec_to_const", "(", "rtx", "const_vec", ")", "{", "int", "n_elts", "=", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "const_vec", ")", ")", ";", "int", "repeat", "=", "16", "/", "n_elts", ";", "int", "i", ";", "int", "hi_val", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "el", "=", "CONST_VECTOR_ELT", "(", "const_vec", ",", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "elpart", ";", "gcc_assert", "(", "CONST_INT_P", "(", "el", ")", ")", ";", "elpart", "=", "INTVAL", "(", "el", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "repeat", ";", "j", "++", ")", "hi_val", "|=", "elpart", "<<", "(", "i", "*", "repeat", "+", "j", ")", ";", "}", "return", "gen_int_mode", "(", "hi_val", ",", "HImode", ")", ";", "}", "</s>" ]

[ "Return", "a", "HI", "representation", "of", "CONST_VEC", "suitable", "for", "MVE", "predicates", "." ]

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

[]

[ "<s>", "bool", "FPS", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "FPIsUsed", "=", "false", ";", "assert", "(", "X86", "::", "FP6", "==", "X86", "::", "FP0", "+", "6", "&&", "\"Register enums aren't sorted right!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<=", "6", ";", "++", "i", ")", "if", "(", "MF", ".", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "X86", "::", "FP0", "+", "i", ")", ")", "{", "FPIsUsed", "=", "true", ";", "break", ";", "}", "if", "(", "!", "FPIsUsed", ")", "return", "false", ";", "Bundles", "=", "&", "getAnalysis", "<", "EdgeBundles", ">", "(", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bundleCFG", "(", "MF", ")", ";", "StackTop", "=", "0", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "8", ">", "Processed", ";", "MachineBasicBlock", "*", "Entry", "=", "MF", ".", "begin", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "*", "BB", ":", "depth_first_ext", "(", "Entry", ",", "Processed", ")", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "if", "(", "MF", ".", "size", "(", ")", "!=", "Processed", ".", "size", "(", ")", ")", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "if", "(", "Processed", ".", "insert", "(", "BB", ")", ".", "second", ")", "Changed", "|=", "processBasicBlock", "(", "MF", ",", "*", "BB", ")", ";", "LiveBundles", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86::FP6", "X86::FP0", "6", "\"Register enums aren't sorted right!\"", "0", "6", "X86::FP0", "0", "8" ]

[]

[ "<s>", "static", "const", "char", "*", "arm_invalid_within_doloop", "(", "const", "rtx_insn", "*", "insn", ")", "{", "if", "(", "!", "TARGET_HAVE_LOB", ")", "return", "default_invalid_within_doloop", "(", "insn", ")", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "\"Function call in the loop.\"", ";", "if", "(", "reg_mentioned_p", "(", "gen_rtx_REG", "(", "SImode", ",", "LR_REGNUM", ")", ",", "insn", ")", ")", "return", "\"LR is used inside loop.\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "NULL", "if", "insn", "INSN", "is", "valid", "within", "a", "low-overhead", "loop", ".", "Otherwise", "return", "why", "doloop", "can", "not", "be", "applied", "." ]

[ "arm", "\"Function call in the loop.\"", "\"LR is used inside loop.\"" ]

[]

[ "<s>", "const", "char", "*", "PPCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "PPCISD", "::", "FSEL", ":", "return", "\"PPCISD::FSEL\"", ";", "case", "PPCISD", "::", "FCFID", ":", "return", "\"PPCISD::FCFID\"", ";", "case", "PPCISD", "::", "FCTIDZ", ":", "return", "\"PPCISD::FCTIDZ\"", ";", "case", "PPCISD", "::", "FCTIWZ", ":", "return", "\"PPCISD::FCTIWZ\"", ";", "case", "PPCISD", "::", "FRE", ":", "return", "\"PPCISD::FRE\"", ";", "case", "PPCISD", "::", "FRSQRTE", ":", "return", "\"PPCISD::FRSQRTE\"", ";", "case", "PPCISD", "::", "STFIWX", ":", "return", "\"PPCISD::STFIWX\"", ";", "case", "PPCISD", "::", "VMADDFP", ":", "return", "\"PPCISD::VMADDFP\"", ";", "case", "PPCISD", "::", "VNMSUBFP", ":", "return", "\"PPCISD::VNMSUBFP\"", ";", "case", "PPCISD", "::", "VPERM", ":", "return", "\"PPCISD::VPERM\"", ";", "case", "PPCISD", "::", "Hi", ":", "return", "\"PPCISD::Hi\"", ";", "case", "PPCISD", "::", "Lo", ":", "return", "\"PPCISD::Lo\"", ";", "case", "PPCISD", "::", "TOC_ENTRY", ":", "return", "\"PPCISD::TOC_ENTRY\"", ";", "case", "PPCISD", "::", "TOC_RESTORE", ":", "return", "\"PPCISD::TOC_RESTORE\"", ";", "case", "PPCISD", "::", "LOAD", ":", "return", "\"PPCISD::LOAD\"", ";", "case", "PPCISD", "::", "LOAD_TOC", ":", "return", "\"PPCISD::LOAD_TOC\"", ";", "case", "PPCISD", "::", "DYNALLOC", ":", "return", "\"PPCISD::DYNALLOC\"", ";", "case", "PPCISD", "::", "GlobalBaseReg", ":", "return", "\"PPCISD::GlobalBaseReg\"", ";", "case", "PPCISD", "::", "SRL", ":", "return", "\"PPCISD::SRL\"", ";", "case", "PPCISD", "::", "SRA", ":", "return", "\"PPCISD::SRA\"", ";", "case", "PPCISD", "::", "SHL", ":", "return", "\"PPCISD::SHL\"", ";", "case", "PPCISD", "::", "CALL", ":", "return", "\"PPCISD::CALL\"", ";", "case", "PPCISD", "::", "CALL_NOP", ":", "return", "\"PPCISD::CALL_NOP\"", ";", "case", "PPCISD", "::", "MTCTR", ":", "return", "\"PPCISD::MTCTR\"", ";", "case", "PPCISD", "::", "BCTRL", ":", "return", "\"PPCISD::BCTRL\"", ";", "case", "PPCISD", "::", "RET_FLAG", ":", "return", "\"PPCISD::RET_FLAG\"", ";", "case", "PPCISD", "::", "EH_SJLJ_SETJMP", ":", "return", "\"PPCISD::EH_SJLJ_SETJMP\"", ";", "case", "PPCISD", "::", "EH_SJLJ_LONGJMP", ":", "return", "\"PPCISD::EH_SJLJ_LONGJMP\"", ";", "case", "PPCISD", "::", "MFOCRF", ":", "return", "\"PPCISD::MFOCRF\"", ";", "case", "PPCISD", "::", "VCMP", ":", "return", "\"PPCISD::VCMP\"", ";", "case", "PPCISD", "::", "VCMPo", ":", "return", "\"PPCISD::VCMPo\"", ";", "case", "PPCISD", "::", "LBRX", ":", "return", "\"PPCISD::LBRX\"", ";", "case", "PPCISD", "::", "STBRX", ":", "return", "\"PPCISD::STBRX\"", ";", "case", "PPCISD", "::", "LARX", ":", "return", "\"PPCISD::LARX\"", ";", "case", "PPCISD", "::", "STCX", ":", "return", "\"PPCISD::STCX\"", ";", "case", "PPCISD", "::", "COND_BRANCH", ":", "return", "\"PPCISD::COND_BRANCH\"", ";", "case", "PPCISD", "::", "BDNZ", ":", "return", "\"PPCISD::BDNZ\"", ";", "case", "PPCISD", "::", "BDZ", ":", "return", "\"PPCISD::BDZ\"", ";", "case", "PPCISD", "::", "MFFS", ":", "return", "\"PPCISD::MFFS\"", ";", "case", "PPCISD", "::", "FADDRTZ", ":", "return", "\"PPCISD::FADDRTZ\"", ";", "case", "PPCISD", "::", "TC_RETURN", ":", "return", "\"PPCISD::TC_RETURN\"", ";", "case", "PPCISD", "::", "CR6SET", ":", "return", "\"PPCISD::CR6SET\"", ";", "case", "PPCISD", "::", "CR6UNSET", ":", "return", "\"PPCISD::CR6UNSET\"", ";", "case", "PPCISD", "::", "ADDIS_TOC_HA", ":", "return", "\"PPCISD::ADDIS_TOC_HA\"", ";", "case", "PPCISD", "::", "LD_TOC_L", ":", "return", "\"PPCISD::LD_TOC_L\"", ";", "case", "PPCISD", "::", "ADDI_TOC_L", ":", "return", "\"PPCISD::ADDI_TOC_L\"", ";", "case", "PPCISD", "::", "ADDIS_GOT_TPREL_HA", ":", "return", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", ";", "case", "PPCISD", "::", "LD_GOT_TPREL_L", ":", "return", "\"PPCISD::LD_GOT_TPREL_L\"", ";", "case", "PPCISD", "::", "ADD_TLS", ":", "return", "\"PPCISD::ADD_TLS\"", ";", "case", "PPCISD", "::", "ADDIS_TLSGD_HA", ":", "return", "\"PPCISD::ADDIS_TLSGD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSGD_L", ":", "return", "\"PPCISD::ADDI_TLSGD_L\"", ";", "case", "PPCISD", "::", "GET_TLS_ADDR", ":", "return", "\"PPCISD::GET_TLS_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_TLSLD_HA", ":", "return", "\"PPCISD::ADDIS_TLSLD_HA\"", ";", "case", "PPCISD", "::", "ADDI_TLSLD_L", ":", "return", "\"PPCISD::ADDI_TLSLD_L\"", ";", "case", "PPCISD", "::", "GET_TLSLD_ADDR", ":", "return", "\"PPCISD::GET_TLSLD_ADDR\"", ";", "case", "PPCISD", "::", "ADDIS_DTPREL_HA", ":", "return", "\"PPCISD::ADDIS_DTPREL_HA\"", ";", "case", "PPCISD", "::", "ADDI_DTPREL_L", ":", "return", "\"PPCISD::ADDI_DTPREL_L\"", ";", "case", "PPCISD", "::", "VADD_SPLAT", ":", "return", "\"PPCISD::VADD_SPLAT\"", ";", "case", "PPCISD", "::", "SC", ":", "return", "\"PPCISD::SC\"", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "0", "PPCISD::FSEL", "\"PPCISD::FSEL\"", "PPCISD::FCFID", "\"PPCISD::FCFID\"", "PPCISD::FCTIDZ", "\"PPCISD::FCTIDZ\"", "PPCISD::FCTIWZ", "\"PPCISD::FCTIWZ\"", "PPCISD::FRE", "\"PPCISD::FRE\"", "PPCISD::FRSQRTE", "\"PPCISD::FRSQRTE\"", "PPCISD::STFIWX", "\"PPCISD::STFIWX\"", "PPCISD::VMADDFP", "\"PPCISD::VMADDFP\"", "PPCISD::VNMSUBFP", "\"PPCISD::VNMSUBFP\"", "PPCISD::VPERM", "\"PPCISD::VPERM\"", "PPCISD::Hi", "\"PPCISD::Hi\"", "PPCISD::Lo", "\"PPCISD::Lo\"", "PPCISD::TOC_ENTRY", "\"PPCISD::TOC_ENTRY\"", "PPCISD::TOC_RESTORE", "\"PPCISD::TOC_RESTORE\"", "PPCISD::LOAD", "\"PPCISD::LOAD\"", "PPCISD::LOAD_TOC", "\"PPCISD::LOAD_TOC\"", "PPCISD::DYNALLOC", "\"PPCISD::DYNALLOC\"", "PPCISD::GlobalBaseReg", "\"PPCISD::GlobalBaseReg\"", "PPCISD::SRL", "\"PPCISD::SRL\"", "PPCISD::SRA", "\"PPCISD::SRA\"", "PPCISD::SHL", "\"PPCISD::SHL\"", "PPCISD::CALL", "\"PPCISD::CALL\"", "PPCISD::CALL_NOP", "\"PPCISD::CALL_NOP\"", "PPCISD::MTCTR", "\"PPCISD::MTCTR\"", "PPCISD::BCTRL", "\"PPCISD::BCTRL\"", "PPCISD::RET_FLAG", "\"PPCISD::RET_FLAG\"", "PPCISD::EH_SJLJ_SETJMP", "\"PPCISD::EH_SJLJ_SETJMP\"", "PPCISD::EH_SJLJ_LONGJMP", "\"PPCISD::EH_SJLJ_LONGJMP\"", "PPCISD::MFOCRF", "\"PPCISD::MFOCRF\"", "PPCISD::VCMP", "\"PPCISD::VCMP\"", "PPCISD::VCMPo", "\"PPCISD::VCMPo\"", "PPCISD::LBRX", "\"PPCISD::LBRX\"", "PPCISD::STBRX", "\"PPCISD::STBRX\"", "PPCISD::LARX", "\"PPCISD::LARX\"", "PPCISD::STCX", "\"PPCISD::STCX\"", "PPCISD::COND_BRANCH", "\"PPCISD::COND_BRANCH\"", "PPCISD::BDNZ", "\"PPCISD::BDNZ\"", "PPCISD::BDZ", "\"PPCISD::BDZ\"", "PPCISD::MFFS", "\"PPCISD::MFFS\"", "PPCISD::FADDRTZ", "\"PPCISD::FADDRTZ\"", "PPCISD::TC_RETURN", "\"PPCISD::TC_RETURN\"", "PPCISD::CR6SET", "\"PPCISD::CR6SET\"", "PPCISD::CR6UNSET", "\"PPCISD::CR6UNSET\"", "PPCISD::ADDIS_TOC_HA", "\"PPCISD::ADDIS_TOC_HA\"", "PPCISD::LD_TOC_L", "\"PPCISD::LD_TOC_L\"", "PPCISD::ADDI_TOC_L", "\"PPCISD::ADDI_TOC_L\"", "PPCISD::ADDIS_GOT_TPREL_HA", "\"PPCISD::ADDIS_GOT_TPREL_HA\"", "PPCISD::LD_GOT_TPREL_L", "\"PPCISD::LD_GOT_TPREL_L\"", "PPCISD::ADD_TLS", "\"PPCISD::ADD_TLS\"", "PPCISD::ADDIS_TLSGD_HA", "\"PPCISD::ADDIS_TLSGD_HA\"", "PPCISD::ADDI_TLSGD_L", "\"PPCISD::ADDI_TLSGD_L\"", "PPCISD::GET_TLS_ADDR", "\"PPCISD::GET_TLS_ADDR\"", "PPCISD::ADDIS_TLSLD_HA", "\"PPCISD::ADDIS_TLSLD_HA\"", "PPCISD::ADDI_TLSLD_L", "\"PPCISD::ADDI_TLSLD_L\"", "PPCISD::GET_TLSLD_ADDR", "\"PPCISD::GET_TLSLD_ADDR\"", "PPCISD::ADDIS_DTPREL_HA", "\"PPCISD::ADDIS_DTPREL_HA\"", "PPCISD::ADDI_DTPREL_L", "\"PPCISD::ADDI_DTPREL_L\"", "PPCISD::VADD_SPLAT", "\"PPCISD::VADD_SPLAT\"", "PPCISD::SC", "\"PPCISD::SC\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "set_frame_related_p", "(", "void", ")", "{", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "rtx_insn", "*", "insn", ";", "end_sequence", "(", ")", ";", "if", "(", "!", "seq", ")", "return", "NULL", ";", "if", "(", "INSN_P", "(", "seq", ")", ")", "{", "insn", "=", "seq", ";", "while", "(", "insn", "!=", "NULL_RTX", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "}", "seq", "=", "emit_insn", "(", "seq", ")", ";", "}", "else", "{", "seq", "=", "emit_insn", "(", "seq", ")", ";", "RTX_FRAME_RELATED_P", "(", "seq", ")", "=", "1", ";", "}", "return", "seq", ";", "}", "</s>" ]

[ "Helper", "function", "to", "set", "RTX_FRAME_RELATED_P", "on", "instructions", ",", "including", "sequences", "." ]

[ "tilepro", "1", "1" ]

[]

[ "<s>", "bool", "ARMDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "unsigned", "ConstraintID", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "assert", "(", "ConstraintID", "==", "InlineAsm", "::", "Constraint_m", "&&", "\"unexpected asm memory constraint\"", ")", ";", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "ARM", "ARM", "\"unexpected asm memory constraint\"" ]

[]

[ "<s>", "void", "Cpu0TargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "this", "->", "TM", "=", "&", "static_cast", "<", "const", "Cpu0TargetMachine", "&", ">", "(", "TM", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "enum", "sched_fusion_type", "fusion_load_store", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "x", ",", "dest", ",", "src", ";", "enum", "sched_fusion_type", "fusion", "=", "SCHED_FUSION_LD", ";", "gcc_assert", "(", "INSN_P", "(", "insn", ")", ")", ";", "x", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SET", ")", "return", "SCHED_FUSION_NONE", ";", "src", "=", "SET_SRC", "(", "x", ")", ";", "dest", "=", "SET_DEST", "(", "x", ")", ";", "machine_mode", "dest_mode", "=", "GET_MODE", "(", "dest", ")", ";", "if", "(", "!", "aarch64_mode_valid_for_sched_fusion_p", "(", "dest_mode", ")", ")", "return", "SCHED_FUSION_NONE", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "SIGN_EXTEND", ")", "{", "fusion", "=", "SCHED_FUSION_LD_SIGN_EXTEND", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "MEM", "||", "GET_MODE", "(", "src", ")", "!=", "SImode", ")", "return", "SCHED_FUSION_NONE", ";", "}", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "ZERO_EXTEND", ")", "{", "fusion", "=", "SCHED_FUSION_LD_ZERO_EXTEND", ";", "src", "=", "XEXP", "(", "src", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "!=", "MEM", "||", "GET_MODE", "(", "src", ")", "!=", "SImode", ")", "return", "SCHED_FUSION_NONE", ";", "}", "if", "(", "GET_CODE", "(", "src", ")", "==", "MEM", "&&", "REG_P", "(", "dest", ")", ")", "extract_base_offset_in_addr", "(", "src", ",", "base", ",", "offset", ")", ";", "else", "if", "(", "GET_CODE", "(", "dest", ")", "==", "MEM", "&&", "(", "REG_P", "(", "src", ")", "||", "src", "==", "const0_rtx", ")", ")", "{", "fusion", "=", "SCHED_FUSION_ST", ";", "extract_base_offset_in_addr", "(", "dest", ",", "base", ",", "offset", ")", ";", "}", "else", "return", "SCHED_FUSION_NONE", ";", "if", "(", "*", "base", "==", "NULL_RTX", "||", "*", "offset", "==", "NULL_RTX", ")", "fusion", "=", "SCHED_FUSION_NONE", ";", "return", "fusion", ";", "}", "</s>" ]

[ "If", "INSN", "is", "a", "load", "or", "store", "of", "address", "in", "the", "form", "of", "[", "base+offset", "]", ",", "extract", "the", "two", "parts", "and", "set", "to", "BASE", "and", "OFFSET", ".", "IS_LOAD", "is", "set", "to", "TRUE", "if", "it", "'s", "a", "load", ".", "Return", "TRUE", "if", "INSN", "is", "such", "an", "instruction", ",", "otherwise", "return", "FALSE", "." ]

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

[]

[ "<s>", "static", "bool", "ia64_expand_vecint_compare", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "dest", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "bool", "negate", "=", "false", ";", "rtx", "x", ";", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "GT", ":", "case", "GTU", ":", "break", ";", "case", "NE", ":", "case", "LE", ":", "case", "LEU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "negate", "=", "true", ";", "break", ";", "case", "GE", ":", "case", "GEU", ":", "code", "=", "reverse_condition", "(", "code", ")", ";", "negate", "=", "true", ";", "case", "LT", ":", "case", "LTU", ":", "code", "=", "swap_condition", "(", "code", ")", ";", "x", "=", "op0", ",", "op0", "=", "op1", ",", "op1", "=", "x", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "code", "==", "GTU", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_V2SImode", ":", "{", "rtx", "t1", ",", "t2", ",", "mask", ";", "mask", "=", "gen_int_mode", "(", "0x80000000", ",", "SImode", ")", ";", "mask", "=", "gen_const_vec_duplicate", "(", "V2SImode", ",", "mask", ")", ";", "mask", "=", "force_reg", "(", "mode", ",", "mask", ")", ";", "t1", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_subv2si3", "(", "t1", ",", "op0", ",", "mask", ")", ")", ";", "t2", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_subv2si3", "(", "t2", ",", "op1", ",", "mask", ")", ")", ";", "op0", "=", "t1", ";", "op1", "=", "t2", ";", "code", "=", "GT", ";", "}", "break", ";", "case", "E_V8QImode", ":", "case", "E_V4HImode", ":", "x", "=", "gen_reg_rtx", "(", "mode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "x", ",", "gen_rtx_US_MINUS", "(", "mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "code", "=", "EQ", ";", "op0", "=", "x", ";", "op1", "=", "CONST0_RTX", "(", "mode", ")", ";", "negate", "=", "!", "negate", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "dest", ",", "x", ")", ")", ";", "return", "negate", ";", "}", "</s>" ]

[ "Generate", "an", "integral", "vector", "comparison", ".", "Return", "true", "if", "the", "condition", "has", "been", "reversed", ",", "and", "so", "the", "sense", "of", "the", "comparison", "should", "be", "inverted", "." ]

[ "ia64", "0x80000000" ]

[]

[ "<s>", "bool", "sparc_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "TARGET_HAVE_TLS", ")", "return", "false", ";", "return", "for_each_rtx", "(", "&", "x", ",", "&", "sparc_tls_symbol_ref_1", ",", "0", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "X", "contains", "a", "thread-local", "symbol", "." ]

[ "sparc", "0" ]

[]

[ "<s>", "void", "LanaiAsmBackend", "::", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", ",", "const", "MCSubtargetInfo", "*", ")", "const", "{", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "Value", "=", "adjustFixupValue", "(", "static_cast", "<", "unsigned", ">", "(", "Kind", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "(", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", "+", "7", ")", "/", "8", ";", "unsigned", "FullSize", "=", "4", ";", "uint64_t", "CurVal", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "CurVal", "|=", "static_cast", "<", "uint64_t", ">", "(", "static_cast", "<", "uint8_t", ">", "(", "Data", "[", "Offset", "+", "Idx", "]", ")", ")", "<<", "(", "i", "*", "8", ")", ";", "}", "uint64_t", "Mask", "=", "(", "static_cast", "<", "uint64_t", ">", "(", "-", "1", ")", ">>", "(", "64", "-", "getFixupKindInfo", "(", "Kind", ")", ".", "TargetSize", ")", ")", ";", "CurVal", "|=", "Value", "&", "Mask", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "(", "FullSize", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "Idx", "]", "=", "static_cast", "<", "uint8_t", ">", "(", "(", "CurVal", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "emit_fusion_p9_store", "(", "rtx", "mem", ",", "rtx", "reg", ",", "rtx", "tmp_reg", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "reg", ")", ";", "rtx", "hi", ";", "rtx", "lo", ";", "rtx", "addr", ";", "const", "char", "*", "store_string", ";", "int", "r", ";", "if", "(", "GET_CODE", "(", "reg", ")", "==", "SUBREG", ")", "{", "gcc_assert", "(", "SUBREG_BYTE", "(", "reg", ")", "==", "0", ")", ";", "reg", "=", "SUBREG_REG", "(", "reg", ")", ";", "}", "if", "(", "!", "REG_P", "(", "reg", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #1\"", ",", "reg", ")", ";", "r", "=", "REGNO", "(", "reg", ")", ";", "if", "(", "FP_REGNO_P", "(", "r", ")", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stfs\"", ";", "else", "if", "(", "mode", "==", "DFmode", ")", "store_string", "=", "\"stfd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "ALTIVEC_REGNO_P", "(", "r", ")", "&&", "TARGET_P9_DFORM_SCALAR", ")", "{", "if", "(", "mode", "==", "SFmode", ")", "store_string", "=", "\"stxssp\"", ";", "else", "if", "(", "mode", "==", "DFmode", "||", "mode", "==", "DImode", ")", "store_string", "=", "\"stxsd\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "if", "(", "INT_REGNO_P", "(", "r", ")", ")", "{", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "store_string", "=", "\"stb\"", ";", "break", ";", "case", "HImode", ":", "store_string", "=", "\"sth\"", ";", "break", ";", "case", "SImode", ":", "case", "SFmode", ":", "store_string", "=", "\"stw\"", ";", "break", ";", "case", "DImode", ":", "case", "DFmode", ":", "if", "(", "!", "TARGET_POWERPC64", ")", "gcc_unreachable", "(", ")", ";", "store_string", "=", "\"std\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "else", "fatal_insn", "(", "\"emit_fusion_p9_store, bad reg #2\"", ",", "reg", ")", ";", "if", "(", "!", "MEM_P", "(", "mem", ")", ")", "fatal_insn", "(", "\"emit_fusion_p9_store not MEM\"", ",", "mem", ")", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "fusion_split_address", "(", "addr", ",", "&", "hi", ",", "&", "lo", ")", ";", "emit_fusion_addis", "(", "tmp_reg", ",", "hi", ",", "\"power9 store fusion\"", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "emit_fusion_load_store", "(", "reg", ",", "tmp_reg", ",", "lo", ",", "store_string", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Return", "a", "string", "to", "fuse", "an", "addis", "instruction", "with", "a", "store", "using", "extended", "fusion", ".", "The", "address", "that", "is", "used", "is", "the", "logical", "address", "that", "was", "formed", "during", "peephole2", ":", "(", "lo_sum", "(", "high", ")", "(", "low-part", ")", ")", "The", "code", "is", "complicated", ",", "so", "we", "call", "output_asm_insn", "directly", ",", "and", "just", "return", "``", "''", "." ]

[ "rs6000", "0", "\"emit_fusion_p9_store, bad reg #1\"", "\"stfs\"", "\"stfd\"", "\"stxssp\"", "\"stxsd\"", "\"stb\"", "\"sth\"", "\"stw\"", "\"std\"", "\"emit_fusion_p9_store, bad reg #2\"", "\"emit_fusion_p9_store not MEM\"", "0", "\"power9 store fusion\"", "\"\"" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i8", ";", "if", "(", "Subtarget", ".", "hasAVX512", "(", ")", ")", "{", "EVT", "LegalVT", "=", "VT", ";", "while", "(", "getTypeAction", "(", "Context", ",", "LegalVT", ")", "!=", "TypeLegal", ")", "LegalVT", "=", "getTypeToTransformTo", "(", "Context", ",", "LegalVT", ")", ";", "if", "(", "LegalVT", ".", "getSimpleVT", "(", ")", ".", "is512BitVector", "(", ")", ")", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "if", "(", "LegalVT", ".", "getSimpleVT", "(", ")", ".", "isVector", "(", ")", "&&", "Subtarget", ".", "hasVLX", "(", ")", ")", "{", "MVT", "EltVT", "=", "LegalVT", ".", "getSimpleVT", "(", ")", ".", "getVectorElementType", "(", ")", ";", "if", "(", "Subtarget", ".", "hasBWI", "(", ")", "||", "EltVT", ".", "getSizeInBits", "(", ")", ">=", "32", ")", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "VT", ".", "getVectorElementCount", "(", ")", ")", ";", "}", "}", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "MVT::i8", "MVT::i1", "32", "MVT::i1" ]

[]

[ "<s>", "virtual", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "MBlaze" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LegacyDivergenceAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MemorySSAWrapperPass", ">", "(", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "M68kFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "MutableArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M68kRegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "const", "auto", "&", "Info", ":", "CSI", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "Info", ".", "getFrameIdx", "(", ")", ")", ";", "Register", "Reg", "=", "Info", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "M68k", "::", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M68k", "::", "MOVM32mp", ")", ")", ".", "addImm", "(", "Mask", ")", ",", "FI", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "for", "(", "const", "auto", "&", "Info", ":", "CSI", ")", "{", "I", ".", "addReg", "(", "Info", ".", "getReg", "(", ")", ",", "RegState", "::", "ImplicitDefine", ")", ";", "M68k", "::", "addMemOperand", "(", "I", ",", "Info", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "M68k", "M68k", "M68k", "0", "0", "1", "M68k::addFrameReference", "M68k::MOVM32mp", "M68k::addMemOperand", "0" ]

[]

[ "<s>", "RegisterRef", "PhysicalRegisterInfo", "::", "normalize", "(", "RegisterRef", "RR", ")", "const", "{", "if", "(", "PhysicalRegisterInfo", "::", "isRegMaskId", "(", "RR", ".", "Reg", ")", ")", "return", "RR", ";", "RegisterId", "SuperReg", "=", "RegInfos", "[", "RR", ".", "Reg", "]", ".", "MaxSuper", ";", "if", "(", "RR", ".", "Reg", "==", "SuperReg", ")", "return", "RR", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RegInfos", "[", "RR", ".", "Reg", "]", ".", "RegClass", ";", "LaneBitmask", "RCMask", "=", "RC", "!=", "nullptr", "?", "RC", "->", "LaneMask", ":", "LaneBitmask", "(", "0x00000001", ")", ";", "LaneBitmask", "Common", "=", "RR", ".", "Mask", "&", "RCMask", ";", "uint32_t", "Sub", "=", "TRI", ".", "getSubRegIndex", "(", "SuperReg", ",", "RR", ".", "Reg", ")", ";", "LaneBitmask", "SuperMask", "=", "TRI", ".", "composeSubRegIndexLaneMask", "(", "Sub", ",", "Common", ")", ";", "assert", "(", "RR", ".", "Mask", ".", "none", "(", ")", "||", "SuperMask", ".", "any", "(", ")", ")", ";", "return", "RegisterRef", "(", "SuperReg", ",", "SuperMask", ")", ";", "}", "</s>" ]

[ "Weight", "normalization", "function", "." ]

[ "Hexagon", "0x00000001" ]

[]

[ "<s>", "static", "enum", "tls_model", "tls_symbolic_operand_type", "(", "rtx", "symbol", ")", "{", "enum", "tls_model", "model", ";", "if", "(", "GET_CODE", "(", "symbol", ")", "!=", "SYMBOL_REF", ")", "return", "TLS_MODEL_NONE", ";", "model", "=", "SYMBOL_REF_TLS_MODEL", "(", "symbol", ")", ";", "if", "(", "model", "==", "TLS_MODEL_LOCAL_EXEC", "&&", "alpha_tls_size", "==", "64", ")", "model", "=", "TLS_MODEL_INITIAL_EXEC", ";", "return", "model", ";", "}", "</s>" ]

[ "Return", "the", "TLS", "model", "to", "use", "for", "SYMBOL", "." ]

[ "alpha", "64" ]

[]

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

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

[ "Hexagon" ]

[]

[ "<s>", "rtx", "extract_mem_rtx", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "body", "=", "PATTERN", "(", "insn", ")", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_LOAD", ":", "case", "TYPE_FLOAD", ":", "if", "(", "MEM_P", "(", "SET_SRC", "(", "body", ")", ")", ")", "return", "SET_SRC", "(", "body", ")", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "body", ")", ")", "==", "UNSPEC", ")", "{", "gcc_assert", "(", "MEM_P", "(", "XVECEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ",", "0", ")", ")", ")", ";", "return", "XVECEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ",", "0", ")", ";", "}", "gcc_assert", "(", "MEM_P", "(", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ")", ")", ";", "return", "XEXP", "(", "SET_SRC", "(", "body", ")", ",", "0", ")", ";", "case", "TYPE_STORE", ":", "case", "TYPE_FSTORE", ":", "if", "(", "MEM_P", "(", "SET_DEST", "(", "body", ")", ")", ")", "return", "SET_DEST", "(", "body", ")", ";", "if", "(", "GET_CODE", "(", "SET_DEST", "(", "body", ")", ")", "==", "UNSPEC", ")", "{", "gcc_assert", "(", "MEM_P", "(", "XVECEXP", "(", "SET_DEST", "(", "body", ")", ",", "0", ",", "0", ")", ")", ")", ";", "return", "XVECEXP", "(", "SET_DEST", "(", "body", ")", ",", "0", ",", "0", ")", ";", "}", "gcc_assert", "(", "MEM_P", "(", "XEXP", "(", "SET_DEST", "(", "body", ")", ",", "0", ")", ")", ")", ";", "return", "XEXP", "(", "SET_DEST", "(", "body", ")", ",", "0", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Extract", "the", "MEM", "rtx", "from", "a", "load/store", "insn", "." ]

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

[]

[ "<s>", "static", "tree", "msp430_attr", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "if", "(", "args", "!=", "NULL", ")", "{", "gcc_assert", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "switch", "(", "TREE_CODE", "(", "value", ")", ")", "{", "case", "STRING_CST", ":", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"reset\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"nmi\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"watchdog\"", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"unrecognized interrupt vector argument of %qE attribute\"", ",", "name", ")", ";", "break", ";", "case", "INTEGER_CST", ":", "if", "(", "wi", "::", "gtu_p", "(", "value", ",", "63", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"numeric argument of %qE attribute must be in range 0..63\"", ",", "name", ")", ";", "break", ";", "default", ":", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant or number\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "break", ";", "}", "}", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "message", "=", "\"%qE attribute only applies to functions\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "&&", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "message", "=", "\"interrupt handlers must be void\"", ";", "if", "(", "!", "TREE_PUBLIC", "(", "*", "node", ")", ")", "message", "=", "\"interrupt handlers cannot be static\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_REENT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be reentrant\"", ";", "else", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be reentrant\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_CRIT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be critical\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be critical\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_NAKED", ")", ")", "{", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be naked\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be naked\"", ";", "}", "if", "(", "message", ")", "{", "warning", "(", "OPT_Wattributes", ",", "message", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Verify", "MSP430", "specific", "attributes", "." ]

[ "msp430", "\"reset\"", "\"nmi\"", "\"watchdog\"", "\"unrecognized interrupt vector argument of %qE attribute\"", "63", "\"numeric argument of %qE attribute must be in range 0..63\"", "\"argument of %qE attribute is not a string constant or number\"", "\"%qE attribute only applies to functions\"", "\"interrupt handlers must be void\"", "\"interrupt handlers cannot be static\"", "\"naked functions cannot be reentrant\"", "\"critical functions cannot be reentrant\"", "\"naked functions cannot be critical\"", "\"reentrant functions cannot be critical\"", "\"critical functions cannot be naked\"", "\"reentrant functions cannot be naked\"" ]

[]

[ "<s>", "int", "arc_initial_elimination_offset", "(", "int", "from", ",", "int", "to", ")", "{", "if", "(", "!", "cfun", "->", "machine", "->", "frame_info", ".", "initialized", ")", "arc_compute_frame_size", "(", ")", ";", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "FRAME_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ";", "}", "if", "(", "from", "==", "ARG_POINTER_REGNUM", "&&", "to", "==", "STACK_POINTER_REGNUM", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", ")", ";", "}", "if", "(", "(", "from", "==", "FRAME_POINTER_REGNUM", ")", "&&", "(", "to", "==", "STACK_POINTER_REGNUM", ")", ")", "{", "return", "(", "cfun", "->", "machine", "->", "frame_info", ".", "total_size", "-", "(", "cfun", "->", "machine", "->", "frame_info", ".", "pretend_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "extra_size", "+", "cfun", "->", "machine", "->", "frame_info", ".", "reg_size", ")", ")", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Define", "the", "offset", "between", "two", "registers", ",", "one", "to", "be", "eliminated", ",", "and", "the", "other", "its", "replacement", ",", "at", "the", "start", "of", "a", "routine", "." ]

[ "arc" ]

[]

[ "<s>", "void", "AArch64AsmPrinter", "::", "emitJumpTableInfo", "(", ")", "{", "const", "MachineJumpTableInfo", "*", "MJTI", "=", "MF", "->", "getJumpTableInfo", "(", ")", ";", "if", "(", "!", "MJTI", ")", "return", ";", "const", "std", "::", "vector", "<", "MachineJumpTableEntry", ">", "&", "JT", "=", "MJTI", "->", "getJumpTables", "(", ")", ";", "if", "(", "JT", ".", "empty", "(", ")", ")", "return", ";", "const", "Function", "&", "F", "=", "MF", "->", "getFunction", "(", ")", ";", "const", "TargetLoweringObjectFile", "&", "TLOF", "=", "getObjFileLowering", "(", ")", ";", "bool", "JTInDiffSection", "=", "!", "STI", "->", "isTargetCOFF", "(", ")", "||", "!", "TLOF", ".", "shouldPutJumpTableInFunctionSection", "(", "MJTI", "->", "getEntryKind", "(", ")", "==", "MachineJumpTableInfo", "::", "EK_LabelDifference32", ",", "F", ")", ";", "if", "(", "JTInDiffSection", ")", "{", "MCSection", "*", "ReadOnlySec", "=", "TLOF", ".", "getSectionForJumpTable", "(", "F", ",", "TM", ")", ";", "OutStreamer", "->", "SwitchSection", "(", "ReadOnlySec", ")", ";", "}", "auto", "AFI", "=", "MF", "->", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "for", "(", "unsigned", "JTI", "=", "0", ",", "e", "=", "JT", ".", "size", "(", ")", ";", "JTI", "!=", "e", ";", "++", "JTI", ")", "{", "const", "std", "::", "vector", "<", "MachineBasicBlock", "*", ">", "&", "JTBBs", "=", "JT", "[", "JTI", "]", ".", "MBBs", ";", "if", "(", "JTBBs", ".", "empty", "(", ")", ")", "continue", ";", "unsigned", "Size", "=", "AFI", "->", "getJumpTableEntrySize", "(", "JTI", ")", ";", "emitAlignment", "(", "Align", "(", "Size", ")", ")", ";", "OutStreamer", "->", "emitLabel", "(", "GetJTISymbol", "(", "JTI", ")", ")", ";", "for", "(", "auto", "*", "JTBB", ":", "JTBBs", ")", "emitJumpTableEntry", "(", "MJTI", ",", "JTBB", ",", "JTI", ")", ";", "}", "}", "</s>" ]

[ "Print", "assembly", "representations", "of", "the", "jump", "tables", "used", "by", "the", "current", "function", "to", "the", "current", "output", "stream", "." ]

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

[]

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

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

[ "XCore", "XCore" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "getGlobalBaseReg", "(", ")", "==", "0", ")", "return", "false", ";", "const", "ARMSubtarget", "&", "STI", "=", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "MF", ".", "getSubtarget", "(", ")", ")", ";", "if", "(", "STI", ".", "isThumb1Only", "(", ")", ")", "return", "false", ";", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "PIC_", ")", "return", "false", ";", "LLVMContext", "*", "Context", "=", "&", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ";", "unsigned", "ARMPCLabelIndex", "=", "AFI", "->", "createPICLabelUId", "(", ")", ";", "unsigned", "PCAdj", "=", "STI", ".", "isThumb", "(", ")", "?", "4", ":", "8", ";", "ARMConstantPoolValue", "*", "CPV", "=", "ARMConstantPoolSymbol", "::", "Create", "(", "*", "Context", ",", "\"_GLOBAL_OFFSET_TABLE_\"", ",", "ARMPCLabelIndex", ",", "PCAdj", ")", ";", "unsigned", "Align", "=", "MF", ".", "getDataLayout", "(", ")", ".", "getPrefTypeAlignment", "(", "Type", "::", "getInt32PtrTy", "(", "*", "Context", ")", ")", ";", "unsigned", "Idx", "=", "MF", ".", "getConstantPool", "(", ")", "->", "getConstantPoolIndex", "(", "CPV", ",", "Align", ")", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "FirstMBB", ".", "findDebugLoc", "(", "MBBI", ")", ";", "unsigned", "TempReg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "&", "ARM", "::", "rGPRRegClass", ")", ";", "unsigned", "Opc", "=", "STI", ".", "isThumb2", "(", ")", "?", "ARM", "::", "t2LDRpci", ":", "ARM", "::", "LDRcp", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "TempReg", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "LDRcp", ")", "MIB", ".", "addImm", "(", "0", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "unsigned", "GlobalBaseReg", "=", "AFI", "->", "getGlobalBaseReg", "(", ")", ";", "Opc", "=", "STI", ".", "isThumb2", "(", ")", "?", "ARM", "::", "tPICADD", ":", "ARM", "::", "PICADD", ";", "MIB", "=", "BuildMI", "(", "FirstMBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ",", "GlobalBaseReg", ")", ".", "addReg", "(", "TempReg", ")", ".", "addImm", "(", "ARMPCLabelIndex", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "PICADD", ")", "AddDefaultPred", "(", "MIB", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "0", "ARM", "ARM", "ARM", "4", "8", "ARM", "ARM", "\"_GLOBAL_OFFSET_TABLE_\"", "ARM", "ARM::rGPRRegClass", "ARM::t2LDRpci", "ARM::LDRcp", "ARM::LDRcp", "0", "ARM::tPICADD", "ARM::PICADD", "ARM", "ARM::PICADD" ]

[]

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

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

[ "MMIX", "MMIX::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "NVPTXFavorNonGenericAddrSpaces", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "DisableFavorNonGeneric", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "for", "(", "Function", "::", "iterator", "B", "=", "F", ".", "begin", "(", ")", ",", "BE", "=", "F", ".", "end", "(", ")", ";", "B", "!=", "BE", ";", "++", "B", ")", "{", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "B", "->", "begin", "(", ")", ",", "IE", "=", "B", "->", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "{", "if", "(", "isa", "<", "LoadInst", ">", "(", "I", ")", ")", "{", "Changed", "|=", "optimizeMemoryInstruction", "(", "I", ",", "0", ")", ";", "}", "else", "if", "(", "isa", "<", "StoreInst", ">", "(", "I", ")", ")", "{", "Changed", "|=", "optimizeMemoryInstruction", "(", "I", ",", "1", ")", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "NVPTX", "NVPTX", "0", "1" ]

[]

[ "<s>", "bool", "SPIRVEmitIntrinsics", "::", "runOnFunction", "(", "Function", "&", "Func", ")", "{", "if", "(", "Func", ".", "isDeclaration", "(", ")", ")", "return", "false", ";", "F", "=", "&", "Func", ";", "IRB", "=", "new", "IRBuilder", "<", ">", "(", "Func", ".", "getContext", "(", ")", ")", ";", "AggrConsts", ".", "clear", "(", ")", ";", "AggrStores", ".", "clear", "(", ")", ";", "for", "(", "auto", "&", "I", ":", "instructions", "(", "Func", ")", ")", "{", "StoreInst", "*", "SI", "=", "dyn_cast", "<", "StoreInst", ">", "(", "&", "I", ")", ";", "if", "(", "!", "SI", ")", "continue", ";", "Type", "*", "ElTy", "=", "SI", "->", "getValueOperand", "(", ")", "->", "getType", "(", ")", ";", "PointerType", "*", "PTy", "=", "cast", "<", "PointerType", ">", "(", "SI", "->", "getOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "if", "(", "ElTy", "->", "isAggregateType", "(", ")", "||", "ElTy", "->", "isVectorTy", "(", ")", "||", "!", "PTy", "->", "isOpaqueOrPointeeTypeMatches", "(", "ElTy", ")", ")", "AggrStores", ".", "insert", "(", "&", "I", ")", ";", "}", "IRB", "->", "SetInsertPoint", "(", "&", "Func", ".", "getEntryBlock", "(", ")", ".", "front", "(", ")", ")", ";", "for", "(", "auto", "&", "GV", ":", "Func", ".", "getParent", "(", ")", "->", "globals", "(", ")", ")", "processGlobalValue", "(", "GV", ")", ";", "preprocessCompositeConstants", "(", ")", ";", "SmallVector", "<", "Instruction", "*", ">", "Worklist", ";", "for", "(", "auto", "&", "I", ":", "instructions", "(", "Func", ")", ")", "Worklist", ".", "push_back", "(", "&", "I", ")", ";", "for", "(", "auto", "&", "I", ":", "Worklist", ")", "insertAssignTypeIntrs", "(", "I", ")", ";", "for", "(", "auto", "*", "I", ":", "Worklist", ")", "{", "TrackConstants", "=", "true", ";", "if", "(", "!", "I", "->", "getType", "(", ")", "->", "isVoidTy", "(", ")", "||", "isa", "<", "StoreInst", ">", "(", "I", ")", ")", "IRB", "->", "SetInsertPoint", "(", "I", "->", "getNextNode", "(", ")", ")", ";", "I", "=", "visit", "(", "*", "I", ")", ";", "processInstrAfterVisit", "(", "I", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SPIRV", "SPIRV", "1" ]

[]

[ "<s>", "bool", "AArch64A53Fix835769", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64A53Fix835769 *****\\n\"", ")", ";", "auto", "&", "STI", "=", "F", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "fixCortexA53_835769", "(", ")", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "F", ")", "{", "Changed", "|=", "runOnBasicBlock", "(", "MBB", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"***** AArch64A53Fix835769 *****\\n\"", "AArch64" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "FIXUPLEA_DESC", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "static", "struct", "machine_function", "*", "msp430_init_machine_status", "(", "void", ")", "{", "struct", "machine_function", "*", "m", ";", "m", "=", "ggc_cleared_alloc", "<", "machine_function", ">", "(", ")", ";", "return", "m", ";", "}", "</s>" ]

[ "This", "is", "our", "init_machine_status", ",", "as", "set", "in", "msp_option_override", "." ]

[ "msp430" ]

[]

[ "<s>", "TargetTransformInfo", "::", "PopcntSupportKind", "PPCTTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "\"Ty width must be power of 2\"", ")", ";", "if", "(", "ST", "->", "hasPOPCNTD", "(", ")", "!=", "PPCSubtarget", "::", "POPCNTD_Unavailable", "&&", "TyWidth", "<=", "64", ")", "return", "ST", "->", "hasPOPCNTD", "(", ")", "==", "PPCSubtarget", "::", "POPCNTD_Slow", "?", "TTI", "::", "PSK_SlowHardware", ":", "TTI", "::", "PSK_FastHardware", ";", "return", "TTI", "::", "PSK_Software", ";", "}", "</s>" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ "PowerPC", "PPC", "\"Ty width must be power of 2\"", "PPC", "64", "PPC" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "Src", ",", "const", "MachineOperand", "*", "&", "Dest", ")", "const", "{", "if", "(", "MI", ".", "isMoveReg", "(", ")", ")", "{", "Dest", "=", "&", "MI", ".", "getOperand", "(", "0", ")", ";", "Src", "=", "&", "MI", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

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

[]

[ "<s>", "static", "int", "ix86_vec_cost", "(", "machine_mode", "mode", ",", "int", "cost", ")", "{", "if", "(", "!", "VECTOR_MODE_P", "(", "mode", ")", ")", "return", "cost", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "128", "&&", "TARGET_SSE_SPLIT_REGS", ")", "return", "cost", "*", "2", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", ">", "128", "&&", "TARGET_AVX128_OPTIMAL", ")", "return", "cost", "*", "GET_MODE_BITSIZE", "(", "mode", ")", "/", "128", ";", "return", "cost", ";", "}", "</s>" ]

[ "Return", "cost", "of", "vector", "operation", "in", "MODE", "given", "that", "scalar", "version", "has", "COST", ".", "If", "PARALLEL", "is", "true", "assume", "that", "CPU", "has", "more", "than", "one", "unit", "performing", "the", "operation", "." ]

[ "i386", "128", "2", "128", "128" ]

[]

[ "<s>", "static", "unsigned", "int", "arc_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "==", "16", "&&", "regno", ">=", "ARC_FIRST_SIMD_VR_REG", "&&", "regno", "<=", "ARC_LAST_SIMD_VR_REG", ")", "return", "1", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "arc", "16", "1" ]

[]

[ "<s>", "param_iterator", "arg_end", "(", ")", "const", "{", "return", "ArgumentParams", ".", "end", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "iterator", "pointing", "to", "the", "end", "of", "the", "argument", "list", "." ]

[ "PTX" ]

[]

[ "<s>", "BitVector", "AArch64RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "AArch64FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WSP", ")", ";", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "WZR", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", "||", "TT", ".", "isOSDarwin", "(", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W29", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "AArch64", "::", "GPR32commonRegClass", ".", "getNumRegs", "(", ")", ";", "++", "i", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "isXRegisterReserved", "(", "i", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "GPR32commonRegClass", ".", "getRegister", "(", "i", ")", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W19", ")", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "SpeculativeLoadHardening", ")", ")", "markSuperRegs", "(", "Reserved", ",", "AArch64", "::", "W16", ")", ";", "if", "(", "PACStack", "::", "hasPACStackAttribute", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "PACStack", "::", "CRSub", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64", "AArch64::WSP", "AArch64::WZR", "AArch64::W29", "0", "AArch64::GPR32commonRegClass", "AArch64", "AArch64::GPR32commonRegClass", "AArch64::W19", "AArch64::W16" ]

[]

[ "<s>", "static", "tree", "spu_handle_vector_attribute", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "type", "=", "*", "node", ",", "result", "=", "NULL_TREE", ";", "machine_mode", "mode", ";", "int", "unsigned_p", ";", "while", "(", "POINTER_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "FUNCTION_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "METHOD_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "switch", "(", "mode", ")", "{", "case", "DImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V2DI_type_node", ":", "V2DI_type_node", ")", ";", "break", ";", "case", "SImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V4SI_type_node", ":", "V4SI_type_node", ")", ";", "break", ";", "case", "HImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V8HI_type_node", ":", "V8HI_type_node", ")", ";", "break", ";", "case", "QImode", ":", "result", "=", "(", "unsigned_p", "?", "unsigned_V16QI_type_node", ":", "V16QI_type_node", ")", ";", "break", ";", "case", "SFmode", ":", "result", "=", "V4SF_type_node", ";", "break", ";", "case", "DFmode", ":", "result", "=", "V2DF_type_node", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "result", "&&", "result", "!=", "type", "&&", "TYPE_QUALS", "(", "type", ")", ")", "result", "=", "build_qualified_type", "(", "result", ",", "TYPE_QUALS", "(", "type", ")", ")", ";", "*", "no_add_attrs", "=", "true", ";", "if", "(", "!", "result", ")", "warning", "(", "0", ",", "\"%qE attribute ignored\"", ",", "name", ")", ";", "else", "*", "node", "=", "lang_hooks", ".", "types", ".", "reconstruct_complex_type", "(", "*", "node", ",", "result", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "the", "``", "vector", "''", "attribute", "." ]

[ "spu", "0", "\"%qE attribute ignored\"" ]

[]

[ "<s>", "static", "void", "emit_v9_brxx_insn", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "label", ")", "{", "emit_jump_insn", "(", "gen_rtx_SET", "(", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "gen_rtx_fmt_ee", "(", "code", ",", "GET_MODE", "(", "op0", ")", ",", "op0", ",", "const0_rtx", ")", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "conditional", "jump", "insn", "for", "the", "v9", "architecture", "using", "comparison", "code", "CODE", "and", "jump", "target", "LABEL", ".", "This", "function", "exists", "to", "take", "advantage", "of", "the", "v9", "brxx", "insns", "." ]

[ "sparc" ]

[]

[ "<s>", "int64_t", "mmix_intval", "(", "const_rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_INT", ")", "return", "INTVAL", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", "&&", "GET_MODE", "(", "x", ")", "==", "VOIDmode", ")", "return", "CONST_DOUBLE_HIGH", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST_DOUBLE", ")", "{", "REAL_VALUE_TYPE", "value", ";", "REAL_VALUE_FROM_CONST_DOUBLE", "(", "value", ",", "x", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "DFmode", ")", "{", "long", "bits", "[", "2", "]", ";", "REAL_VALUE_TO_TARGET_DOUBLE", "(", "value", ",", "bits", ")", ";", "return", "(", "(", "uint64_t", ")", "(", "unsigned", "long", ")", "bits", "[", "0", "]", "<<", "(", "uint64_t", ")", "32U", ")", "|", "(", "uint64_t", ")", "(", "unsigned", "long", ")", "bits", "[", "1", "]", ";", "}", "else", "if", "(", "GET_MODE", "(", "x", ")", "==", "SFmode", ")", "{", "long", "bits", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "value", ",", "bits", ")", ";", "return", "(", "unsigned", "long", ")", "bits", ";", "}", "}", "fatal_insn", "(", "\"MMIX Internal: This is not a constant:\"", ",", "x", ")", ";", "}", "</s>" ]

[ "Return", "the", "bit-value", "for", "a", "const_int", "or", "const_double", "." ]

[ "mmix", "2", "0", "32U", "1", "\"MMIX Internal: This is not a constant:\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "MipsInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "uint64_t", "Address", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ",", "raw_ostream", "&", "O", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Mips", "::", "RDHWR", ":", "case", "Mips", "::", "RDHWR64", ":", "O", "<<", "\"\\t.set\\tpush\\n\"", ";", "O", "<<", "\"\\t.set\\tmips32r2\\n\"", ";", "break", ";", "case", "Mips", "::", "Save16", ":", "O", "<<", "\"\\tsave\\t\"", ";", "printSaveRestore", "(", "MI", ",", "STI", ",", "O", ")", ";", "O", "<<", "\" # 16 bit inst\\n\"", ";", "return", ";", "case", "Mips", "::", "SaveX16", ":", "O", "<<", "\"\\tsave\\t\"", ";", "printSaveRestore", "(", "MI", ",", "STI", ",", "O", ")", ";", "O", "<<", "\"\\n\"", ";", "return", ";", "case", "Mips", "::", "Restore16", ":", "O", "<<", "\"\\trestore\\t\"", ";", "printSaveRestore", "(", "MI", ",", "STI", ",", "O", ")", ";", "O", "<<", "\" # 16 bit inst\\n\"", ";", "return", ";", "case", "Mips", "::", "RestoreX16", ":", "O", "<<", "\"\\trestore\\t\"", ";", "printSaveRestore", "(", "MI", ",", "STI", ",", "O", ")", ";", "O", "<<", "\"\\n\"", ";", "return", ";", "}", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "Address", ",", "STI", ",", "O", ")", "&&", "!", "printAlias", "(", "*", "MI", ",", "Address", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "Address", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Mips", "::", "RDHWR", ":", "case", "Mips", "::", "RDHWR64", ":", "O", "<<", "\"\\n\\t.set\\tpop\"", ";", "}", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips::RDHWR", "Mips::RDHWR64", "\"\\t.set\\tpush\\n\"", "\"\\t.set\\tmips32r2\\n\"", "Mips::Save16", "\"\\tsave\\t\"", "\" # 16 bit inst\\n\"", "Mips::SaveX16", "\"\\tsave\\t\"", "\"\\n\"", "Mips::Restore16", "\"\\trestore\\t\"", "\" # 16 bit inst\\n\"", "Mips::RestoreX16", "\"\\trestore\\t\"", "\"\\n\"", "Mips::RDHWR", "Mips::RDHWR64", "\"\\n\\t.set\\tpop\"" ]

[]

[ "<s>", "void", "AMDGPUAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "{", "switch", "(", "(", "unsigned", ")", "Fixup", ".", "getKind", "(", ")", ")", "{", "case", "AMDGPU", "::", "fixup_si_sopp_br", ":", "{", "uint16_t", "*", "Dst", "=", "(", "uint16_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "(", "Value", "-", "4", ")", "/", "4", ";", "break", ";", "}", "case", "AMDGPU", "::", "fixup_si_rodata", ":", "{", "uint32_t", "*", "Dst", "=", "(", "uint32_t", "*", ")", "(", "Data", "+", "Fixup", ".", "getOffset", "(", ")", ")", ";", "*", "Dst", "=", "Value", "+", "4", ";", "break", ";", "}", "default", ":", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "MCFixupKindInfo", "Info", "=", "getFixupKindInfo", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "<<=", "Info", ".", "TargetOffset", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::fixup_si_sopp_br", "4", "4", "AMDGPU::fixup_si_rodata", "4", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "const", "char", "*", "MSP430TargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "(", "MSP430ISD", "::", "NodeType", ")", "Opcode", ")", "{", "case", "MSP430ISD", "::", "FIRST_NUMBER", ":", "break", ";", "case", "MSP430ISD", "::", "RET_FLAG", ":", "return", "\"MSP430ISD::RET_FLAG\"", ";", "case", "MSP430ISD", "::", "RETI_FLAG", ":", "return", "\"MSP430ISD::RETI_FLAG\"", ";", "case", "MSP430ISD", "::", "RRA", ":", "return", "\"MSP430ISD::RRA\"", ";", "case", "MSP430ISD", "::", "RLA", ":", "return", "\"MSP430ISD::RLA\"", ";", "case", "MSP430ISD", "::", "RRC", ":", "return", "\"MSP430ISD::RRC\"", ";", "case", "MSP430ISD", "::", "RRCL", ":", "return", "\"MSP430ISD::RRCL\"", ";", "case", "MSP430ISD", "::", "CALL", ":", "return", "\"MSP430ISD::CALL\"", ";", "case", "MSP430ISD", "::", "Wrapper", ":", "return", "\"MSP430ISD::Wrapper\"", ";", "case", "MSP430ISD", "::", "BR_CC", ":", "return", "\"MSP430ISD::BR_CC\"", ";", "case", "MSP430ISD", "::", "CMP", ":", "return", "\"MSP430ISD::CMP\"", ";", "case", "MSP430ISD", "::", "SETCC", ":", "return", "\"MSP430ISD::SETCC\"", ";", "case", "MSP430ISD", "::", "SELECT_CC", ":", "return", "\"MSP430ISD::SELECT_CC\"", ";", "case", "MSP430ISD", "::", "DADD", ":", "return", "\"MSP430ISD::DADD\"", ";", "case", "MSP430ISD", "::", "RRAM", ":", "return", "\"MSP430ISD::RRAM\"", ";", "case", "MSP430ISD", "::", "RRUM", ":", "return", "\"MSP430ISD::RRUM\"", ";", "case", "MSP430ISD", "::", "RLAM", ":", "return", "\"MSP430ISD::RLAM\"", ";", "case", "MSP430ISD", "::", "RRAX", ":", "return", "\"MSP430ISD::RRAX\"", ";", "case", "MSP430ISD", "::", "RLAX", ":", "return", "\"MSP430ISD::RLAX\"", ";", "case", "MSP430ISD", "::", "RRUX", ":", "return", "\"MSP430ISD::RRUX\"", ";", "}", "return", "nullptr", ";", "}", "</s>" ]

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

[ "MSP430", "MSP430", "MSP430ISD::NodeType", "MSP430ISD::FIRST_NUMBER", "MSP430ISD::RET_FLAG", "\"MSP430ISD::RET_FLAG\"", "MSP430ISD::RETI_FLAG", "\"MSP430ISD::RETI_FLAG\"", "MSP430ISD::RRA", "\"MSP430ISD::RRA\"", "MSP430ISD::RLA", "\"MSP430ISD::RLA\"", "MSP430ISD::RRC", "\"MSP430ISD::RRC\"", "MSP430ISD::RRCL", "\"MSP430ISD::RRCL\"", "MSP430ISD::CALL", "\"MSP430ISD::CALL\"", "MSP430ISD::Wrapper", "\"MSP430ISD::Wrapper\"", "MSP430ISD::BR_CC", "\"MSP430ISD::BR_CC\"", "MSP430ISD::CMP", "\"MSP430ISD::CMP\"", "MSP430ISD::SETCC", "\"MSP430ISD::SETCC\"", "MSP430ISD::SELECT_CC", "\"MSP430ISD::SELECT_CC\"", "MSP430ISD::DADD", "\"MSP430ISD::DADD\"", "MSP430ISD::RRAM", "\"MSP430ISD::RRAM\"", "MSP430ISD::RRUM", "\"MSP430ISD::RRUM\"", "MSP430ISD::RLAM", "\"MSP430ISD::RLAM\"", "MSP430ISD::RRAX", "\"MSP430ISD::RRAX\"", "MSP430ISD::RLAX", "\"MSP430ISD::RLAX\"", "MSP430ISD::RRUX", "\"MSP430ISD::RRUX\"" ]

[]

[ "<s>", "unsigned", "AMDGPURegisterBankInfo", "::", "copyCost", "(", "const", "RegisterBank", "&", "Dst", ",", "const", "RegisterBank", "&", "Src", ",", "unsigned", "Size", ")", "const", "{", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "&&", "isVectorRegisterBank", "(", "Src", ")", ")", "{", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "}", "if", "(", "Size", "==", "1", "&&", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", ")", "&&", "(", "isVectorRegisterBank", "(", "Src", ")", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "SGPRRegBankID", "||", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "VCCRegBankID", ")", "return", "std", "::", "numeric_limits", "<", "unsigned", ">", "::", "max", "(", ")", ";", "if", "(", "Dst", ".", "getID", "(", ")", "==", "AMDGPU", "::", "AGPRRegBankID", "&&", "Src", ".", "getID", "(", ")", "==", "AMDGPU", "::", "AGPRRegBankID", ")", "return", "4", ";", "return", "RegisterBankInfo", "::", "copyCost", "(", "Dst", ",", "Src", ",", "Size", ")", ";", "}", "</s>" ]

[ "Get", "the", "cost", "of", "a", "copy", "from", "B", "to", "A", ",", "or", "put", "differently", ",", "get", "the", "cost", "of", "A", "=", "COPY", "B", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::SGPRRegBankID", "1", "AMDGPU::SGPRRegBankID", "AMDGPU::SGPRRegBankID", "AMDGPU::VCCRegBankID", "AMDGPU::VCCRegBankID", "AMDGPU::AGPRRegBankID", "AMDGPU::AGPRRegBankID", "4" ]

[]

[ "<s>", "bool", "PPCCTRLoopsVerify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "I", "=", "MF", ".", "begin", "(", ")", ",", "IE", "=", "MF", ".", "end", "(", ")", ";", "I", "!=", "IE", ";", "++", "I", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "I", ";", "if", "(", "!", "MDT", "->", "isReachableFromEntry", "(", "MBB", ")", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MBB", "->", "getFirstTerminator", "(", ")", ",", "MIIE", "=", "MBB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "unsigned", "Opc", "=", "MII", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "PPC", "::", "BDNZ8", "||", "Opc", "==", "PPC", "::", "BDNZ", "||", "Opc", "==", "PPC", "::", "BDZ8", "||", "Opc", "==", "PPC", "::", "BDZ", ")", "if", "(", "!", "verifyCTRBranch", "(", "MBB", ",", "MII", ")", ")", "llvm_unreachable", "(", "\"Invalid PPC CTR loop!\"", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::BDNZ8", "PPC::BDNZ", "PPC::BDZ8", "PPC::BDZ", "\"Invalid PPC CTR loop!\"" ]

[]

[ "<s>", "bool", "WebAssemblyTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", "Fast", ")", "const", "{", "if", "(", "Fast", ")", "*", "Fast", "=", "true", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreSched2", "(", ")", "{", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "bool", "WebAssemblyCFGStackify", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "MCAsmInfo", "*", "MCAI", "=", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", ";", "releaseMemory", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "placeMarkers", "(", "MF", ")", ";", "if", "(", "MCAI", "->", "getExceptionHandlingType", "(", ")", "==", "ExceptionHandling", "::", "Wasm", "&&", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "removeUnnecessaryInstrs", "(", "MF", ")", ";", "rewriteDepthImmediates", "(", "MF", ")", ";", "fixEndsAtEndOfFunction", "(", "MF", ")", ";", "const", "auto", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "!", "MF", ".", "getSubtarget", "<", "WebAssemblySubtarget", ">", "(", ")", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "appendEndToFunction", "(", "MF", ",", "TII", ")", ";", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", "->", "setCFGStackified", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Stackifying **********\\n\"", "\"********** Function: \"", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createMVETPAndVPTOptimisationsPass", "(", ")", ")", ";", "addPass", "(", "createMLxExpansionPass", "(", ")", ")", ";", "if", "(", "EnableARMLoadStoreOpt", ")", "addPass", "(", "createARMLoadStoreOptimizationPass", "(", "true", ")", ")", ";", "if", "(", "!", "DisableA15SDOptimization", ")", "addPass", "(", "createA15SDOptimizerPass", "(", ")", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "PPC", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_ppc_br24\"", ",", "6", ",", "24", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_brcond14\"", ",", "16", ",", "14", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_ppc_lo16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_ha16\"", ",", "16", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ppc_lo14\"", ",", "16", ",", "14", ",", "0", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC::NumTargetFixupKinds", "\"fixup_ppc_br24\"", "6", "24", "\"fixup_ppc_brcond14\"", "16", "14", "\"fixup_ppc_lo16\"", "16", "16", "0", "\"fixup_ppc_ha16\"", "16", "16", "0", "\"fixup_ppc_lo14\"", "16", "14", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "static", "bool", "s390_scalar_mode_supported_p", "(", "scalar_mode", "mode", ")", "{", "if", "(", "!", "TARGET_64BIT", "&&", "TARGET_ZARCH", "&&", "mode", "==", "TImode", ")", "return", "false", ";", "if", "(", "DECIMAL_FLOAT_MODE_P", "(", "mode", ")", ")", "return", "default_decimal_float_supported_p", "(", ")", ";", "return", "default_scalar_mode_supported_p", "(", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "back", "end", "supports", "mode", "MODE", "." ]

[ "s390" ]

[]

[ "<s>", "void", "function_builder", "::", "add_unique_function", "(", "const", "function_instance", "&", "instance", ",", "tree", "return_type", ",", "vec", "<", "tree", ">", "&", "argument_types", ",", "aarch64_feature_flags", "required_extensions", ",", "bool", "force_direct_overloads", ")", "{", "char", "*", "name", "=", "get_name", "(", "instance", ",", "false", ")", ";", "tree", "fntype", "=", "build_function_type_array", "(", "return_type", ",", "argument_types", ".", "length", "(", ")", ",", "argument_types", ".", "address", "(", ")", ")", ";", "tree", "attrs", "=", "get_attributes", "(", "instance", ")", ";", "registered_function", "&", "rfn", "=", "add_function", "(", "instance", ",", "name", ",", "fntype", ",", "attrs", ",", "required_extensions", ",", "false", ",", "false", ")", ";", "hashval_t", "hash", "=", "instance", ".", "hash", "(", ")", ";", "registered_function", "*", "*", "rfn_slot", "=", "function_table", "->", "find_slot_with_hash", "(", "instance", ",", "hash", ",", "INSERT", ")", ";", "gcc_assert", "(", "!", "*", "rfn_slot", ")", ";", "*", "rfn_slot", "=", "&", "rfn", ";", "char", "*", "overload_name", "=", "get_name", "(", "instance", ",", "true", ")", ";", "if", "(", "strcmp", "(", "name", ",", "overload_name", ")", "!=", "0", ")", "{", "tree", "attrs", "=", "get_attributes", "(", "instance", ")", ";", "bool", "placeholder_p", "=", "!", "(", "m_direct_overloads", "||", "force_direct_overloads", ")", ";", "add_function", "(", "instance", ",", "overload_name", ",", "fntype", ",", "attrs", ",", "required_extensions", ",", "false", ",", "placeholder_p", ")", ";", "}", "obstack_free", "(", "&", "m_string_obstack", ",", "name", ")", ";", "}", "</s>" ]

[ "Add", "a", "built-in", "function", "for", "INSTANCE", ",", "with", "the", "argument", "types", "given", "by", "ARGUMENT_TYPES", "and", "the", "return", "type", "given", "by", "RETURN_TYPE", ".", "NAME", "is", "the", "``", "full", "''", "name", "for", "C", "function", ".", "OVERLOAD_NAME", "is", "the", "``", "short", "''", "name", "for", "C++", "overloaded", "function", ".", "OVERLOAD_NAME", "can", "be", "nullptr", "because", "some", "instance", "does", "n't", "have", "C++", "overloaded", "function", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "assert", "(", "!", "IsVarArg", "&&", "\"TODO implement var args\"", ")", ";", "assert", "(", "Outs", ".", "empty", "(", ")", "&&", "\"TODO implement return values\"", ")", ";", "assert", "(", "OutVals", ".", "empty", "(", ")", "&&", "\"TODO implement return values\"", ")", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "RetOps", "[", "0", "]", "=", "Chain", ";", "return", "DAG", ".", "getNode", "(", "VEISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "VE", "VE", "ISD::OutputArg", "\"TODO implement var args\"", "\"TODO implement return values\"", "\"TODO implement return values\"", "4", "1", "0", "VEISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "shouldClusterMemOps", "(", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps1", ",", "ArrayRef", "<", "const", "MachineOperand", "*", ">", "BaseOps2", ",", "unsigned", "NumLoads", ")", "const", "{", "assert", "(", "BaseOps1", ".", "size", "(", ")", "==", "1", "&&", "BaseOps2", ".", "size", "(", ")", "==", "1", ")", ";", "const", "MachineOperand", "&", "BaseOp1", "=", "*", "BaseOps1", ".", "front", "(", ")", ";", "const", "MachineOperand", "&", "BaseOp2", "=", "*", "BaseOps2", ".", "front", "(", ")", ";", "const", "MachineInstr", "&", "FirstLdSt", "=", "*", "BaseOp1", ".", "getParent", "(", ")", ";", "const", "MachineInstr", "&", "SecondLdSt", "=", "*", "BaseOp2", ".", "getParent", "(", ")", ";", "if", "(", "BaseOp1", ".", "getType", "(", ")", "!=", "BaseOp2", ".", "getType", "(", ")", ")", "return", "false", ";", "assert", "(", "(", "BaseOp1", ".", "isReg", "(", ")", "||", "BaseOp1", ".", "isFI", "(", ")", ")", "&&", "\"Only base registers and frame indices are supported.\"", ")", ";", "if", "(", "BaseOp1", ".", "isReg", "(", ")", "&&", "BaseOp1", ".", "getReg", "(", ")", "!=", "BaseOp2", ".", "getReg", "(", ")", ")", "return", "false", ";", "if", "(", "NumLoads", ">", "1", ")", "return", "false", ";", "if", "(", "!", "isPairableLdStInst", "(", "FirstLdSt", ")", "||", "!", "isPairableLdStInst", "(", "SecondLdSt", ")", ")", "return", "false", ";", "unsigned", "FirstOpc", "=", "FirstLdSt", ".", "getOpcode", "(", ")", ";", "unsigned", "SecondOpc", "=", "SecondLdSt", ".", "getOpcode", "(", ")", ";", "if", "(", "!", "canPairLdStOpc", "(", "FirstOpc", ",", "SecondOpc", ")", ")", "return", "false", ";", "if", "(", "!", "isCandidateToMergeOrPair", "(", "FirstLdSt", ")", "||", "!", "isCandidateToMergeOrPair", "(", "SecondLdSt", ")", ")", "return", "false", ";", "int64_t", "Offset1", "=", "FirstLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "FirstOpc", ")", "&&", "!", "scaleOffset", "(", "FirstOpc", ",", "Offset1", ")", ")", "return", "false", ";", "int64_t", "Offset2", "=", "SecondLdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "if", "(", "isUnscaledLdSt", "(", "SecondOpc", ")", "&&", "!", "scaleOffset", "(", "SecondOpc", ",", "Offset2", ")", ")", "return", "false", ";", "if", "(", "Offset1", ">", "63", "||", "Offset1", "<", "-", "64", ")", "return", "false", ";", "if", "(", "BaseOp1", ".", "isFI", "(", ")", ")", "{", "assert", "(", "(", "!", "BaseOp1", ".", "isIdenticalTo", "(", "BaseOp2", ")", "||", "Offset1", "<=", "Offset2", ")", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "FirstLdSt", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFrameInfo", "(", ")", ";", "return", "shouldClusterFI", "(", "MFI", ",", "BaseOp1", ".", "getIndex", "(", ")", ",", "Offset1", ",", "FirstOpc", ",", "BaseOp2", ".", "getIndex", "(", ")", ",", "Offset2", ",", "SecondOpc", ")", ";", "}", "assert", "(", "Offset1", "<=", "Offset2", "&&", "\"Caller should have ordered offsets.\"", ")", ";", "return", "Offset1", "+", "1", "==", "Offset2", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "two", "given", "memory", "operations", "should", "be", "scheduled", "adjacent", "." ]

[ "AArch64", "AArch64", "1", "1", "\"Only base registers and frame indices are supported.\"", "1", "2", "2", "63", "64", "\"Caller should have ordered offsets.\"", "\"Caller should have ordered offsets.\"", "1" ]

[]

[ "<s>", "static", "bool", "aarch64_rtx_costs_wrapper", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "int", "outer", ",", "int", "param", ",", "int", "*", "cost", ",", "bool", "speed", ")", "{", "bool", "result", "=", "aarch64_rtx_costs", "(", "x", ",", "mode", ",", "outer", ",", "param", ",", "cost", ",", "speed", ")", ";", "if", "(", "dump_file", "&&", "flag_aarch64_verbose_cost", ")", "{", "print_rtl_single", "(", "dump_file", ",", "x", ")", ";", "fprintf", "(", "dump_file", ",", "\"\\n%s cost: %d (%s)\\n\"", ",", "speed", "?", "\"Hot\"", ":", "\"Cold\"", ",", "*", "cost", ",", "result", "?", "\"final\"", ":", "\"partial\"", ")", ";", "}", "return", "result", ";", "}", "</s>" ]

[ "Wrapper", "around", "aarch64_rtx_costs", ",", "dumps", "the", "partial", ",", "or", "total", "cost", "calculated", "for", "X", ".", "This", "cost", "is", "stored", "in", "*", "COST", ".", "Returns", "true", "if", "the", "total", "cost", "of", "X", "was", "calculated", "." ]

[ "aarch64", "\"\\n%s cost: %d (%s)\\n\"", "\"Hot\"", "\"Cold\"", "\"final\"", "\"partial\"" ]

[]

[ "<s>", "bool", "CSKYPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createCSKYISelDag", "(", "getCSKYTargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY", "CSKY", "CSKY" ]

[]

[ "<s>", "bool", "AMDGPUArgumentUsageInfo", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "return", "false", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "BitVector", "XNCMRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "XNCM", "::", "IP", ")", ";", "Reserved", ".", "set", "(", "XNCM", "::", "SP", ")", ";", "Reserved", ".", "set", "(", "XNCM", "::", "LR", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "XNCM::IP", "XNCM::SP", "XNCM::LR" ]

[]

[ "<s>", "void", "M88kFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFFrame", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "MFFrame", ".", "hasCalls", "(", ")", ")", "SavedRegs", ".", "set", "(", "M88k", "::", "R1", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "SavedRegs", ".", "set", "(", "M88k", "::", "R30", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k", "M88k::R1", "M88k::R30" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "StackOffset", "Off", "(", "Offset", ",", "MVT", "::", "i8", ")", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Done", "=", "rewriteAArch64FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "MVT::i8", "0", "\"Instr doesn't have FrameIndex operand!\"", "AArch64", "AArch64", "AArch64", "\"Unable to resolve frame index!\"" ]

[]

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

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

[ "TL45" ]

[]

[ "<s>", "void", "addExpr", "(", "MCInst", "&", "Inst", ",", "const", "MCExpr", "*", "Expr", ")", "const", "{", "if", "(", "!", "Expr", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "0", ")", ")", ";", "else", "if", "(", "const", "MCConstantExpr", "*", "CE", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Expr", ")", ")", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateImm", "(", "CE", "->", "getValue", "(", ")", ")", ")", ";", "else", "Inst", ".", "addOperand", "(", "MCOperand", "::", "CreateExpr", "(", "Expr", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "new", "MCExpr", "operand", "." ]

[ "ARM", "0" ]

[]

[ "<s>", "void", "mprocRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "RegScavenger", "*", "RS", ")", "const", "{", "}", "</s>" ]

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

[ "mproc", "mproc" ]

[]

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

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

[ "OR1K", "OR1K" ]

[]