Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "EVT", "TPCTargetLowering", "::", "getSetCCResultType", "(", "const", "DataLayout", "&", "DL", ",", "LLVMContext", "&", "Context", ",", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", ")", "{", "return", "EVT", "::", "getVectorVT", "(", "Context", ",", "MVT", "::", "i1", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "}", "return", "MVT", "::", "SimpleValueType", "::", "i1", ";", "}", "</s>" ]

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

[ "TPC", "TPC", "MVT::i1", "MVT::SimpleValueType" ]

[]

[ "<s>", "static", "bool", "z8k_reg_ok_for_base_p", "(", "rtx", "op", ")", "{", "return", "GET_MODE", "(", "op", ")", "==", "Pmode", "&&", "(", "REGNO", "(", "op", ")", ">", "FIRST_PSEUDO_REGISTER", "||", "(", "REGNO", "(", "op", ")", "!=", "0", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "X", "is", "a", "hard", "reg", "that", "can", "be", "used", "as", "a", "base", "reg", "or", "if", "it", "is", "a", "pseudo", "reg", "." ]

[ "z8k", "0" ]

[]

[ "<s>", "bool", "M68kInstrInfo", "::", "ExpandMOVSZX_RM", "(", "MachineInstrBuilder", "&", "MIB", ",", "bool", "IsSigned", ",", "const", "MCInstrDesc", "&", "Desc", ",", "MVT", "MVTDst", ",", "MVT", "MVTSrc", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Expand \"", "<<", "*", "MIB", ".", "getInstr", "(", ")", "<<", "\" to LOAD and \"", ")", ";", "Register", "Dst", "=", "MIB", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "SubDst", "=", "RI", ".", "getSubReg", "(", "Dst", ",", "MVTSrc", "==", "MVT", "::", "i8", "?", "M68k", "::", "MxSubRegIndex8Lo", ":", "M68k", "::", "MxSubRegIndex16Lo", ")", ";", "assert", "(", "SubDst", "&&", "\"No viable SUB register available\"", ")", ";", "MIB", "->", "setDesc", "(", "Desc", ")", ";", "MIB", "->", "getOperand", "(", "0", ")", ".", "setReg", "(", "SubDst", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MIB", ".", "getInstr", "(", ")", ";", "I", "++", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MIB", "->", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MIB", "->", "getDebugLoc", "(", ")", ";", "if", "(", "IsSigned", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Sign Extend\"", "<<", "'\\n'", ")", ";", "AddSExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Zero Extend\"", "<<", "'\\n'", ")", ";", "AddZExt", "(", "MBB", ",", "I", ",", "DL", ",", "Dst", ",", "MVTSrc", ",", "MVTDst", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Move", "from", "memory", "and", "extend", "." ]

[ "M68k", "M68k", "\"Expand \"", "\" to LOAD and \"", "0", "MVT::i8", "M68k::MxSubRegIndex8Lo", "M68k::MxSubRegIndex16Lo", "\"No viable SUB register available\"", "0", "\"Sign Extend\"", "\"Zero Extend\"" ]

[]

[ "<s>", "void", "split_adds_subs", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "rtx", "reg", "=", "operands", "[", "0", "]", ";", "HOST_WIDE_INT", "sign", "=", "1", ";", "HOST_WIDE_INT", "amount", ";", "rtx", "(", "*", "gen_add", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "val", "<", "0", ")", "{", "val", "=", "-", "val", ";", "sign", "=", "-", "1", ";", "}", "switch", "(", "mode", ")", "{", "case", "E_HImode", ":", "gen_add", "=", "gen_addhi3", ";", "break", ";", "case", "E_SImode", ":", "gen_add", "=", "gen_addsi3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "for", "(", "amount", "=", "4", ";", "amount", ">", "0", ";", "amount", "/=", "2", ")", "{", "for", "(", ";", "val", ">=", "amount", ";", "val", "-=", "amount", ")", "emit_insn", "(", "gen_add", "(", "reg", ",", "reg", ",", "GEN_INT", "(", "sign", "*", "amount", ")", ")", ")", ";", "}", "return", ";", "}", "</s>" ]

[ "Split", "an", "add", "of", "a", "small", "constant", "into", "two", "adds/subs", "insns", "." ]

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

[]

[ "<s>", "bool", "AArch64PostRASchedStrategy", "::", "tryCandidate", "(", "SchedCandidate", "&", "Cand", ",", "SchedCandidate", "&", "TryCand", ")", "{", "bool", "OriginalResult", "=", "PostGenericScheduler", "::", "tryCandidate", "(", "Cand", ",", "TryCand", ")", ";", "if", "(", "Cand", ".", "isValid", "(", ")", ")", "{", "MachineInstr", "*", "Instr0", "=", "TryCand", ".", "SU", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "Instr1", "=", "Cand", ".", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "Instr0", "&&", "Instr1", "&&", "Instr0", "->", "getOpcode", "(", ")", "==", "Instr1", "->", "getOpcode", "(", ")", "&&", "Instr0", "->", "getOpcode", "(", ")", "==", "AArch64", "::", "STPQi", ")", "{", "MachineOperand", "&", "Base0", "=", "Instr0", "->", "getOperand", "(", "2", ")", ";", "MachineOperand", "&", "Base1", "=", "Instr1", "->", "getOperand", "(", "2", ")", ";", "int64_t", "Off0", "=", "Instr0", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "int64_t", "Off1", "=", "Instr1", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "Base0", ".", "isIdenticalTo", "(", "Base1", ")", "&&", "llabs", "(", "Off0", "-", "Off1", ")", ">=", "2", ")", "{", "TryCand", ".", "Reason", "=", "NodeOrder", ";", "return", "Off0", "<", "Off1", ";", "}", "}", "}", "return", "OriginalResult", ";", "}", "</s>" ]

[ "Apply", "a", "set", "of", "heuristics", "to", "a", "new", "candidate", "." ]

[ "AArch64", "AArch64", "AArch64::STPQi", "2", "2", "3", "3", "2" ]

[]

[ "<s>", "tree", "memory_scalar_type", "(", "const", "function_instance", "&", "fi", ")", "const", "override", "{", "type_class_index", "tclass", "=", "fi", ".", "type_suffix", "(", "0", ")", ".", "tclass", ";", "unsigned", "int", "element_bits", "=", "GET_MODE_BITSIZE", "(", "m_to_mode", ")", ";", "type_suffix_index", "suffix", "=", "find_type_suffix", "(", "tclass", ",", "element_bits", ")", ";", "return", "scalar_types", "[", "type_suffixes", "[", "suffix", "]", ".", "vector_type", "]", ";", "}", "</s>" ]

[ "If", "the", "function", "addresses", "memory", ",", "return", "the", "type", "of", "a", "single", "scalar", "memory", "element", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "inline", "const", "type_suffix_info", "&", "function_instance", "::", "type_suffix", "(", "unsigned", "int", "i", ")", "const", "{", "return", "type_suffixes", "[", "type_suffix_ids", "[", "i", "]", "]", ";", "}", "</s>" ]

[ "Return", "information", "about", "type", "suffix", "I", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "GCNSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "hasHardClauses", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "SII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "ST", ".", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "ClauseInfo", "CI", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "HardClauseType", "Type", "=", "getHardClauseType", "(", "MI", ")", ";", "int64_t", "Dummy1", ";", "bool", "Dummy2", ";", "SmallVector", "<", "const", "MachineOperand", "*", ",", "4", ">", "BaseOps", ";", "if", "(", "Type", "<=", "LAST_REAL_HARDCLAUSE_TYPE", ")", "{", "if", "(", "!", "SII", "->", "getMemOperandsWithOffset", "(", "MI", ",", "BaseOps", ",", "Dummy1", ",", "Dummy2", ",", "TRI", ")", ")", "{", "Type", "=", "HARDCLAUSE_ILLEGAL", ";", "}", "}", "if", "(", "CI", ".", "Length", "==", "64", "||", "(", "CI", ".", "Length", "&&", "Type", "!=", "HARDCLAUSE_INTERNAL", "&&", "(", "Type", "!=", "CI", ".", "Type", "||", "!", "SII", "->", "shouldClusterMemOps", "(", "CI", ".", "BaseOps", ",", "BaseOps", ",", "2", ")", ")", ")", ")", "{", "Changed", "|=", "emitClause", "(", "CI", ",", "SII", ")", ";", "CI", "=", "ClauseInfo", "(", ")", ";", "}", "if", "(", "CI", ".", "Length", ")", "{", "++", "CI", ".", "Length", ";", "if", "(", "Type", "!=", "HARDCLAUSE_INTERNAL", ")", "{", "CI", ".", "Last", "=", "&", "MI", ";", "CI", ".", "BaseOps", "=", "std", "::", "move", "(", "BaseOps", ")", ";", "}", "}", "else", "if", "(", "Type", "<=", "LAST_REAL_HARDCLAUSE_TYPE", ")", "{", "CI", "=", "ClauseInfo", "{", "Type", ",", "&", "MI", ",", "&", "MI", ",", "1", ",", "std", "::", "move", "(", "BaseOps", ")", "}", ";", "}", "}", "if", "(", "CI", ".", "Length", ")", "Changed", "|=", "emitClause", "(", "CI", ",", "SII", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AMDGPUAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "MCSubtargetInfo", "&", "STI", "=", "*", "getGlobalSTI", "(", ")", ";", "if", "(", "(", "AMDGPU", "::", "isGFX10Plus", "(", "STI", ")", "||", "AMDGPU", "::", "isGFX90A", "(", "STI", ")", ")", "&&", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "||", "STI", ".", "getTargetTriple", "(", ")", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDPAL", ")", ")", "{", "OutStreamer", "->", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getTextSection", "(", ")", ")", ";", "getTargetStreamer", "(", ")", "->", "EmitCodeEnd", "(", "STI", ")", ";", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::isGFX10Plus", "AMDGPU::isGFX90A" ]

[]

[ "<s>", "bool", "TeeRISCPassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", "true", ";", "}", "</s>" ]

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

[ "TeeRISC", "TeeRISC" ]

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "{", "Parser", ".", "Lex", "(", ")", ";", "}", "else", "return", "true", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".intel_syntax\"", "1", "\"noprefix\"" ]

[]

[ "<s>", "bool", "MCS51PassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createMCS51ISelDag", "(", "getMCS51TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createMCS51FrameAnalyzerPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "MCS51", "MCS51", "MCS51" ]

[]

[ "<s>", "bool", "hasAndNotCompare", "(", "SDValue", "V", ")", "const", "override", "{", "return", "V", ".", "getValueType", "(", ")", ".", "isScalarInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "should", "transform", ":", "(", "X", "&", "Y", ")", "==", "Y", "�", "?", "(", "~X", "&", "Y", ")", "==", "0", "(", "X", "&", "Y", ")", "!", "=", "Y", "�", "?", "(", "~X", "&", "Y", ")", "!", "=", "0", "." ]

[ "AArch64" ]

[]

[ "<s>", "void", "TL45InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "IsKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opcode", ";", "if", "(", "TL45", "::", "GRRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "Opcode", "=", "TL45", "::", "SW", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "TL45", "TL45", "TL45::GRRegsRegClass", "TL45::SW", "\"Can't store this register to stack slot\"", "0" ]

[]

[ "<s>", "uint64_t", "MipsFrameLowering", "::", "estimateStackSize", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "int64_t", "Offset", "=", "0", ";", "for", "(", "int", "I", "=", "MFI", ".", "getObjectIndexBegin", "(", ")", ";", "I", "!=", "0", ";", "++", "I", ")", "Offset", "=", "std", "::", "max", "(", "Offset", ",", "-", "MFI", ".", "getObjectOffset", "(", "I", ")", ")", ";", "for", "(", "const", "MCPhysReg", "*", "R", "=", "TRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "{", "unsigned", "Size", "=", "TRI", ".", "getSpillSize", "(", "*", "TRI", ".", "getMinimalPhysRegClass", "(", "*", "R", ")", ")", ";", "Offset", "=", "alignTo", "(", "Offset", "+", "Size", ",", "Size", ")", ";", "}", "unsigned", "MaxAlign", "=", "MFI", ".", "getMaxAlignment", "(", ")", ";", "assert", "(", "!", "MFI", ".", "getObjectIndexEnd", "(", ")", "||", "MaxAlign", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MFI", ".", "getObjectIndexEnd", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "Offset", "=", "alignTo", "(", "Offset", "+", "MFI", ".", "getObjectSize", "(", "I", ")", ",", "MaxAlign", ")", ";", "if", "(", "MFI", ".", "adjustsStack", "(", ")", "&&", "hasReservedCallFrame", "(", "MF", ")", ")", "Offset", "=", "alignTo", "(", "Offset", "+", "MFI", ".", "getMaxCallFrameSize", "(", ")", ",", "std", "::", "max", "(", "MaxAlign", ",", "getStackAlignment", "(", ")", ")", ")", ";", "return", "alignTo", "(", "Offset", ",", "getStackAlignment", "(", ")", ")", ";", "}", "</s>" ]

[ "Estimate", "and", "return", "the", "size", "of", "the", "stack", "frame", "." ]

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

[]

[ "<s>", "SDValue", "LC3TargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "!", "isVarArg", "&&", "\"VarArg not supported\"", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "ArgLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeFormalArguments", "(", "Ins", ",", "CC_LC3", ")", ";", "for", "(", "auto", "&", "VA", ":", "ArgLocs", ")", "{", "if", "(", "VA", ".", "isRegLoc", "(", ")", ")", "{", "EVT", "RegVT", "=", "VA", ".", "getLocVT", "(", ")", ";", "assert", "(", "RegVT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "i16", "&&", "\"Only support MVT::i16 register passing\"", ")", ";", "const", "unsigned", "VReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "&", "LC3", "::", "GRRegsRegClass", ")", ";", "RegInfo", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ",", "VReg", ")", ";", "SDValue", "ArgIn", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "VReg", ",", "RegVT", ")", ";", "InVals", ".", "push_back", "(", "ArgIn", ")", ";", "continue", ";", "}", "assert", "(", "VA", ".", "isMemLoc", "(", ")", "&&", "\"Can only pass arguments as either registers or via the stack\"", ")", ";", "const", "unsigned", "Offset", "=", "VA", ".", "getLocMemOffset", "(", ")", ";", "const", "int", "FI", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "EVT", "PtrTy", "=", "getPointerTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "FIPtr", "=", "DAG", ".", "getFrameIndex", "(", "FI", ",", "PtrTy", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "i16", "&&", "\"Only support passing arguments as i16\"", ")", ";", "SDValue", "Load", "=", "DAG", ".", "getLoad", "(", "VA", ".", "getValVT", "(", ")", ",", "dl", ",", "Chain", ",", "FIPtr", ",", "MachinePointerInfo", "(", ")", ",", "false", ",", "false", ",", "false", ",", "0", ")", ";", "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", "." ]

[ "LC3", "LC3", "ISD::InputArg", "\"VarArg not supported\"", "16", "LC3", "MVT::i16", "\"Only support MVT::i16 register passing\"", "LC3::GRRegsRegClass", "\"Can only pass arguments as either registers or via the stack\"", "4", "MVT::i16", "\"Only support passing arguments as i16\"", "0" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "MCRegister", "DestReg", ",", "MCRegister", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "if", "(", "!", "ARM", "::", "GPRRegClass", ".", "contains", "(", "DestReg", ",", "SrcReg", ")", ")", "return", "ARMBaseInstrInfo", "::", "copyPhysReg", "(", "MBB", ",", "I", ",", "DL", ",", "DestReg", ",", "SrcReg", ",", "KillSrc", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "tMOVr", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM", "ARM::tMOVr", "ARMCC::AL" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isShuffleMaskLegal", "(", "const", "SmallVectorImpl", "<", "int", ">", "&", "M", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "MVT", "SVT", "=", "VT", ".", "getSimpleVT", "(", ")", ";", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "false", ";", "if", "(", "(", "SVT", ".", "is128BitVector", "(", ")", "&&", "Subtarget", "->", "hasSSSE3", "(", ")", ")", "||", "(", "SVT", ".", "is256BitVector", "(", ")", "&&", "Subtarget", "->", "hasInt256", "(", ")", ")", ")", "{", "bool", "isLegal", "=", "true", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "M", ".", "size", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "M", "[", "I", "]", ">=", "(", "int", ")", "SVT", ".", "getVectorNumElements", "(", ")", "||", "ShuffleCrosses128bitLane", "(", "SVT", ",", "I", ",", "M", "[", "I", "]", ")", ")", "{", "isLegal", "=", "false", ";", "break", ";", "}", "}", "if", "(", "isLegal", ")", "return", "true", ";", "}", "return", "(", "SVT", ".", "getVectorNumElements", "(", ")", "==", "2", "||", "ShuffleVectorSDNode", "::", "isSplatMask", "(", "&", "M", "[", "0", "]", ",", "VT", ")", "||", "isMOVLMask", "(", "M", ",", "SVT", ")", "||", "isSHUFPMask", "(", "M", ",", "SVT", ")", "||", "isPSHUFDMask", "(", "M", ",", "SVT", ")", "||", "isPSHUFHWMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isPSHUFLWMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isPALIGNRMask", "(", "M", ",", "SVT", ",", "Subtarget", ")", "||", "isUNPCKLMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isUNPCKHMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isUNPCKL_v_undef_Mask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isUNPCKH_v_undef_Mask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", "||", "isBlendMask", "(", "M", ",", "SVT", ",", "Subtarget", "->", "hasSSE41", "(", ")", ",", "Subtarget", "->", "hasInt256", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Targets", "can", "use", "this", "to", "indicate", "that", "they", "only", "support", "some", "VECTOR_SHUFFLE", "operations", ",", "those", "with", "specific", "masks", "." ]

[ "X86", "X86", "64", "0", "2", "0" ]

[]

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

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

[ "SHUXI" ]

[]

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

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "BPF" ]

[]

[ "<s>", "bool", "MipsFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "if", "(", "!", "TargetSupported", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Instruction", "::", "Load", ":", "return", "selectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "selectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "return", "selectShift", "(", "I", ")", ";", "case", "Instruction", "::", "And", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "return", "selectLogicalOp", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "selectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "selectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "selectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "selectIntExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "selectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "selectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPToSI", ":", "return", "selectFPToInt", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "selectFPToInt", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "ICmp", ":", "case", "Instruction", "::", "FCmp", ":", "return", "selectCmp", "(", "I", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "static", "void", "add_constant", "(", "int", "dest", ",", "int", "src", ",", "int", "value", ",", "int", "mark_frame", ")", "{", "rtx_insn", "*", "insn", ";", "int", "hi", ",", "lo", ";", "if", "(", "src", "==", "dest", "&&", "value", "==", "0", ")", "return", ";", "if", "(", "value", "==", "0", ")", "{", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ")", ";", "if", "(", "mark_frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", ";", "}", "if", "(", "value", ">=", "-", "32768", "&&", "value", "<=", "32767", ")", "{", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ",", "GEN_INT", "(", "value", ")", ")", ")", ";", "if", "(", "mark_frame", ")", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", ";", "}", "hi", "=", "trunc_int_for_mode", "(", "value", "&", "0xffff0000", ",", "SImode", ")", ";", "lo", "=", "value", "&", "0xffff", ";", "insn", "=", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "GEN_INT", "(", "hi", ")", ")", ";", "if", "(", "lo", ")", "{", "insn", "=", "emit_insn", "(", "gen_iorsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ",", "GEN_INT", "(", "lo", ")", ")", ")", ";", "}", "insn", "=", "emit_insn", "(", "gen_addsi3", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "src", ")", ",", "gen_rtx_REG", "(", "SImode", ",", "REGSAVE_CONTROL_TEMP", ")", ")", ")", ";", "if", "(", "mark_frame", ")", "{", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "gen_rtx_SET", "(", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "gen_rtx_PLUS", "(", "SImode", ",", "gen_rtx_REG", "(", "SImode", ",", "dest", ")", ",", "GEN_INT", "(", "value", ")", ")", ")", ")", ";", "}", "}", "</s>" ]

[ "Add", "a", "constant", "to", "the", "pool", "and", "return", "its", "label", "." ]

[ "mep", "0", "0", "1", "32768", "32767", "1", "0xffff0000", "0xffff", "1" ]

[]

[ "<s>", "void", "WebAssemblyDAGToDAGISel", "::", "PreprocessISelDAG", "(", ")", "{", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "for", "(", "int", "Idx", "=", "0", ";", "Idx", "<", "FrameInfo", ".", "getObjectIndexEnd", "(", ")", ";", "Idx", "++", ")", "WebAssemblyFrameLowering", "::", "getLocalForStackObject", "(", "*", "MF", ",", "Idx", ")", ";", "SelectionDAGISel", "::", "PreprocessISelDAG", "(", ")", ";", "}", "</s>" ]

[ "PreprocessISelDAG", "-", "This", "hook", "allows", "targets", "to", "hack", "on", "the", "graph", "before", "instruction", "selection", "starts", "." ]

[ "WebAssembly", "WebAssembly", "0", "WebAssembly" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "override", "{", "if", "(", "Count", "==", "0", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "TOY", "0" ]

[]

[ "<s>", "void", "AArch64WinCOFFStreamer", "::", "finishImpl", "(", ")", "{", "emitFrames", "(", "nullptr", ")", ";", "EmitWindowsUnwindTables", "(", ")", ";", "MCWinCOFFStreamer", "::", "finishImpl", "(", ")", ";", "}", "</s>" ]

[ "Streamer", "specific", "finalization", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "void", "RegisterAggr", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "OS", "<<", "'{'", ";", "for", "(", "auto", "I", ":", "Masks", ")", "OS", "<<", "' '", "<<", "PrintReg", "(", "I", ".", "first", ",", "&", "PRI", ".", "getTRI", "(", ")", ")", "<<", "PrintLaneMaskOpt", "(", "I", ".", "second", ")", ";", "OS", "<<", "\" }\"", ";", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "Hexagon", "\" }\"" ]

[]

[ "<s>", "unsigned", "PPCTTIImpl", "::", "getPrefetchDistance", "(", ")", "{", "return", "300", ";", "}", "</s>" ]

[ "Return", "the", "preferred", "prefetch", "distance", "in", "terms", "of", "instructions", "." ]

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

[]

[ "<s>", "const", "MCSection", "*", "X86WindowsTargetObjectFile", "::", "getSectionForConstant", "(", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "{", "if", "(", "Kind", ".", "isReadOnly", "(", ")", ")", "{", "if", "(", "C", ")", "{", "Type", "*", "Ty", "=", "C", "->", "getType", "(", ")", ";", "SmallString", "<", "32", ">", "COMDATSymName", ";", "if", "(", "Ty", "->", "isFloatTy", "(", ")", "||", "Ty", "->", "isDoubleTy", "(", ")", ")", "{", "COMDATSymName", "=", "\"__real@\"", ";", "COMDATSymName", "+=", "scalarConstantToHexString", "(", "C", ")", ";", "}", "else", "if", "(", "const", "auto", "*", "VTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "Ty", ")", ")", "{", "uint64_t", "NumBits", "=", "VTy", "->", "getBitWidth", "(", ")", ";", "if", "(", "NumBits", "==", "128", "||", "NumBits", "==", "256", ")", "{", "COMDATSymName", "=", "NumBits", "==", "128", "?", "\"__xmm@\"", ":", "\"__ymm@\"", ";", "for", "(", "int", "I", "=", "VTy", "->", "getNumElements", "(", ")", "-", "1", ",", "E", "=", "-", "1", ";", "I", "!=", "E", ";", "--", "I", ")", "COMDATSymName", "+=", "scalarConstantToHexString", "(", "C", "->", "getAggregateElement", "(", "I", ")", ")", ";", "}", "}", "if", "(", "!", "COMDATSymName", ".", "empty", "(", ")", ")", "{", "unsigned", "Characteristics", "=", "COFF", "::", "IMAGE_SCN_CNT_INITIALIZED_DATA", "|", "COFF", "::", "IMAGE_SCN_MEM_READ", "|", "COFF", "::", "IMAGE_SCN_LNK_COMDAT", ";", "return", "getContext", "(", ")", ".", "getCOFFSection", "(", "\".rdata\"", ",", "Characteristics", ",", "Kind", ",", "COMDATSymName", ",", "COFF", "::", "IMAGE_COMDAT_SELECT_ANY", ")", ";", "}", "}", "}", "return", "TargetLoweringObjectFile", "::", "getSectionForConstant", "(", "Kind", ",", "C", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "X86", "X86", "32", "\"__real@\"", "128", "256", "128", "\"__xmm@\"", "\"__ymm@\"", "1", "1", "\".rdata\"" ]

[]

[ "<s>", "BitVector", "NVPTXRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "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", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "static", "tree", "bpf_core_field_info", "(", "tree", "src", ",", "enum", "btf_core_reloc_kind", "kind", ")", "{", "unsigned", "int", "result", ";", "poly_int64", "bitsize", ",", "bitpos", ";", "tree", "var_off", "=", "NULL_TREE", ";", "machine_mode", "mode", ";", "int", "unsignedp", ",", "reversep", ",", "volatilep", ";", "location_t", "loc", "=", "EXPR_LOCATION", "(", "src", ")", ";", "get_inner_reference", "(", "src", ",", "&", "bitsize", ",", "&", "bitpos", ",", "&", "var_off", ",", "&", "mode", ",", "&", "unsignedp", ",", "&", "reversep", ",", "&", "volatilep", ")", ";", "bool", "bitfieldp", "=", "(", "TREE_CODE", "(", "src", ")", "==", "COMPONENT_REF", "&&", "DECL_BIT_FIELD_TYPE", "(", "TREE_OPERAND", "(", "src", ",", "1", ")", ")", ")", ";", "unsigned", "int", "align", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "src", ")", ")", ";", "if", "(", "TREE_CODE", "(", "src", ")", "==", "COMPONENT_REF", ")", "{", "tree", "field", "=", "TREE_OPERAND", "(", "src", ",", "1", ")", ";", "if", "(", "DECL_BIT_FIELD_TYPE", "(", "field", ")", ")", "align", "=", "TYPE_ALIGN", "(", "DECL_BIT_FIELD_TYPE", "(", "field", ")", ")", ";", "else", "align", "=", "TYPE_ALIGN", "(", "TREE_TYPE", "(", "field", ")", ")", ";", "}", "unsigned", "int", "start_bitpos", "=", "bitpos", "&", "~", "(", "align", "-", "1", ")", ";", "unsigned", "int", "end_bitpos", "=", "start_bitpos", "+", "align", ";", "switch", "(", "kind", ")", "{", "case", "BPF_RELO_FIELD_BYTE_OFFSET", ":", "{", "if", "(", "var_off", "!=", "NULL_TREE", ")", "{", "error_at", "(", "loc", ",", "\"unsupported variable field offset\"", ")", ";", "return", "error_mark_node", ";", "}", "if", "(", "bitfieldp", ")", "result", "=", "start_bitpos", "/", "8", ";", "else", "result", "=", "bitpos", "/", "8", ";", "}", "break", ";", "case", "BPF_RELO_FIELD_BYTE_SIZE", ":", "{", "if", "(", "mode", "==", "BLKmode", "&&", "bitsize", "==", "-", "1", ")", "{", "error_at", "(", "loc", ",", "\"unsupported variable size field access\"", ")", ";", "return", "error_mark_node", ";", "}", "if", "(", "bitfieldp", ")", "{", "result", "=", "end_bitpos", "-", "start_bitpos", ";", "if", "(", "result", "&", "(", "result", "-", "1", ")", ")", "{", "error_at", "(", "loc", ",", "\"unsupported field expression\"", ")", ";", "return", "error_mark_node", ";", "}", "result", "=", "result", "/", "8", ";", "}", "else", "result", "=", "bitsize", "/", "8", ";", "}", "break", ";", "case", "BPF_RELO_FIELD_EXISTS", ":", "result", "=", "1", ";", "break", ";", "case", "BPF_RELO_FIELD_SIGNED", ":", "result", "=", "!", "unsignedp", ";", "break", ";", "case", "BPF_RELO_FIELD_LSHIFT_U64", ":", "case", "BPF_RELO_FIELD_RSHIFT_U64", ":", "{", "if", "(", "mode", "==", "BLKmode", "&&", "bitsize", "==", "-", "1", ")", "{", "error_at", "(", "loc", ",", "\"unsupported variable size field access\"", ")", ";", "return", "error_mark_node", ";", "}", "if", "(", "var_off", "!=", "NULL_TREE", ")", "{", "error_at", "(", "loc", ",", "\"unsupported variable field offset\"", ")", ";", "return", "error_mark_node", ";", "}", "if", "(", "!", "bitfieldp", ")", "{", "if", "(", "bitsize", ">", "64", ")", "{", "error_at", "(", "loc", ",", "\"field size too large\"", ")", ";", "return", "error_mark_node", ";", "}", "result", "=", "64", "-", "bitsize", ";", "break", ";", "}", "if", "(", "end_bitpos", "-", "start_bitpos", ">", "64", ")", "{", "error_at", "(", "loc", ",", "\"field size too large\"", ")", ";", "return", "error_mark_node", ";", "}", "if", "(", "kind", "==", "BPF_RELO_FIELD_LSHIFT_U64", ")", "{", "if", "(", "TARGET_BIG_ENDIAN", ")", "result", "=", "bitpos", "+", "64", "-", "start_bitpos", "-", "align", ";", "else", "result", "=", "start_bitpos", "+", "64", "-", "bitpos", "-", "bitsize", ";", "}", "else", "result", "=", "64", "-", "bitsize", ";", "}", "break", ";", "default", ":", "error", "(", "\"invalid second argument to built-in function\"", ")", ";", "return", "error_mark_node", ";", "break", ";", "}", "return", "build_int_cst", "(", "unsigned_type_node", ",", "result", ")", ";", "}", "</s>" ]

[ "Expand", "a", "call", "to", "__builtin_preserve_field_info", "by", "evaluating", "the", "requested", "information", "about", "SRC", "according", "to", "KIND", ",", "and", "return", "a", "tree", "holding", "the", "result", "." ]

[ "bpf", "1", "1", "1", "\"unsupported variable field offset\"", "8", "8", "1", "\"unsupported variable size field access\"", "1", "\"unsupported field expression\"", "8", "8", "1", "1", "\"unsupported variable size field access\"", "\"unsupported variable field offset\"", "64", "\"field size too large\"", "64", "64", "\"field size too large\"", "64", "64", "64", "\"invalid second argument to built-in function\"" ]

[]

[ "<s>", "static", "int", "mcore_arg_partial_bytes", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "int", "reg", "=", "ROUND_REG", "(", "*", "cum", ",", "mode", ")", ";", "if", "(", "named", "==", "0", ")", "return", "0", ";", "if", "(", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "return", "0", ";", "if", "(", "reg", ">=", "NPARM_REGS", ")", "return", "0", ";", "if", "(", "reg", "+", "mcore_num_arg_regs", "(", "mode", ",", "type", ")", "<=", "NPARM_REGS", ")", "return", "0", ";", "reg", "=", "NPARM_REGS", "-", "reg", ";", "return", "reg", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Returns", "the", "number", "of", "bytes", "of", "argument", "registers", "required", "to", "hold", "*", "part", "*", "of", "a", "parameter", "of", "machine", "mode", "MODE", "and", "type", "TYPE", "(", "which", "may", "be", "NULL", "if", "the", "type", "is", "not", "known", ")", ".", "If", "the", "argument", "fits", "entirely", "in", "the", "argument", "registers", ",", "or", "entirely", "on", "the", "stack", ",", "then", "0", "is", "returned", ".", "CUM", "is", "the", "number", "of", "argument", "registers", "already", "used", "by", "earlier", "parameters", "to", "the", "function", "." ]

[ "mcore", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "!", "getARMSubtarget", "(", ")", ".", "isTargetNaCl", "(", ")", "&&", "(", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "127", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "void", "SystemZELFFrameLowering", "::", "orderFrameObjects", "(", "const", "MachineFunction", "&", "MF", ",", "SmallVectorImpl", "<", "int", ">", "&", "ObjectsToAllocate", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "SystemZInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SystemZInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "ObjectsToAllocate", ".", "size", "(", ")", "<=", "1", ")", "return", ";", "SZFrameObjVec", "SortingObjects", "(", "MFI", ".", "getObjectIndexEnd", "(", ")", ")", ";", "for", "(", "auto", "&", "Obj", ":", "ObjectsToAllocate", ")", "{", "SortingObjects", "[", "Obj", "]", ".", "IsValid", "=", "true", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectIndex", "=", "Obj", ";", "SortingObjects", "[", "Obj", "]", ".", "ObjectSize", "=", "MFI", ".", "getObjectSize", "(", "Obj", ")", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "if", "(", "MI", ".", "isDebugInstr", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "I", "=", "0", ",", "E", "=", "MI", ".", "getNumOperands", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "!", "MO", ".", "isFI", "(", ")", ")", "continue", ";", "int", "Index", "=", "MO", ".", "getIndex", "(", ")", ";", "if", "(", "Index", ">=", "0", "&&", "Index", "<", "MFI", ".", "getObjectIndexEnd", "(", ")", "&&", "SortingObjects", "[", "Index", "]", ".", "IsValid", ")", "{", "if", "(", "TII", "->", "hasDisplacementPairInsn", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "SortingObjects", "[", "Index", "]", ".", "DPairCount", "++", ";", "else", "if", "(", "!", "(", "MI", ".", "getDesc", "(", ")", ".", "TSFlags", "&", "SystemZII", "::", "Has20BitOffset", ")", ")", "SortingObjects", "[", "Index", "]", ".", "D12Count", "++", ";", "}", "}", "}", "auto", "CmpD12", "=", "[", "]", "(", "const", "SZFrameSortingObj", "&", "A", ",", "const", "SZFrameSortingObj", "&", "B", ")", "{", "if", "(", "!", "A", ".", "IsValid", "||", "!", "B", ".", "IsValid", ")", "return", "A", ".", "IsValid", ";", "if", "(", "!", "A", ".", "ObjectSize", "||", "!", "B", ".", "ObjectSize", ")", "return", "A", ".", "ObjectSize", ">", "0", ";", "uint64_t", "ADensityCmp", "=", "A", ".", "D12Count", "*", "B", ".", "ObjectSize", ";", "uint64_t", "BDensityCmp", "=", "B", ".", "D12Count", "*", "A", ".", "ObjectSize", ";", "if", "(", "ADensityCmp", "!=", "BDensityCmp", ")", "return", "ADensityCmp", "<", "BDensityCmp", ";", "return", "A", ".", "DPairCount", "*", "B", ".", "ObjectSize", "<", "B", ".", "DPairCount", "*", "A", ".", "ObjectSize", ";", "}", ";", "std", "::", "stable_sort", "(", "SortingObjects", ".", "begin", "(", ")", ",", "SortingObjects", ".", "end", "(", ")", ",", "CmpD12", ")", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Obj", ":", "SortingObjects", ")", "{", "if", "(", "!", "Obj", ".", "IsValid", ")", "break", ";", "ObjectsToAllocate", "[", "Idx", "++", "]", "=", "Obj", ".", "ObjectIndex", ";", "}", "}", "</s>" ]

[ "Order", "the", "symbols", "in", "the", "local", "stack", "." ]

[ "SystemZ", "SystemZ", "SystemZ", "SystemZ", "1", "0", "0", "SystemZII::Has20BitOffset", "0", "0" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isAlwaysUniform", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_readfirstlane", ":", "case", "Intrinsic", "::", "amdgcn_readlane", ":", "case", "Intrinsic", "::", "amdgcn_icmp", ":", "case", "Intrinsic", "::", "amdgcn_fcmp", ":", "case", "Intrinsic", "::", "amdgcn_ballot", ":", "case", "Intrinsic", "::", "amdgcn_if_break", ":", "return", "true", ";", "}", "}", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "isa", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ")", "return", "!", "isInlineAsmSourceOfDivergence", "(", "CI", ")", ";", "return", "false", ";", "}", "const", "ExtractValueInst", "*", "ExtValue", "=", "dyn_cast", "<", "ExtractValueInst", ">", "(", "V", ")", ";", "if", "(", "!", "ExtValue", ")", "return", "false", ";", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "ExtValue", "->", "getOperand", "(", "0", ")", ")", ";", "if", "(", "!", "CI", ")", "return", "false", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "CI", ")", ")", "{", "switch", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Intrinsic", "::", "amdgcn_if", ":", "case", "Intrinsic", "::", "amdgcn_else", ":", "{", "ArrayRef", "<", "unsigned", ">", "Indices", "=", "ExtValue", "->", "getIndices", "(", ")", ";", "return", "Indices", ".", "size", "(", ")", "==", "1", "&&", "Indices", "[", "0", "]", "==", "1", ";", "}", "}", "}", "if", "(", "isa", "<", "InlineAsm", ">", "(", "CI", "->", "getCalledValue", "(", ")", ")", ")", "return", "!", "isInlineAsmSourceOfDivergence", "(", "CI", ",", "ExtValue", "->", "getIndices", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Whether", "Val", "will", "always", "return", "a", "uniform", "value", "regardless", "of", "its", "operands", "." ]

[ "AMDGPU", "Intrinsic::amdgcn_readfirstlane", "Intrinsic::amdgcn_readlane", "Intrinsic::amdgcn_icmp", "Intrinsic::amdgcn_fcmp", "Intrinsic::amdgcn_ballot", "Intrinsic::amdgcn_if_break", "0", "Intrinsic::amdgcn_if", "Intrinsic::amdgcn_else", "1", "0", "1" ]

[]

[ "<s>", "static", "int", "bfin_comp_type_attributes", "(", "tree", "type1", ",", "tree", "type2", ")", "{", "e_funkind", "kind1", ",", "kind2", ";", "if", "(", "TREE_CODE", "(", "type1", ")", "!=", "FUNCTION_TYPE", ")", "return", "1", ";", "kind1", "=", "funkind", "(", "type1", ")", ";", "kind2", "=", "funkind", "(", "type2", ")", ";", "if", "(", "kind1", "!=", "kind2", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"nesting\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"nesting\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"saveall\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"saveall\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"kspisusp\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"kspisusp\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "if", "(", "!", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "type1", ")", ")", "!=", "!", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "type2", ")", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "0", "if", "the", "attributes", "for", "two", "types", "are", "incompatible", ",", "1", "if", "they", "are", "compatible", ",", "and", "2", "if", "they", "are", "nearly", "compatible", "(", "which", "causes", "a", "warning", "to", "be", "generated", ")", "." ]

[ "bfin", "1", "0", "\"nesting\"", "\"nesting\"", "0", "\"saveall\"", "\"saveall\"", "0", "\"kspisusp\"", "\"kspisusp\"", "0", "\"longcall\"", "\"longcall\"", "0", "1" ]

[]

[ "<s>", "bool", "PPCFastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "MVT", "VT", ";", "if", "(", "!", "isLoadTypeLegal", "(", "LI", "->", "getType", "(", ")", ",", "VT", ")", ")", "return", "false", ";", "bool", "IsZExt", "=", "false", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "PPC", "::", "RLDICL", ":", "case", "PPC", "::", "RLDICL_32_64", ":", "{", "IsZExt", "=", "true", ";", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i8", "&&", "MB", "<=", "56", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "MB", "<=", "48", ")", "||", "(", "VT", "==", "MVT", "::", "i32", "&&", "MB", "<=", "32", ")", ")", "break", ";", "return", "false", ";", "}", "case", "PPC", "::", "RLWINM", ":", "case", "PPC", "::", "RLWINM8", ":", "{", "IsZExt", "=", "true", ";", "unsigned", "MB", "=", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", ";", "if", "(", "(", "VT", "==", "MVT", "::", "i8", "&&", "MB", "<=", "24", ")", "||", "(", "VT", "==", "MVT", "::", "i16", "&&", "MB", "<=", "16", ")", ")", "break", ";", "return", "false", ";", "}", "case", "PPC", "::", "EXTSB", ":", "case", "PPC", "::", "EXTSB8", ":", "case", "PPC", "::", "EXTSB8_32_64", ":", "return", "false", ";", "case", "PPC", "::", "EXTSH", ":", "case", "PPC", "::", "EXTSH8", ":", "case", "PPC", "::", "EXTSH8_32_64", ":", "{", "if", "(", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "break", ";", "}", "case", "PPC", "::", "EXTSW", ":", "case", "PPC", "::", "EXTSW_32", ":", "case", "PPC", "::", "EXTSW_32_64", ":", "{", "if", "(", "VT", "!=", "MVT", "::", "i32", "&&", "VT", "!=", "MVT", "::", "i16", "&&", "VT", "!=", "MVT", "::", "i8", ")", "return", "false", ";", "break", ";", "}", "}", "Address", "Addr", ";", "if", "(", "!", "PPCComputeAddress", "(", "LI", "->", "getOperand", "(", "0", ")", ",", "Addr", ")", ")", "return", "false", ";", "unsigned", "ResultReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "PPCEmitLoad", "(", "VT", ",", "ResultReg", ",", "Addr", ",", "nullptr", ",", "IsZExt", ",", "PPCSubTarget", "->", "hasSPE", "(", ")", "?", "PPC", "::", "EVLDD", ":", "PPC", "::", "LFD", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "I", "(", "MI", ")", ";", "removeDeadCode", "(", "I", ",", "std", "::", "next", "(", "I", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC::RLDICL", "PPC::RLDICL_32_64", "3", "MVT::i8", "56", "MVT::i16", "48", "MVT::i32", "32", "PPC::RLWINM", "PPC::RLWINM8", "3", "MVT::i8", "24", "MVT::i16", "16", "PPC::EXTSB", "PPC::EXTSB8", "PPC::EXTSB8_32_64", "PPC::EXTSH", "PPC::EXTSH8", "PPC::EXTSH8_32_64", "MVT::i16", "MVT::i8", "PPC::EXTSW", "PPC::EXTSW_32", "PPC::EXTSW_32_64", "MVT::i32", "MVT::i16", "MVT::i8", "PPC", "0", "0", "PPC", "PPC", "PPC::EVLDD", "PPC::LFD" ]

[]

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

[ "Tests", "whether", "the", "target", "triple", "is", "little", "endian", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "int", "ix86_simd_clone_usable", "(", "struct", "cgraph_node", "*", "node", ")", "{", "switch", "(", "node", "->", "simdclone", "->", "vecsize_mangle", ")", "{", "case", "'b'", ":", "if", "(", "!", "TARGET_SSE2", ")", "return", "-", "1", ";", "if", "(", "!", "TARGET_AVX", ")", "return", "0", ";", "return", "TARGET_AVX512F", "?", "3", ":", "TARGET_AVX2", "?", "2", ":", "1", ";", "case", "'c'", ":", "if", "(", "!", "TARGET_AVX", ")", "return", "-", "1", ";", "return", "TARGET_AVX512F", "?", "2", ":", "TARGET_AVX2", "?", "1", ":", "0", ";", "case", "'d'", ":", "if", "(", "!", "TARGET_AVX2", ")", "return", "-", "1", ";", "return", "TARGET_AVX512F", "?", "1", ":", "0", ";", "case", "'e'", ":", "if", "(", "!", "TARGET_AVX512F", ")", "return", "-", "1", ";", "return", "0", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "If", "SIMD", "clone", "NODE", "ca", "n't", "be", "used", "in", "a", "vectorized", "loop", "in", "current", "function", ",", "return", "-1", ",", "otherwise", "return", "a", "badness", "of", "using", "it", "(", "0", "if", "it", "is", "most", "desirable", "from", "vecsize_mangle", "point", "of", "view", ",", "1", "slightly", "less", "desirable", ",", "etc", ".", ")", "." ]

[ "i386", "1", "0", "3", "2", "1", "1", "2", "1", "0", "1", "1", "0", "1", "0" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "isTruncateFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "if", "(", "!", "VT1", ".", "isSimple", "(", ")", "||", "!", "VT2", ".", "isSimple", "(", ")", ")", "return", "false", ";", "return", "(", "VT1", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i64", ")", "&&", "(", "VT2", ".", "getSimpleVT", "(", ")", "==", "MVT", "::", "i32", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "free", "to", "truncate", "a", "value", "of", "type", "Ty1", "to", "type", "Ty2", "." ]

[ "Hexagon", "Hexagon", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "unsigned", "constant_generates_lxvkq", "(", "vec_const_128bit_type", "*", "vsx_const", ")", "{", "if", "(", "!", "TARGET_IEEE128_CONSTANT", "||", "!", "TARGET_FLOAT128_HW", "||", "!", "TARGET_POWER10", "||", "!", "TARGET_VSX", ")", "return", "0", ";", "if", "(", "vsx_const", "->", "words", "[", "1", "]", "!=", "0", "||", "vsx_const", "->", "words", "[", "2", "]", "!=", "0", "||", "vsx_const", "->", "words", "[", "3", "]", "!=", "0", ")", "return", "0", ";", "switch", "(", "vsx_const", "->", "words", "[", "0", "]", ")", "{", "case", "0x3FFF0000U", ":", "return", "1", ";", "case", "0x40000000U", ":", "return", "2", ";", "case", "0x40008000U", ":", "return", "3", ";", "case", "0x40010000U", ":", "return", "4", ";", "case", "0x40014000U", ":", "return", "5", ";", "case", "0x40018000U", ":", "return", "6", ";", "case", "0x4001C000U", ":", "return", "7", ";", "case", "0x7FFF0000U", ":", "return", "8", ";", "case", "0x7FFF8000U", ":", "return", "9", ";", "case", "0x80000000U", ":", "return", "16", ";", "case", "0xBFFF0000U", ":", "return", "17", ";", "case", "0xC0000000U", ":", "return", "18", ";", "case", "0xC0008000U", ":", "return", "19", ";", "case", "0xC0010000U", ":", "return", "20", ";", "case", "0xC0014000U", ":", "return", "21", ";", "case", "0xC0018000U", ":", "return", "22", ";", "case", "0xC001C000U", ":", "return", "23", ";", "case", "0xFFFF0000U", ":", "return", "24", ";", "default", ":", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Determine", "if", "an", "IEEE", "128-bit", "constant", "can", "be", "loaded", "with", "LXVKQ", ".", "Return", "zero", "if", "the", "LXVKQ", "instruction", "can", "not", "be", "used", ".", "Otherwise", "return", "the", "immediate", "value", "to", "be", "used", "with", "the", "LXVKQ", "instruction", "." ]

[ "rs6000", "0", "1", "0", "2", "0", "3", "0", "0", "0", "0x3FFF0000U", "1", "0x40000000U", "2", "0x40008000U", "3", "0x40010000U", "4", "0x40014000U", "5", "0x40018000U", "6", "0x4001C000U", "7", "0x7FFF0000U", "8", "0x7FFF8000U", "9", "0x80000000U", "16", "0xBFFF0000U", "17", "0xC0000000U", "18", "0xC0008000U", "19", "0xC0010000U", "20", "0xC0014000U", "21", "0xC0018000U", "22", "0xC001C000U", "23", "0xFFFF0000U", "24", "0" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"TriCore Assembly Printer\"", ";", "}", "</s>" ]

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

[ "TriCore", "\"TriCore Assembly Printer\"" ]

[]

[ "<s>", "int", "m32c_hard_regno_nregs", "(", "int", "regno", ",", "machine_mode", "mode", ")", "{", "int", "rv", "=", "m32c_hard_regno_nregs_1", "(", "regno", ",", "mode", ")", ";", "return", "rv", "?", "rv", ":", "1", ";", "}", "</s>" ]

[ "Implements", "HARD_REGNO_NREGS", ".", "This", "is", "complicated", "by", "the", "fact", "that", "different", "registers", "are", "different", "sizes", "from", "each", "other", ",", "*", "and", "*", "may", "be", "different", "sizes", "in", "different", "chip", "families", "." ]

[ "m32c", "1" ]

[]

[ "<s>", "static", "void", "iq2000_select_rtx_section", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "unsigned", "HOST_WIDE_INT", "align", ")", "{", "mergeable_constant_section", "(", "mode", ",", "align", ",", "0", ")", ";", "}", "</s>" ]

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

[ "iq2000", "0" ]

[]

[ "<s>", "bool", "HexagonRDFOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "RDFLimit", ".", "getPosition", "(", ")", ")", "{", "if", "(", "RDFCount", ">=", "RDFLimit", ")", "return", "false", ";", "RDFCount", "++", ";", "}", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "const", "auto", "&", "MDF", "=", "getAnalysis", "<", "MachineDominanceFrontier", ">", "(", ")", ";", "const", "auto", "&", "HII", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "const", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", ";", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"Before \"", "<<", "getPassName", "(", ")", "<<", "\"\\n\"", ",", "nullptr", ")", ";", "HexagonRegisterAliasInfo", "HAI", "(", "HRI", ")", ";", "TargetOperandInfo", "TOI", "(", "HII", ")", ";", "DataFlowGraph", "G", "(", "MF", ",", "HII", ",", "HRI", ",", "*", "MDT", ",", "MDF", ",", "HAI", ",", "TOI", ")", ";", "G", ".", "build", "(", ")", ";", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "\"Starting copy propagation on: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'\\n'", ";", "HexagonCP", "CP", "(", "G", ")", ";", "CP", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "=", "CP", ".", "run", "(", ")", ";", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "\"Starting dead code elimination on: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", "<<", "PrintNode", "<", "FuncNode", "*", ">", "(", "G", ".", "getFunc", "(", ")", ",", "G", ")", "<<", "'\\n'", ";", "HexagonDCE", "DCE", "(", "G", ",", "*", "MRI", ")", ";", "DCE", ".", "trace", "(", "RDFDump", ")", ";", "Changed", "|=", "DCE", ".", "run", "(", ")", ";", "if", "(", "Changed", ")", "{", "if", "(", "RDFDump", ")", "dbgs", "(", ")", "<<", "\"Starting liveness recomputation on: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ";", "Liveness", "LV", "(", "*", "MRI", ",", "G", ")", ";", "LV", ".", "trace", "(", "RDFDump", ")", ";", "LV", ".", "computeLiveIns", "(", ")", ";", "LV", ".", "resetLiveIns", "(", ")", ";", "LV", ".", "resetKills", "(", ")", ";", "}", "if", "(", "RDFDump", ")", "MF", ".", "print", "(", "dbgs", "(", ")", "<<", "\"After \"", "<<", "getPassName", "(", ")", "<<", "\"\\n\"", ",", "nullptr", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "\"Before \"", "\"\\n\"", "Hexagon", "\"Starting copy propagation on: \"", "Hexagon", "\"Starting dead code elimination on: \"", "Hexagon", "\"Starting liveness recomputation on: \"", "\"After \"", "\"\\n\"" ]

[]

[ "<s>", "static", "rtx", "restore_gprs", "(", "rtx", "base", ",", "int", "offset", ",", "int", "first", ",", "int", "last", ")", "{", "rtx", "addr", ",", "insn", ";", "addr", "=", "plus_constant", "(", "Pmode", ",", "base", ",", "offset", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "if", "(", "first", "==", "last", ")", "{", "if", "(", "TARGET_64BIT", ")", "insn", "=", "gen_movdi", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ")", ";", "else", "insn", "=", "gen_movsi", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "insn", "=", "gen_load_multiple", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ",", "GEN_INT", "(", "last", "-", "first", "+", "1", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "return", "insn", ";", "}", "</s>" ]

[ "Generate", "insn", "to", "restore", "registers", "FIRST", "to", "LAST", "from", "the", "register", "save", "area", "located", "at", "offset", "OFFSET", "relative", "to", "register", "BASE", "." ]

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

[]

[ "<s>", "const", "char", "*", "vax_output_conditional_branch", "(", "enum", "rtx_code", "code", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "return", "\"jeql %l0\"", ";", "case", "NE", ":", "return", "\"jneq %l0\"", ";", "case", "GT", ":", "return", "\"jgtr %l0\"", ";", "case", "LT", ":", "return", "\"jlss %l0\"", ";", "case", "GTU", ":", "return", "\"jgtru %l0\"", ";", "case", "LTU", ":", "return", "\"jlssu %l0\"", ";", "case", "GE", ":", "return", "\"jgeq %l0\"", ";", "case", "LE", ":", "return", "\"jleq %l0\"", ";", "case", "GEU", ":", "return", "\"jgequ %l0\"", ";", "case", "LEU", ":", "return", "\"jlequ %l0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "conditional", "branch", "." ]

[ "vax", "\"jeql %l0\"", "\"jneq %l0\"", "\"jgtr %l0\"", "\"jlss %l0\"", "\"jgtru %l0\"", "\"jlssu %l0\"", "\"jgeq %l0\"", "\"jleq %l0\"", "\"jgequ %l0\"", "\"jlequ %l0\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "getInlineAsmLength", "(", "const", "char", "*", "Str", ",", "const", "MCAsmInfo", "&", "MAI", ")", "const", "{", "StringRef", "AStr", "(", "Str", ")", ";", "bool", "atInsnStart", "=", "true", ";", "unsigned", "Length", "=", "0", ";", "for", "(", ";", "*", "Str", ";", "++", "Str", ")", "{", "if", "(", "*", "Str", "==", "'\\n'", "||", "strncmp", "(", "Str", ",", "MAI", ".", "getSeparatorString", "(", ")", ",", "strlen", "(", "MAI", ".", "getSeparatorString", "(", ")", ")", ")", "==", "0", ")", "atInsnStart", "=", "true", ";", "if", "(", "atInsnStart", "&&", "!", "std", "::", "isspace", "(", "static_cast", "<", "unsigned", "char", ">", "(", "*", "Str", ")", ")", ")", "{", "Length", "+=", "MAI", ".", "getMaxInstLength", "(", ")", ";", "atInsnStart", "=", "false", ";", "}", "if", "(", "atInsnStart", "&&", "strncmp", "(", "Str", ",", "MAI", ".", "getCommentString", "(", ")", ",", "strlen", "(", "MAI", ".", "getCommentString", "(", ")", ")", ")", "==", "0", ")", "atInsnStart", "=", "false", ";", "}", "StringRef", "Occ", "(", "\"##\"", ")", ";", "Length", "+=", "AStr", ".", "count", "(", "Occ", ")", "*", "4", ";", "return", "Length", ";", "}", "</s>" ]

[ "Measure", "the", "specified", "inline", "asm", "to", "determine", "an", "approximation", "of", "its", "length", "." ]

[ "Hexagon", "Hexagon", "0", "0", "0", "\"##\"", "4" ]

[]

[ "<s>", "bool", "Tile64VLIWPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "Tile64VLIWPacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ",", "MDT", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ",", "MBBb", "=", "MBB", "->", "begin", "(", ")", ";", "RegionEnd", "!=", "MBBb", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBBb", ";", "--", "I", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "llvm", "::", "prior", "(", "I", ")", ",", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "MachineBasicBlock", "::", "iterator", "priorEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "if", "(", "I", "==", "RegionEnd", "||", "I", "==", "priorEnd", ")", "{", "RegionEnd", "=", "priorEnd", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "MBB", ",", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Tile64", "\"Empty DFA table!\"" ]

[]

[ "<s>", "void", "merge", "(", "const", "PredicatedBlock", "*", "b2", ")", "{", "InstrPred", ".", "insert", "(", "b2", "->", "InstrPred", ".", "begin", "(", ")", ",", "b2", "->", "InstrPred", ".", "end", "(", ")", ")", ";", "Definitions", ".", "insert", "(", "Definitions", ".", "end", "(", ")", ",", "b2", "->", "Definitions", ".", "begin", "(", ")", ",", "b2", "->", "Definitions", ".", "end", "(", ")", ")", ";", "ExitTargets", ".", "insert", "(", "ExitTargets", ".", "end", "(", ")", ",", "b2", "->", "ExitTargets", ".", "begin", "(", ")", ",", "b2", "->", "ExitTargets", ".", "end", "(", ")", ")", ";", "Remnants", ".", "insert", "(", "b2", "->", "Remnants", ".", "begin", "(", ")", ",", "b2", "->", "Remnants", ".", "end", "(", ")", ")", ";", "Remnants", ".", "insert", "(", "b2", "->", "getMBB", "(", ")", ")", ";", "Successors", ".", "insert", "(", "b2", "->", "Successors", ".", "begin", "(", ")", ",", "b2", "->", "Successors", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Merge", "target", "triples", "." ]

[ "Patmos" ]

[]

[ "<s>", "bool", "nios2_validate_compare", "(", "machine_mode", "mode", ",", "rtx", "*", "cmp", ",", "rtx", "*", "op1", ",", "rtx", "*", "op2", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "*", "cmp", ")", ";", "enum", "rtx_code", "alt_code", ";", "rtx", "alt_op2", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", ")", "return", "nios2_validate_fpu_compare", "(", "mode", ",", "cmp", ",", "op1", ",", "op2", ",", "true", ")", ";", "if", "(", "!", "reg_or_0_operand", "(", "*", "op2", ",", "mode", ")", ")", "{", "nios2_alternate_compare_const", "(", "code", ",", "*", "op2", ",", "&", "alt_code", ",", "&", "alt_op2", ",", "mode", ")", ";", "if", "(", "alt_op2", "==", "const0_rtx", ")", "{", "code", "=", "alt_code", ";", "*", "op2", "=", "alt_op2", ";", "goto", "check_rebuild_cmp", ";", "}", "if", "(", "nios2_valid_compare_const_p", "(", "code", ",", "*", "op2", ")", ")", "return", "true", ";", "else", "if", "(", "nios2_valid_compare_const_p", "(", "alt_code", ",", "alt_op2", ")", ")", "{", "code", "=", "alt_code", ";", "*", "op2", "=", "alt_op2", ";", "goto", "rebuild_cmp", ";", "}", "if", "(", "!", "nios2_simple_const_p", "(", "*", "op2", ")", "&&", "nios2_simple_const_p", "(", "alt_op2", ")", ")", "{", "code", "=", "alt_code", ";", "*", "op2", "=", "alt_op2", ";", "}", "*", "op2", "=", "force_reg", "(", "SImode", ",", "*", "op2", ")", ";", "}", "check_rebuild_cmp", ":", "if", "(", "code", "==", "GT", "||", "code", "==", "GTU", "||", "code", "==", "LE", "||", "code", "==", "LEU", ")", "{", "rtx", "t", "=", "*", "op1", ";", "*", "op1", "=", "*", "op2", ";", "*", "op2", "=", "t", ";", "code", "=", "swap_condition", "(", "code", ")", ";", "}", "rebuild_cmp", ":", "*", "cmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "mode", ",", "*", "op1", ",", "*", "op2", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Checks", "and", "modifies", "the", "comparison", "in", "*", "CMP", ",", "*", "OP1", ",", "and", "*", "OP2", "into", "valid", "nios2", "supported", "form", ".", "Returns", "true", "if", "success", "." ]

[ "nios2" ]

[]

[ "<s>", "static", "int", "attr_strcmp", "(", "const", "void", "*", "v1", ",", "const", "void", "*", "v2", ")", "{", "const", "char", "*", "c1", "=", "*", "(", "char", "*", "const", "*", ")", "v1", ";", "const", "char", "*", "c2", "=", "*", "(", "char", "*", "const", "*", ")", "v2", ";", "return", "strcmp", "(", "c1", ",", "c2", ")", ";", "}", "</s>" ]

[ "Comparator", "function", "to", "be", "used", "in", "qsort", "routine", "to", "sort", "attribute", "specification", "strings", "to", "``", "target", "''", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "PatmosAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "ParsePrefix", "(", "NameLoc", ",", "Operands", ",", "Name", ")", ";", "MCAsmLexer", "&", "Lexer", "=", "getLexer", "(", ")", ";", "if", "(", "Name", "==", "\"{\"", ")", "{", "if", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "Identifier", ")", "&&", "Lexer", ".", "isNot", "(", "AsmToken", "::", "String", ")", ")", "{", "return", "Error", "(", "Lexer", ".", "getLoc", "(", ")", ",", "\"Couldn't find Mnemonic\"", ")", ";", "}", "Name", "=", "getTok", "(", ")", ".", "getIdentifier", "(", ")", ";", "NameLoc", "=", "Lexer", ".", "getLoc", "(", ")", ";", "Lex", "(", ")", ";", "}", "size_t", "Next", "=", "Name", ".", "find", "(", "'.'", ")", ";", "StringRef", "Mnemonic", "=", "Name", ".", "slice", "(", "0", ",", "Next", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", ",", "std", "::", "unique_ptr", "<", "MCParsedAsmOperand", ">", "(", "PatmosOperand", "::", "CreateToken", "(", "Mnemonic", ",", "NameLoc", ")", ")", ")", ";", "if", "(", "Next", "!=", "StringRef", "::", "npos", ")", "{", "StringRef", "Format", "=", "Name", ".", "slice", "(", "Next", ",", "StringRef", "::", "npos", ")", ";", "Operands", ".", "insert", "(", "Operands", ".", "begin", "(", ")", "+", "1", ",", "std", "::", "unique_ptr", "<", "MCParsedAsmOperand", ">", "(", "PatmosOperand", "::", "CreateToken", "(", "Format", ",", "NameLoc", ")", ")", ")", ";", "}", "ParseGuard", "(", "NameLoc", ",", "Operands", ")", ";", "unsigned", "OpNo", "=", "0", ";", "while", "(", "Lexer", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "RCurly", ")", ")", "{", "if", "(", "!", "InBundle", ")", "{", "SMLoc", "TokLoc", "=", "Lexer", ".", "getLoc", "(", ")", ";", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "TokLoc", ",", "\"found bundle end marker without a matching \"", "\"start marker\"", ")", ";", "}", "InBundle", "=", "false", ";", "Lexer", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "if", "(", "OpNo", "==", "0", ")", "{", "SMLoc", "TokLoc", "=", "Lexer", ".", "getLoc", "(", ")", ";", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "TokLoc", ",", "\"comma before first operand\"", ")", ";", "}", "Lex", "(", ")", ";", "}", "else", "if", "(", "Lexer", ".", "is", "(", "AsmToken", "::", "Equal", ")", ")", "{", "if", "(", "ParseToken", "(", "Operands", ",", "AsmToken", "::", "Equal", ")", ")", "{", "EatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "OpNo", ">", "0", ")", "{", "SMLoc", "TokLoc", "=", "Lexer", ".", "getLoc", "(", ")", ";", "EatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "TokLoc", ",", "\"missing separator between operands or instructions\"", ")", ";", "}", "if", "(", "ParseOperand", "(", "Operands", ",", "OpNo", ")", ")", "{", "EatToEndOfStatement", "(", ")", ";", "return", "true", ";", "}", "OpNo", "++", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "Patmos", "Patmos", "\"{\"", "\"Couldn't find Mnemonic\"", "0", "Patmos", "1", "Patmos", "0", "\"found bundle end marker without a matching \"", "\"start marker\"", "0", "\"comma before first operand\"", "0", "\"missing separator between operands or instructions\"" ]

[]

[ "<s>", "bool", "MCS51AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "bool", "Error", "=", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ";", "if", "(", "Error", "&&", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "if", "(", "ExtraCode", "[", "0", "]", ">=", "'A'", "&&", "ExtraCode", "[", "0", "]", "<=", "'Z'", ")", "{", "const", "MachineOperand", "&", "RegOp", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "assert", "(", "RegOp", ".", "isReg", "(", ")", "&&", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", ")", ";", "Register", "Reg", "=", "RegOp", ".", "getReg", "(", ")", ";", "unsigned", "ByteNumber", "=", "ExtraCode", "[", "0", "]", "-", "'A'", ";", "unsigned", "OpFlags", "=", "MI", "->", "getOperand", "(", "OpNum", "-", "1", ")", ".", "getImm", "(", ")", ";", "unsigned", "NumOpRegs", "=", "InlineAsm", "::", "getNumOperandRegisters", "(", "OpFlags", ")", ";", "(", "void", ")", "NumOpRegs", ";", "const", "MCS51Subtarget", "&", "STI", "=", "MF", "->", "getSubtarget", "<", "MCS51Subtarget", ">", "(", ")", ";", "const", "TargetRegisterInfo", "&", "TRI", "=", "*", "STI", ".", "getRegisterInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", ".", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "unsigned", "BytesPerReg", "=", "TRI", ".", "getRegSizeInBits", "(", "*", "RC", ")", "/", "8", ";", "assert", "(", "BytesPerReg", "<=", "2", "&&", "\"Only 8 and 16 bit regs are supported.\"", ")", ";", "unsigned", "RegIdx", "=", "ByteNumber", "/", "BytesPerReg", ";", "assert", "(", "RegIdx", "<", "NumOpRegs", "&&", "\"Multibyte index out of range.\"", ")", ";", "Reg", "=", "MI", "->", "getOperand", "(", "OpNum", "+", "RegIdx", ")", ".", "getReg", "(", ")", ";", "if", "(", "BytesPerReg", "==", "2", ")", "{", "Reg", "=", "TRI", ".", "getSubReg", "(", "Reg", ",", "ByteNumber", "%", "BytesPerReg", "?", "MCS51", "::", "sub_hi", ":", "MCS51", "::", "sub_lo", ")", ";", "}", "O", "<<", "MCS51InstPrinter", "::", "getPrettyRegisterName", "(", "Reg", ",", "MRI", ")", ";", "return", "false", ";", "}", "}", "if", "(", "Error", ")", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "MCS51", "MCS51", "0", "1", "0", "0", "0", "\"Operand must be a register when you're\"", "\"using 'A'..'Z' operand extracodes.\"", "0", "1", "MCS51", "MCS51", "8", "2", "\"Only 8 and 16 bit regs are supported.\"", "\"Multibyte index out of range.\"", "2", "MCS51::sub_hi", "MCS51::sub_lo", "MCS51" ]

[]

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

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

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

[]

[ "<s>", "bool", "Thumb1FrameInfo", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tPUSH", ")", ")", ";", "AddDefaultPred", "(", "MIB", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "true", ";", "if", "(", "Reg", "==", "ARM", "::", "LR", ")", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "if", "(", "MF", ".", "getFrameInfo", "(", ")", "->", "isReturnAddressTaken", "(", ")", "&&", "MF", ".", "getRegInfo", "(", ")", ".", "isLiveIn", "(", "Reg", ")", ")", "isKill", "=", "false", ";", "}", "if", "(", "isKill", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "MIB", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM::tPUSH", "0", "1", "ARM::LR" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">>", "WebAssemblyInstrInfo", "::", "getSerializableTargetIndices", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "int", ",", "const", "char", "*", ">", "TargetIndices", "[", "]", "=", "{", "{", "WebAssembly", "::", "TI_LOCAL", ",", "\"wasm-local\"", "}", ",", "{", "WebAssembly", "::", "TI_GLOBAL_FIXED", ",", "\"wasm-global-fixed\"", "}", ",", "{", "WebAssembly", "::", "TI_OPERAND_STACK", ",", "\"wasm-operand-stack\"", "}", ",", "{", "WebAssembly", "::", "TI_GLOBAL_RELOC", ",", "\"wasm-global-reloc\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetIndices", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "ids", "of", "the", "target", "indices", "(", "used", "for", "the", "TargetIndex", "machine", "operand", ")", "and", "their", "names", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::TI_LOCAL", "\"wasm-local\"", "WebAssembly::TI_GLOBAL_FIXED", "\"wasm-global-fixed\"", "WebAssembly::TI_OPERAND_STACK", "\"wasm-operand-stack\"", "WebAssembly::TI_GLOBAL_RELOC", "\"wasm-global-reloc\"" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "static", "int", "s390_sched_variable_issue", "(", "FILE", "*", "file", ",", "int", "verbose", ",", "rtx_insn", "*", "insn", ",", "int", "more", ")", "{", "last_scheduled_insn", "=", "insn", ";", "if", "(", "s390_tune", "==", "PROCESSOR_2827_ZEC12", "&&", "reload_completed", "&&", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "{", "unsigned", "int", "mask", "=", "s390_get_sched_attrmask", "(", "insn", ")", ";", "if", "(", "(", "mask", "&", "S390_OOO_SCHED_ATTR_MASK_CRACKED", ")", "!=", "0", "||", "(", "mask", "&", "S390_OOO_SCHED_ATTR_MASK_EXPANDED", ")", "!=", "0", ")", "s390_sched_state", "=", "S390_OOO_SCHED_STATE_CRACKED", ";", "else", "if", "(", "(", "mask", "&", "S390_OOO_SCHED_ATTR_MASK_ENDGROUP", ")", "!=", "0", "||", "(", "mask", "&", "S390_OOO_SCHED_ATTR_MASK_GROUPALONE", ")", "!=", "0", ")", "s390_sched_state", "=", "S390_OOO_SCHED_STATE_NORMAL", ";", "else", "{", "switch", "(", "s390_sched_state", ")", "{", "case", "0", ":", "case", "1", ":", "case", "2", ":", "case", "S390_OOO_SCHED_STATE_NORMAL", ":", "if", "(", "s390_sched_state", "==", "S390_OOO_SCHED_STATE_NORMAL", ")", "s390_sched_state", "=", "1", ";", "else", "s390_sched_state", "++", ";", "break", ";", "case", "S390_OOO_SCHED_STATE_CRACKED", ":", "s390_sched_state", "=", "S390_OOO_SCHED_STATE_NORMAL", ";", "break", ";", "}", "}", "if", "(", "verbose", ">", "5", ")", "{", "fprintf", "(", "file", ",", "\"insn %d: \"", ",", "INSN_UID", "(", "insn", ")", ")", ";", "fprintf", "(", "file", ",", "\"%s \"", ",", "get_attr_", "##", "ATTR", "(", "insn", ")", "?", "#", "ATTR", ":", "\"\"", ")", ";", "PRINT_OOO_ATTR", "(", "ooo_cracked", ")", ";", "PRINT_OOO_ATTR", "(", "ooo_expanded", ")", ";", "PRINT_OOO_ATTR", "(", "ooo_endgroup", ")", ";", "PRINT_OOO_ATTR", "(", "ooo_groupalone", ")", ";", "fprintf", "(", "file", ",", "\"\\n\"", ")", ";", "fprintf", "(", "file", ",", "\"sched state: %d\\n\"", ",", "s390_sched_state", ")", ";", "}", "}", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "USE", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "CLOBBER", ")", "return", "more", "-", "1", ";", "else", "return", "more", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "via", "hook", "TARGET_SCHED_VARIABLE_ISSUE", "after", "the", "scheduler", "has", "issued", "INSN", ".", "It", "stores", "the", "last", "issued", "insn", "into", "last_scheduled_insn", "in", "order", "to", "make", "it", "available", "for", "s390_sched_reorder", "." ]

[ "s390", "0", "0", "0", "0", "0", "0", "1", "2", "1", "5", "\"insn %d: \"", "\"%s \"", "\"\"", "\"\\n\"", "\"sched state: %d\\n\"", "1" ]

[]

[ "<s>", "tree", "ix86_valid_target_attribute_tree", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "const", "char", "*", "orig_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "const", "char", "*", "orig_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "enum", "fpmath_unit", "orig_fpmath_set", "=", "opts_set", "->", "x_ix86_fpmath", ";", "int", "orig_tune_defaulted", "=", "ix86_tune_defaulted", ";", "int", "orig_arch_specified", "=", "ix86_arch_specified", ";", "char", "*", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_MAX", "]", "=", "{", "NULL", ",", "NULL", "}", ";", "tree", "t", "=", "NULL_TREE", ";", "struct", "cl_target_option", "*", "def", "=", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ";", "struct", "gcc_options", "enum_opts_set", ";", "memset", "(", "&", "enum_opts_set", ",", "0", ",", "sizeof", "(", "enum_opts_set", ")", ")", ";", "if", "(", "!", "ix86_valid_target_attribute_inner_p", "(", "args", ",", "option_strings", ",", "opts", ",", "opts_set", ",", "&", "enum_opts_set", ")", ")", "return", "error_mark_node", ";", "if", "(", "opts", "->", "x_ix86_isa_flags", "!=", "def", "->", "x_ix86_isa_flags", "||", "opts", "->", "x_ix86_isa_flags2", "!=", "def", "->", "x_ix86_isa_flags2", "||", "opts", "->", "x_target_flags", "!=", "def", "->", "x_target_flags", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", "||", "enum_opts_set", ".", "x_ix86_fpmath", ")", "{", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", "{", "opts", "->", "x_ix86_arch_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", ";", "opts", "->", "x_ix86_isa_flags", "&=", "(", "OPTION_MASK_ISA_64BIT", "|", "OPTION_MASK_ABI_64", "|", "OPTION_MASK_ABI_X32", "|", "OPTION_MASK_CODE16", ")", ";", "opts", "->", "x_ix86_isa_flags2", "=", "0", ";", "}", "else", "if", "(", "!", "orig_arch_specified", ")", "opts", "->", "x_ix86_arch_string", "=", "NULL", ";", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", "opts", "->", "x_ix86_tune_string", "=", "ggc_strdup", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", ";", "else", "if", "(", "orig_tune_defaulted", ")", "opts", "->", "x_ix86_tune_string", "=", "NULL", ";", "if", "(", "enum_opts_set", ".", "x_ix86_fpmath", ")", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "else", "if", "(", "!", "TARGET_64BIT_P", "(", "opts", "->", "x_ix86_isa_flags", ")", "&&", "TARGET_SSE_P", "(", "opts", "->", "x_ix86_isa_flags", ")", ")", "{", "if", "(", "TARGET_80387_P", "(", "opts", "->", "x_target_flags", ")", ")", "opts", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "(", "FPMATH_SSE", "|", "FPMATH_387", ")", ";", "else", "opts", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "FPMATH_SSE", ";", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "}", "bool", "r", "=", "ix86_option_override_internal", "(", "false", ",", "opts", ",", "opts_set", ")", ";", "if", "(", "!", "r", ")", "{", "release_options_strings", "(", "option_strings", ")", ";", "return", "error_mark_node", ";", "}", "ix86_add_new_builtins", "(", "opts", "->", "x_ix86_isa_flags", ",", "opts", "->", "x_ix86_isa_flags2", ")", ";", "t", "=", "build_target_option_node", "(", "opts", ")", ";", "opts", "->", "x_ix86_arch_string", "=", "orig_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "orig_tune_string", ";", "opts_set", "->", "x_ix86_fpmath", "=", "orig_fpmath_set", ";", "release_options_strings", "(", "option_strings", ")", ";", "}", "return", "t", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "int", "avr_regs_to_save", "(", "HARD_REG_SET", "*", "set", ")", "{", "int", "count", ";", "int", "int_or_sig_p", "=", "cfun", "->", "machine", "->", "is_interrupt", "||", "cfun", "->", "machine", "->", "is_signal", ";", "if", "(", "set", ")", "CLEAR_HARD_REG_SET", "(", "*", "set", ")", ";", "count", "=", "0", ";", "if", "(", "TREE_THIS_VOLATILE", "(", "current_function_decl", ")", "||", "cfun", "->", "machine", "->", "is_OS_task", "||", "cfun", "->", "machine", "->", "is_OS_main", ")", "return", "0", ";", "for", "(", "int", "reg", "=", "0", ";", "reg", "<", "32", ";", "reg", "++", ")", "{", "if", "(", "fixed_regs", "[", "reg", "]", ")", "continue", ";", "if", "(", "(", "int_or_sig_p", "&&", "!", "crtl", "->", "is_leaf", "&&", "call_used_regs", "[", "reg", "]", ")", "||", "(", "df_regs_ever_live_p", "(", "reg", ")", "&&", "(", "int_or_sig_p", "||", "!", "call_used_regs", "[", "reg", "]", ")", "&&", "!", "(", "frame_pointer_needed", "&&", "(", "reg", "==", "REG_Y", "||", "reg", "==", "REG_Y", "+", "1", ")", ")", ")", ")", "{", "if", "(", "set", ")", "SET_HARD_REG_BIT", "(", "*", "set", ",", "reg", ")", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "hard", "registers", "to", "push/pop", "in", "the", "prologue/epilogue", "of", "the", "current", "function", ",", "and", "optionally", "store", "these", "registers", "in", "SET", "." ]

[ "avr", "0", "0", "0", "32", "1" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "ARMFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "&", "Old", "=", "*", "I", ";", "DebugLoc", "dl", "=", "Old", ".", "getDebugLoc", "(", ")", ";", "unsigned", "Amount", "=", "Old", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "alignSPAdjust", "(", "Amount", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This eliminateCallFramePseudoInstr does not support Thumb1!\"", ")", ";", "bool", "isARM", "=", "!", "AFI", "->", "isThumbFunction", "(", ")", ";", "unsigned", "Opc", "=", "Old", ".", "getOpcode", "(", ")", ";", "int", "PIdx", "=", "Old", ".", "findFirstPredOperandIdx", "(", ")", ";", "ARMCC", "::", "CondCodes", "Pred", "=", "(", "PIdx", "==", "-", "1", ")", "?", "ARMCC", "::", "AL", ":", "(", "ARMCC", "::", "CondCodes", ")", "Old", ".", "getOperand", "(", "PIdx", ")", ".", "getImm", "(", ")", ";", "if", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKDOWN", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKDOWN", ")", "{", "unsigned", "PredReg", "=", "Old", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "-", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "else", "{", "unsigned", "PredReg", "=", "Old", ".", "getOperand", "(", "3", ")", ".", "getReg", "(", ")", ";", "assert", "(", "Opc", "==", "ARM", "::", "ADJCALLSTACKUP", "||", "Opc", "==", "ARM", "::", "tADJCALLSTACKUP", ")", ";", "emitSPUpdate", "(", "isARM", ",", "MBB", ",", "I", ",", "dl", ",", "TII", ",", "Amount", ",", "MachineInstr", "::", "NoFlags", ",", "Pred", ",", "PredReg", ")", ";", "}", "}", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "0", "0", "ARM", "ARM", "\"This eliminateCallFramePseudoInstr does not support Thumb1!\"", "ARM", "ARMCC::CondCodes", "1", "ARMCC::AL", "ARMCC::CondCodes", "ARM::ADJCALLSTACKDOWN", "ARM::tADJCALLSTACKDOWN", "2", "ARM", "3", "ARM::ADJCALLSTACKUP", "ARM::tADJCALLSTACKUP", "ARM" ]

[]

[ "<s>", "bool", "P2AsmParser", "::", "ParseDirective", "(", "llvm", "::", "AsmToken", "DirectiveID", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"Parse directive: \"", "<<", "DirectiveID", ".", "getString", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "P2", "P2", "\"Parse directive: \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", ")", "const", "{", "return", "(", "(", "!", "DisablePPC32RS", "&&", "!", "Subtarget", ".", "isPPC64", "(", ")", ")", "||", "(", "!", "DisablePPC64RS", "&&", "Subtarget", ".", "isPPC64", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

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

[]

[ "<s>", "static", "bool", "aarch64_sve_only_stmt_p", "(", "stmt_vec_info", "stmt_info", ",", "tree", "vectype", ")", "{", "if", "(", "!", "aarch64_sve_mode_p", "(", "TYPE_MODE", "(", "vectype", ")", ")", ")", "return", "false", ";", "if", "(", "STMT_VINFO_DATA_REF", "(", "stmt_info", ")", ")", "{", "if", "(", "STMT_VINFO_GATHER_SCATTER_P", "(", "stmt_info", ")", ")", "return", "true", ";", "if", "(", "auto", "*", "call", "=", "dyn_cast", "<", "gcall", "*", ">", "(", "stmt_info", "->", "stmt", ")", ")", "if", "(", "gimple_call_internal_p", "(", "call", ")", "&&", "internal_fn_mask_index", "(", "gimple_call_internal_fn", "(", "call", ")", ")", ">=", "0", ")", "return", "true", ";", "}", "auto", "*", "assign", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "stmt_info", "->", "stmt", ")", ";", "if", "(", "assign", "&&", "gimple_assign_rhs_code", "(", "assign", ")", "==", "MULT_EXPR", "&&", "GET_MODE_INNER", "(", "TYPE_MODE", "(", "vectype", ")", ")", "==", "DImode", "&&", "!", "integer_pow2p", "(", "gimple_assign_rhs2", "(", "assign", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "vectorized", "form", "of", "STMT_INFO", "is", "something", "that", "is", "only", "possible", "when", "using", "SVE", "instead", "of", "Advanced", "SIMD", ".", "VECTYPE", "is", "the", "type", "of", "the", "vector", "that", "STMT_INFO", "is", "operating", "on", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "bool", "RV16KAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "RV16K", "RV16K" ]

[]

[ "<s>", "unsigned", "AArch64FastISel", "::", "fastMaterializeAlloca", "(", "const", "AllocaInst", "*", "AI", ")", "{", "assert", "(", "TLI", ".", "getValueType", "(", "AI", "->", "getType", "(", ")", ",", "true", ")", "==", "MVT", "::", "i64", "&&", "\"Alloca should always return a pointer.\"", ")", ";", "if", "(", "!", "FuncInfo", ".", "StaticAllocaMap", ".", "count", "(", "AI", ")", ")", "return", "0", ";", "DenseMap", "<", "const", "AllocaInst", "*", ",", "int", ">", "::", "iterator", "SI", "=", "FuncInfo", ".", "StaticAllocaMap", ".", "find", "(", "AI", ")", ";", "if", "(", "SI", "!=", "FuncInfo", ".", "StaticAllocaMap", ".", "end", "(", ")", ")", "{", "unsigned", "ResultReg", "=", "createResultReg", "(", "&", "AArch64", "::", "GPR64spRegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "AArch64", "::", "ADDXri", ")", ",", "ResultReg", ")", ".", "addFrameIndex", "(", "SI", "->", "second", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "return", "ResultReg", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Emit", "an", "alloca", "address", "in", "a", "register", "using", "target-specific", "logic", "." ]

[ "AArch64", "AArch64", "MVT::i64", "\"Alloca should always return a pointer.\"", "0", "AArch64::GPR64spRegClass", "AArch64::ADDXri", "0", "0", "0" ]

[]

[ "<s>", "bool", "SSACCmpConv", "::", "isDeadDef", "(", "unsigned", "DstReg", ")", "{", "if", "(", "DstReg", "==", "AArch64", "::", "WZR", "||", "DstReg", "==", "AArch64", "::", "XZR", ")", "return", "true", ";", "if", "(", "!", "Register", "::", "isVirtualRegister", "(", "DstReg", ")", ")", "return", "false", ";", "return", "MRI", "->", "use_nodbg_empty", "(", "DstReg", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "instruction", "has", "a", "dead", "def", "." ]

[ "AArch64", "AArch64::WZR", "AArch64::XZR" ]

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "TuneAttr", "=", "F", ".", "getFnAttribute", "(", "\"tune-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "CPUAttr", ".", "isValid", "(", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "TuneCPU", "=", "TuneAttr", ".", "isValid", "(", ")", "?", "TuneAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "CPU", ";", "StringRef", "FS", "=", "FSAttr", ".", "isValid", "(", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "unsigned", "PreferVectorWidthOverride", "=", "0", ";", "Attribute", "PreferVecWidthAttr", "=", "F", ".", "getFnAttribute", "(", "\"prefer-vector-width\"", ")", ";", "if", "(", "PreferVecWidthAttr", ".", "isValid", "(", ")", ")", "{", "StringRef", "Val", "=", "PreferVecWidthAttr", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\"prefer-vector-width=\"", ";", "Key", "+=", "Val", ";", "PreferVectorWidthOverride", "=", "Width", ";", "}", "}", "unsigned", "RequiredVectorWidth", "=", "UINT32_MAX", ";", "Attribute", "MinLegalVecWidthAttr", "=", "F", ".", "getFnAttribute", "(", "\"min-legal-vector-width\"", ")", ";", "if", "(", "MinLegalVecWidthAttr", ".", "isValid", "(", ")", ")", "{", "StringRef", "Val", "=", "MinLegalVecWidthAttr", ".", "getValueAsString", "(", ")", ";", "unsigned", "Width", ";", "if", "(", "!", "Val", ".", "getAsInteger", "(", "0", ",", "Width", ")", ")", "{", "Key", "+=", "\"min-legal-vector-width=\"", ";", "Key", "+=", "Val", ";", "RequiredVectorWidth", "=", "Width", ";", "}", "}", "Key", "+=", "CPU", ";", "Key", "+=", "\"tune=\"", ";", "Key", "+=", "TuneCPU", ";", "unsigned", "FSStart", "=", "Key", ".", "size", "(", ")", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\"+soft-float,\"", ";", "Key", "+=", "FS", ";", "FS", "=", "Key", ".", "substr", "(", "FSStart", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "std", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "TuneCPU", ",", "FS", ",", "*", "this", ",", "MaybeAlign", "(", "Options", ".", "StackAlignmentOverride", ")", ",", "PreferVectorWidthOverride", ",", "RequiredVectorWidth", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"tune-cpu\"", "\"target-features\"", "512", "0", "\"prefer-vector-width\"", "0", "\"prefer-vector-width=\"", "\"min-legal-vector-width\"", "0", "\"min-legal-vector-width=\"", "\"tune=\"", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\"+soft-float,\"", "X86" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Cpu0", "Cpu0", "ISD::BRCOND", "ISD::GlobalAddress" ]

[]

[ "<s>", "static", "void", "mips_block_move_loop", "(", "rtx", "dest", ",", "rtx", "src", ",", "HOST_WIDE_INT", "length", ",", "HOST_WIDE_INT", "bytes_per_iter", ")", "{", "rtx_code_label", "*", "label", ";", "rtx", "src_reg", ",", "dest_reg", ",", "final_src", ",", "test", ";", "HOST_WIDE_INT", "leftover", ";", "leftover", "=", "length", "%", "bytes_per_iter", ";", "length", "-=", "leftover", ";", "mips_adjust_block_mem", "(", "src", ",", "bytes_per_iter", ",", "&", "src_reg", ",", "&", "src", ")", ";", "mips_adjust_block_mem", "(", "dest", ",", "bytes_per_iter", ",", "&", "dest_reg", ",", "&", "dest", ")", ";", "final_src", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "src_reg", ",", "GEN_INT", "(", "length", ")", ",", "0", ",", "0", ",", "OPTAB_WIDEN", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label", "(", "label", ")", ";", "mips_block_move_straight", "(", "dest", ",", "src", ",", "bytes_per_iter", ")", ";", "mips_emit_move", "(", "src_reg", ",", "plus_constant", "(", "Pmode", ",", "src_reg", ",", "bytes_per_iter", ")", ")", ";", "mips_emit_move", "(", "dest_reg", ",", "plus_constant", "(", "Pmode", ",", "dest_reg", ",", "bytes_per_iter", ")", ")", ";", "test", "=", "gen_rtx_NE", "(", "VOIDmode", ",", "src_reg", ",", "final_src", ")", ";", "if", "(", "Pmode", "==", "DImode", ")", "emit_jump_insn", "(", "gen_cbranchdi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "else", "emit_jump_insn", "(", "gen_cbranchsi4", "(", "test", ",", "src_reg", ",", "final_src", ",", "label", ")", ")", ";", "if", "(", "leftover", ")", "mips_block_move_straight", "(", "dest", ",", "src", ",", "leftover", ")", ";", "}", "</s>" ]

[ "Move", "LENGTH", "bytes", "from", "SRC", "to", "DEST", "using", "a", "loop", "that", "moves", "MAX_MOVE_BYTES", "per", "iteration", ".", "LENGTH", "must", "be", "at", "least", "MAX_MOVE_BYTES", ".", "Assume", "that", "the", "memory", "regions", "do", "not", "overlap", "." ]

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

[]

[ "<s>", "void", "SystemZTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "KnownBits", "&", "Known", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "Known", ".", "getBitWidth", "(", ")", ";", "Known", ".", "resetAll", "(", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "SystemZISD", "::", "SELECT_CCMASK", ":", "{", "KnownBits", "TrueKnown", "(", "BitWidth", ")", ",", "FalseKnown", "(", "BitWidth", ")", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "TrueKnown", ",", "Depth", "+", "1", ")", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "FalseKnown", ",", "Depth", "+", "1", ")", ";", "Known", ".", "Zero", "=", "TrueKnown", ".", "Zero", "&", "FalseKnown", ".", "Zero", ";", "Known", ".", "One", "=", "TrueKnown", ".", "One", "&", "FalseKnown", ".", "One", ";", "break", ";", "}", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "SystemZ", "SystemZ", "SystemZISD::SELECT_CCMASK", "0", "1", "1", "1" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "swapOperands", "(", "MachineBasicBlock", "::", "iterator", "Inst", ")", "const", "{", "assert", "(", "Inst", "->", "getNumExplicitOperands", "(", ")", "==", "3", ")", ";", "MachineOperand", "Op1", "=", "Inst", "->", "getOperand", "(", "1", ")", ";", "Inst", "->", "RemoveOperand", "(", "1", ")", ";", "Inst", "->", "addOperand", "(", "Op1", ")", ";", "}", "</s>" ]

[ "Exchange", "the", "two", "operands", "to", "this", "instruction", "in", "such", "a", "way", "that", "it", "does", "not", "modify", "the", "semantics", "of", "the", "instruction", "." ]

[ "R600", "SI", "3", "1", "1" ]

[]

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

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "Mips" ]

[]

[ "<s>", "static", "int", "length_for_loop", "(", "rtx_insn", "*", "insn", ")", "{", "int", "length", "=", "0", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "any_condjump_p", "(", "insn", ")", "&&", "!", "optimize_size", ")", "{", "if", "(", "ENABLE_WA_SPECULATIVE_SYNCS", ")", "length", "=", "8", ";", "else", "if", "(", "ENABLE_WA_SPECULATIVE_LOADS", ")", "length", "=", "6", ";", "}", "else", "if", "(", "LABEL_P", "(", "insn", ")", ")", "{", "if", "(", "ENABLE_WA_SPECULATIVE_SYNCS", ")", "length", "=", "4", ";", "}", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "length", "+=", "get_attr_length", "(", "insn", ")", ";", "return", "length", ";", "}", "</s>" ]

[ "Estimate", "the", "length", "of", "INSN", "conservatively", "." ]

[ "bfin", "0", "8", "6", "4" ]

[]

[ "<s>", "static", "int", "unspec_cmla", "(", "int", "rot", ")", "{", "switch", "(", "rot", ")", "{", "case", "0", ":", "return", "UNSPEC_CMLA", ";", "case", "90", ":", "return", "UNSPEC_CMLA90", ";", "case", "180", ":", "return", "UNSPEC_CMLA180", ";", "case", "270", ":", "return", "UNSPEC_CMLA270", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "parallel", "*", "nvptx_find_par", "(", "bb_insn_map_t", "*", "map", ",", "parallel", "*", "par", ",", "basic_block", "block", ")", "{", "if", "(", "block", "->", "flags", "&", "BB_VISITED", ")", "return", "par", ";", "block", "->", "flags", "|=", "BB_VISITED", ";", "if", "(", "rtx_insn", "*", "*", "endp", "=", "map", "->", "get", "(", "block", ")", ")", "{", "rtx_insn", "*", "end", "=", "*", "endp", ";", "switch", "(", "recog_memoized", "(", "end", ")", ")", "{", "case", "CODE_FOR_return", ":", "return", "par", ";", "case", "CODE_FOR_nvptx_forked", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "mask", ")", ";", "par", "=", "new", "parallel", "(", "par", ",", "mask", ")", ";", "par", "->", "forked_block", "=", "block", ";", "par", "->", "forked_insn", "=", "end", ";", "if", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", "par", "->", "fork_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_fork", ")", ";", "}", "break", ";", "case", "CODE_FOR_nvptx_join", ":", "{", "unsigned", "mask", "=", "UINTVAL", "(", "XVECEXP", "(", "PATTERN", "(", "end", ")", ",", "0", ",", "0", ")", ")", ";", "gcc_assert", "(", "par", "->", "mask", "==", "mask", ")", ";", "par", "->", "join_block", "=", "block", ";", "par", "->", "join_insn", "=", "end", ";", "if", "(", "mask", "&", "GOMP_DIM_MASK", "(", "GOMP_DIM_WORKER", ")", ")", "par", "->", "joining_insn", "=", "nvptx_discover_pre", "(", "block", ",", "CODE_FOR_nvptx_joining", ")", ";", "par", "=", "par", "->", "parent", ";", "}", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "par", ")", "par", "->", "blocks", ".", "safe_push", "(", "block", ")", ";", "else", "par", "=", "new", "parallel", "(", "0", ",", "0", ")", ";", "edge", "e", ";", "edge_iterator", "ei", ";", "FOR_EACH_EDGE", "(", "e", ",", "ei", ",", "block", "->", "succs", ")", "nvptx_find_par", "(", "map", ",", "par", ",", "e", "->", "dest", ")", ";", "return", "par", ";", "}", "</s>" ]

[ "See", "also", "'gcc/omp-oacc-neuter-broadcast.cc", ":", "omp_sese_find_par", "'", "." ]

[ "nvptx", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "pa_output_function_epilogue", "(", "FILE", "*", "file", ",", "HOST_WIDE_INT", "size", "ATTRIBUTE_UNUSED", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "bool", "extra_nop", ";", "if", "(", "NOTE_P", "(", "insn", ")", ")", "insn", "=", "prev_real_insn", "(", "insn", ")", ";", "if", "(", "insn", "&&", "NONJUMP_INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SEQUENCE", ")", "insn", "=", "as_a", "<", "rtx_sequence", "*", ">", "(", "PATTERN", "(", "insn", ")", ")", "->", "insn", "(", "0", ")", ";", "if", "(", "insn", "&&", "CALL_P", "(", "insn", ")", ")", "{", "fputs", "(", "\"\\tnop\\n\"", ",", "file", ")", ";", "extra_nop", "=", "true", ";", "}", "else", "extra_nop", "=", "false", ";", "fputs", "(", "\"\\t.EXIT\\n\\t.PROCEND\\n\"", ",", "file", ")", ";", "if", "(", "TARGET_SOM", "&&", "TARGET_GAS", ")", "{", "in_section", "=", "NULL", ";", "cfun", "->", "machine", "->", "in_nsubspa", "=", "2", ";", "}", "if", "(", "cfun", "->", "is_thunk", ")", "return", ";", "if", "(", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "last_address", "=", "extra_nop", "?", "4", ":", "0", ";", "insn", "=", "get_last_nonnote_insn", "(", ")", ";", "if", "(", "insn", ")", "{", "last_address", "+=", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", ")", "last_address", "+=", "insn_default_length", "(", "insn", ")", ";", "}", "last_address", "=", "(", "(", "last_address", "+", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", "&", "~", "(", "FUNCTION_BOUNDARY", "/", "BITS_PER_UNIT", "-", "1", ")", ")", ";", "}", "else", "last_address", "=", "UINT_MAX", ";", "update_total_code_bytes", "(", "last_address", ")", ";", "}", "</s>" ]

[ "This", "function", "generates", "the", "assembly", "code", "for", "function", "exit", ".", "Args", "are", "as", "for", "output_function_prologue", "(", ")", ".", "The", "function", "epilogue", "should", "not", "depend", "on", "the", "current", "stack", "pointer", "!", "It", "should", "use", "the", "frame", "pointer", "only", ".", "This", "is", "mandatory", "because", "of", "alloca", ";", "we", "also", "take", "advantage", "of", "it", "to", "omit", "stack", "adjustments", "before", "returning", "." ]

[ "pa", "0", "\"\\tnop\\n\"", "\"\\t.EXIT\\n\\t.PROCEND\\n\"", "2", "4", "0", "1", "1" ]

[]

[ "<s>", "void", "ARMAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "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", "." ]

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "bool", "LEGRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "LEG", "LEG" ]

[]

[ "<s>", "static", "void", "arm_print_value", "(", "FILE", "*", "f", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "fprintf", "(", "f", ",", "\"<0x%lx,0x%lx>\"", ",", "(", "long", ")", "XWINT", "(", "x", ",", "2", ")", ",", "(", "long", ")", "XWINT", "(", "x", ",", "3", ")", ")", ";", "return", ";", "case", "CONST_VECTOR", ":", "{", "int", "i", ";", "fprintf", "(", "f", ",", "\"<\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "i", "++", ")", "{", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", ")", ";", "if", "(", "i", "<", "(", "CONST_VECTOR_NUNITS", "(", "x", ")", "-", "1", ")", ")", "fputc", "(", "','", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "\">\"", ")", ";", "}", "return", ";", "case", "CONST_STRING", ":", "fprintf", "(", "f", ",", "\"\\\"%s\\\"\"", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "SYMBOL_REF", ":", "fprintf", "(", "f", ",", "\"`%s'\"", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "LABEL_REF", ":", "fprintf", "(", "f", ",", "\"L%d\"", ",", "INSN_UID", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "return", ";", "case", "CONST", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "PLUS", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "f", ",", "\"+\"", ")", ";", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "return", ";", "case", "PC", ":", "fprintf", "(", "f", ",", "\"pc\"", ")", ";", "return", ";", "default", ":", "fprintf", "(", "f", ",", "\"????\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Print", "a", "symbolic", "form", "of", "X", "to", "the", "debug", "file", ",", "F", "." ]

[ "arm", "\"<0x%lx,0x%lx>\"", "2", "3", "\"<\"", "0", "1", "\">\"", "\"\\\"%s\\\"\"", "0", "\"`%s'\"", "0", "\"L%d\"", "0", "0", "0", "\"+\"", "1", "\"pc\"", "\"????\"" ]

[]

[ "<s>", "const", "LegalizerInfo", "*", "getLegalizerInfo", "(", ")", "const", "override", "{", "return", "Legalizer", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Expose", "LegalizerInfo", "so", "the", "clients", "can", "re-use", "." ]

[ "SPIRV" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "PPCScoreboardHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "return", "ScoreboardHazardRecognizer", "::", "getHazardType", "(", "SU", ",", "Stalls", ")", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "PPCTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'b'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RC_NOX0RegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRC_NOR0RegClass", ")", ";", "case", "'r'", ":", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "GPRCRegClass", ")", ";", "case", "'f'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", "||", "VT", "==", "MVT", "::", "i32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F4RCRegClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", "||", "VT", "==", "MVT", "::", "i64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "F8RCRegClass", ")", ";", "break", ";", "case", "'v'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VRRCRegClass", ")", ";", "case", "'y'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRRCRegClass", ")", ";", "}", "}", "else", "if", "(", "Constraint", "==", "\"wc\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "CRBITRCRegClass", ")", ";", "}", "else", "if", "(", "Constraint", "==", "\"wa\"", "||", "Constraint", "==", "\"wd\"", "||", "Constraint", "==", "\"wf\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VSRCRegClass", ")", ";", "}", "else", "if", "(", "Constraint", "==", "\"ws\"", ")", "{", "return", "std", "::", "make_pair", "(", "0U", ",", "&", "PPC", "::", "VSFRCRegClass", ")", ";", "}", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "R", "=", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "if", "(", "R", ".", "first", "&&", "VT", "==", "MVT", "::", "i64", "&&", "PPCSubTarget", ".", "isPPC64", "(", ")", "&&", "PPC", "::", "GPRCRegClass", ".", "contains", "(", "R", ".", "first", ")", ")", "{", "const", "TargetRegisterInfo", "*", "TRI", "=", "getTargetMachine", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "return", "std", "::", "make_pair", "(", "TRI", "->", "getMatchingSuperReg", "(", "R", ".", "first", ",", "PPC", "::", "sub_32", ",", "&", "PPC", "::", "G8RCRegClass", ")", ",", "&", "PPC", "::", "G8RCRegClass", ")", ";", "}", "return", "R", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "1", "0", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RC_NOX0RegClass", "0U", "PPC::GPRC_NOR0RegClass", "MVT::i64", "PPC", "PPC", "0U", "PPC::G8RCRegClass", "0U", "PPC::GPRCRegClass", "MVT::f32", "MVT::i32", "0U", "PPC::F4RCRegClass", "MVT::f64", "MVT::i64", "0U", "PPC::F8RCRegClass", "0U", "PPC::VRRCRegClass", "0U", "PPC::CRRCRegClass", "\"wc\"", "0U", "PPC::CRBITRCRegClass", "\"wa\"", "\"wd\"", "\"wf\"", "0U", "PPC::VSRCRegClass", "\"ws\"", "0U", "PPC::VSFRCRegClass", "MVT::i64", "PPC", "PPC", "PPC::GPRCRegClass", "PPC::sub_32", "PPC::G8RCRegClass", "PPC::G8RCRegClass" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "reMaterialize", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "const", "MachineInstr", "*", "Orig", ",", "const", "TargetRegisterInfo", "&", "TRI", ")", "const", "{", "bool", "ClobbersEFLAGS", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "Orig", "->", "operands", "(", ")", ")", "{", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "isDef", "(", ")", "&&", "MO", ".", "getReg", "(", ")", "==", "X86", "::", "EFLAGS", ")", "{", "ClobbersEFLAGS", "=", "true", ";", "break", ";", "}", "}", "if", "(", "ClobbersEFLAGS", "&&", "!", "isSafeToClobberEFLAGS", "(", "MBB", ",", "I", ")", ")", "{", "int", "Value", ";", "switch", "(", "Orig", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "MOV32r0", ":", "Value", "=", "0", ";", "break", ";", "case", "X86", "::", "MOV32r1", ":", "Value", "=", "1", ";", "break", ";", "case", "X86", "::", "MOV32r_1", ":", "Value", "=", "-", "1", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected instruction!\"", ")", ";", "}", "DebugLoc", "DL", "=", "Orig", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "X86", "::", "MOV32ri", ")", ")", ".", "addOperand", "(", "Orig", "->", "getOperand", "(", "0", ")", ")", ".", "addImm", "(", "Value", ")", ";", "}", "else", "{", "MachineInstr", "*", "MI", "=", "MBB", ".", "getParent", "(", ")", "->", "CloneMachineInstr", "(", "Orig", ")", ";", "MBB", ".", "insert", "(", "I", ",", "MI", ")", ";", "}", "MachineInstr", "*", "NewMI", "=", "std", "::", "prev", "(", "I", ")", ";", "NewMI", "->", "substituteRegister", "(", "Orig", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ",", "DestReg", ",", "SubIdx", ",", "TRI", ")", ";", "}", "</s>" ]

[ "Re-issue", "the", "specified", "'original", "'", "instruction", "at", "the", "specific", "location", "targeting", "a", "new", "destination", "register", "." ]

[ "X86", "X86", "X86::EFLAGS", "X86::MOV32r0", "0", "X86::MOV32r1", "1", "X86::MOV32r_1", "1", "\"Unexpected instruction!\"", "X86::MOV32ri", "0", "0" ]

[]

[ "<s>", "const", "char", "*", "host_detect_local_cpu", "(", "int", "argc", ",", "const", "char", "*", "*", "argv", ")", "{", "const", "char", "*", "cpu", ";", "bool", "arch", ";", "if", "(", "argc", "<", "1", ")", "return", "NULL", ";", "arch", "=", "strcmp", "(", "argv", "[", "0", "]", ",", "\"cpu\"", ")", "==", "0", ";", "if", "(", "!", "arch", "&&", "strcmp", "(", "argv", "[", "0", "]", ",", "\"tune\"", ")", ")", "return", "NULL", ";", "if", "(", "arch", ")", "cpu", "=", "\"powerpc\"", ";", "return", "concat", "(", "\"-m\"", ",", "argv", "[", "0", "]", ",", "\"=\"", ",", "cpu", ",", "NULL", ")", ";", "}", "</s>" ]

[ "This", "will", "be", "called", "by", "the", "spec", "parser", "in", "gcc.cc", "when", "it", "sees", "a", "%", ":", "local_cpu_detect", "(", "args", ")", "construct", ".", "Currently", "it", "will", "be", "called", "with", "either", "``", "cpu", "''", "or", "``", "tune", "''", "as", "argument", "depending", "on", "if", "-mcpu=native", "or", "-mtune=native", "is", "to", "be", "substituted", ".", "It", "returns", "a", "string", "containing", "new", "command", "line", "parameters", "to", "be", "put", "at", "the", "place", "of", "the", "above", "two", "options", ",", "depending", "on", "what", "CPU", "this", "is", "executed", ".", "E.g", ".", "``", "-mcpu=ultrasparc3", "''", "on", "an", "UltraSPARC", "III", "for", "-mcpu=native", ".", "If", "the", "routine", "ca", "n't", "detect", "a", "known", "processor", ",", "the", "-mcpu", "or", "-mtune", "option", "is", "discarded", ".", "ARGC", "and", "ARGV", "are", "set", "depending", "on", "the", "actual", "arguments", "given", "in", "the", "spec", "." ]

[ "powerpcspe", "1", "0", "\"cpu\"", "0", "0", "\"tune\"", "\"powerpc\"", "\"-m\"", "0", "\"=\"" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_reciprocal", "(", "tree", "fndecl", ")", "{", "switch", "(", "DECL_MD_FUNCTION_CODE", "(", "fndecl", ")", ")", "{", "case", "VSX_BUILTIN_XVSQRTDP", ":", "if", "(", "!", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "V2DFmode", ")", ")", "return", "NULL_TREE", ";", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RSQRT_2DF", "]", ";", "case", "VSX_BUILTIN_XVSQRTSP", ":", "if", "(", "!", "RS6000_RECIP_AUTO_RSQRTE_P", "(", "V4SFmode", ")", ")", "return", "NULL_TREE", ";", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RSQRT_4SF", "]", ";", "default", ":", "return", "NULL_TREE", ";", "}", "}", "</s>" ]

[ "Returns", "a", "code", "for", "a", "target-specific", "builtin", "that", "implements", "reciprocal", "of", "the", "function", ",", "or", "NULL_TREE", "if", "not", "available", "." ]

[ "rs6000" ]

[]

[ "<s>", "SDNode", "*", "OR1KDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "Node", ")", "{", "unsigned", "Opcode", "=", "Node", "->", "getOpcode", "(", ")", ";", "DebugLoc", "dl", "=", "Node", "->", "getDebugLoc", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Selecting: \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "Node", "->", "isMachineOpcode", "(", ")", ")", "{", "DEBUG", "(", "errs", "(", ")", "<<", "\"== \"", ";", "Node", "->", "dump", "(", "CurDAG", ")", ";", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "NULL", ";", "}", "switch", "(", "Opcode", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "FrameIndex", ":", "{", "SDValue", "imm", "=", "CurDAG", "->", "getTargetConstant", "(", "0", ",", "MVT", "::", "i32", ")", ";", "int", "FI", "=", "dyn_cast", "<", "FrameIndexSDNode", ">", "(", "Node", ")", "->", "getIndex", "(", ")", ";", "EVT", "VT", "=", "Node", "->", "getValueType", "(", "0", ")", ";", "SDValue", "TFI", "=", "CurDAG", "->", "getTargetFrameIndex", "(", "FI", ",", "VT", ")", ";", "unsigned", "Opc", "=", "OR1K", "::", "ADDI", ";", "if", "(", "Node", "->", "hasOneUse", "(", ")", ")", "return", "CurDAG", "->", "SelectNodeTo", "(", "Node", ",", "Opc", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "return", "CurDAG", "->", "getMachineNode", "(", "Opc", ",", "dl", ",", "VT", ",", "TFI", ",", "imm", ")", ";", "}", "}", "SDNode", "*", "ResNode", "=", "SelectCode", "(", "Node", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"=> \"", ")", ";", "if", "(", "ResNode", "==", "NULL", "||", "ResNode", "==", "Node", ")", "DEBUG", "(", "Node", "->", "dump", "(", "CurDAG", ")", ")", ";", "else", "DEBUG", "(", "ResNode", "->", "dump", "(", "CurDAG", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\n\"", ")", ";", "return", "ResNode", ";", "}", "</s>" ]

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

[ "OR1K", "OR1K", "\"Selecting: \"", "\"\\n\"", "\"== \"", "\"\\n\"", "ISD::FrameIndex", "0", "MVT::i32", "0", "OR1K::ADDI", "\"=> \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "MipsTargetLowering", "::", "IsEligibleForTailCallOptimization", "(", "const", "MipsCC", "&", "MipsCCInfo", ",", "unsigned", "NextStackOffset", ",", "const", "MipsFunctionInfo", "&", "FI", ")", "const", "{", "if", "(", "!", "EnableMipsTailCalls", ")", "return", "false", ";", "if", "(", "Subtarget", "->", "inMips16Mode", "(", ")", ")", "return", "false", ";", "if", "(", "MipsCCInfo", ".", "hasByValArg", "(", ")", "||", "FI", ".", "hasByvalArg", "(", ")", ")", "return", "false", ";", "return", "NextStackOffset", "<=", "FI", ".", "getIncomingArgSize", "(", ")", ";", "}", "</s>" ]

[ "IsEligibleForTailCallOptimization", "-", "Check", "whether", "the", "call", "is", "eligible", "for", "tail", "call", "optimization", "." ]

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

[]

[ "<s>", "static", "rtx", "aarch64_gen_load_pair", "(", "machine_mode", "mode", ",", "rtx", "reg1", ",", "rtx", "mem1", ",", "rtx", "reg2", ",", "rtx", "mem2", ")", "{", "switch", "(", "mode", ")", "{", "case", "E_DImode", ":", "return", "gen_load_pairdi", "(", "reg1", ",", "mem1", ",", "reg2", ",", "mem2", ")", ";", "case", "E_DFmode", ":", "return", "gen_load_pairdf", "(", "reg1", ",", "mem1", ",", "reg2", ",", "mem2", ")", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Generate", "and", "regurn", "a", "load", "pair", "isntruction", "of", "mode", "MODE", "to", "load", "register", "REG1", "from", "MEM1", "and", "register", "REG2", "from", "MEM2", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "const", "MachineOperand", "&", "getLdStOffsetOp", "(", "const", "MachineInstr", "&", "MI", ")", "{", "unsigned", "Idx", "=", "isPairedLdSt", "(", "MI", ")", "?", "3", ":", "2", ";", "return", "MI", ".", "getOperand", "(", "Idx", ")", ";", "}", "</s>" ]

[ "Returns", "the", "immediate", "offset", "operator", "of", "a", "load/store", "." ]

[ "AArch64", "3", "2" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Hexagon optimize redundant zero and size extends\"", ";", "}", "</s>" ]

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

[ "Hexagon", "\"Hexagon optimize redundant zero and size extends\"" ]

[]

[ "<s>", "static", "machine_mode", "rx_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "funtype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", ")", "{", "if", "(", "for_return", "!=", "1", "||", "GET_MODE_SIZE", "(", "mode", ")", ">=", "4", "||", "COMPLEX_MODE_P", "(", "mode", ")", "||", "GET_MODE_SIZE", "(", "mode", ")", "<", "1", ")", "return", "mode", ";", "return", "SImode", ";", "}", "</s>" ]

[ "TARGET_PROMOTE_FUNCTION_MODE", "must", "behave", "in", "the", "same", "way", "with", "regard", "to", "function", "returns", "as", "does", "TARGET_FUNCTION_VALUE", "." ]

[ "rx", "1", "4", "1" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "assignCalleeSavedSpillSlots", "(", "MachineFunction", "&", "MF", ",", "const", "TargetRegisterInfo", "*", "TRI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "X86MachineFunctionInfo", "*", "X86FI", "=", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", ";", "unsigned", "CalleeSavedFrameSize", "=", "0", ";", "int", "SpillSlotOffset", "=", "getOffsetOfLocalArea", "(", ")", "+", "X86FI", "->", "getTCReturnAddrDelta", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "SpillSlotOffset", "-=", "SlotSize", ";", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "unsigned", "FPReg", "=", "TRI", "->", "getFrameRegister", "(", "MF", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "if", "(", "TRI", "->", "regsOverlap", "(", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ",", "FPReg", ")", ")", "{", "CSI", ".", "erase", "(", "CSI", ".", "begin", "(", ")", "+", "i", ")", ";", "break", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "SpillSlotOffset", "-=", "SlotSize", ";", "CalleeSavedFrameSize", "+=", "SlotSize", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "SlotSize", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "}", "X86FI", "->", "setCalleeSavedFrameSize", "(", "CalleeSavedFrameSize", ")", ";", "for", "(", "unsigned", "i", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "0", ";", "--", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "-", "1", "]", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "SpillSlotOffset", "-=", "std", "::", "abs", "(", "SpillSlotOffset", ")", "%", "RC", "->", "getAlignment", "(", ")", ";", "SpillSlotOffset", "-=", "RC", "->", "getSize", "(", ")", ";", "int", "SlotIndex", "=", "MFI", "->", "CreateFixedSpillStackObject", "(", "RC", "->", "getSize", "(", ")", ",", "SpillSlotOffset", ")", ";", "CSI", "[", "i", "-", "1", "]", ".", "setFrameIdx", "(", "SlotIndex", ")", ";", "MFI", "->", "ensureMaxAlignment", "(", "RC", "->", "getAlignment", "(", ")", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "X86", "0", "X86", "0", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1", "X86", "0", "1", "X86::GR64RegClass", "X86::GR32RegClass", "1" ]

[]

[ "<s>", "static", "rtx_insn", "*", "riscv_sr_match_epilogue", "(", "void", ")", "{", "rtx_insn", "*", "insn", ",", "*", "start", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", "!=", "NULL", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "NOTE_P", "(", "insn", ")", "&&", "NOTE_KIND", "(", "insn", ")", "==", "NOTE_INSN_EPILOGUE_BEG", ")", "{", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "break", ";", "}", "if", "(", "insn", "==", "NULL", ")", "return", "NULL", ";", "start", "=", "insn", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_stack_tiesi", "&&", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_stack_tiedi", ")", "return", "NULL", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "INSN_P", "(", "insn", ")", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_gpr_restore", ")", "return", "NULL", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_gpr_restore_return", ")", "return", "NULL", ";", "return", "start", ";", "}", "</s>" ]

[ "Find", "the", "first", "instruction", "in", "the", "epilogue", "of", "the", "current", "function", ",", "and", "return", "a", "pointer", "to", "that", "instruction", "if", ",", "and", "only", "if", ",", "the", "epilogue", "has", "the", "correct", "structure", "that", "would", "allow", "us", "to", "optimize", "out", "the", "call", "to", "_riscv_restore_0", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "e_funkind", "funkind", "(", "const_tree", "funtype", ")", "{", "tree", "attrs", "=", "TYPE_ATTRIBUTES", "(", "funtype", ")", ";", "if", "(", "lookup_attribute", "(", "\"interrupt_handler\"", ",", "attrs", ")", ")", "return", "INTERRUPT_HANDLER", ";", "else", "if", "(", "lookup_attribute", "(", "\"exception_handler\"", ",", "attrs", ")", ")", "return", "EXCPT_HANDLER", ";", "else", "if", "(", "lookup_attribute", "(", "\"nmi_handler\"", ",", "attrs", ")", ")", "return", "NMI_HANDLER", ";", "else", "return", "SUBROUTINE", ";", "}", "</s>" ]

[ "Examine", "machine-dependent", "attributes", "of", "function", "type", "FUNTYPE", "and", "return", "its", "type", ".", "See", "the", "definition", "of", "E_FUNKIND", "." ]

[ "bfin", "\"interrupt_handler\"", "\"exception_handler\"", "\"nmi_handler\"" ]

[]

[ "<s>", "bool", "NVVMReflect", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "NVVMReflectEnabled", ")", "return", "false", ";", "setVarMap", "(", ")", ";", "ReflectFunction", "=", "M", ".", "getFunction", "(", "NVVM_REFLECT_FUNCTION", ")", ";", "if", "(", "ReflectFunction", "==", "0", ")", "return", "false", ";", "assert", "(", "ReflectFunction", "->", "isDeclaration", "(", ")", "&&", "\"_reflect function should not have a body\"", ")", ";", "assert", "(", "ReflectFunction", "->", "getReturnType", "(", ")", "->", "isIntegerTy", "(", ")", "&&", "\"_reflect's return type should be integer\"", ")", ";", "std", "::", "vector", "<", "Instruction", "*", ">", "ToRemove", ";", "for", "(", "Value", "::", "use_iterator", "I", "=", "ReflectFunction", "->", "use_begin", "(", ")", ",", "E", "=", "ReflectFunction", "->", "use_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "assert", "(", "isa", "<", "CallInst", ">", "(", "*", "I", ")", "&&", "\"Only a call instruction can use _reflect\"", ")", ";", "CallInst", "*", "Reflect", "=", "cast", "<", "CallInst", ">", "(", "*", "I", ")", ";", "assert", "(", "(", "Reflect", "->", "getNumOperands", "(", ")", "==", "2", ")", "&&", "\"Only one operand expect for _reflect function\"", ")", ";", "const", "Value", "*", "conv", "=", "Reflect", "->", "getArgOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "CallInst", ">", "(", "conv", ")", "&&", "\"Expected a const-to-gen conversion\"", ")", ";", "const", "CallInst", "*", "ConvCall", "=", "cast", "<", "CallInst", ">", "(", "conv", ")", ";", "const", "Value", "*", "str", "=", "ConvCall", "->", "getArgOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "ConstantExpr", ">", "(", "str", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "ConstantExpr", "*", "GEP", "=", "cast", "<", "ConstantExpr", ">", "(", "str", ")", ";", "const", "Value", "*", "Sym", "=", "GEP", "->", "getOperand", "(", "0", ")", ";", "assert", "(", "isa", "<", "Constant", ">", "(", "Sym", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "const", "Constant", "*", "SymStr", "=", "cast", "<", "Constant", ">", "(", "Sym", ")", ";", "assert", "(", "isa", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "assert", "(", "cast", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "->", "isCString", "(", ")", "&&", "\"Format of _reflect function not recognized\"", ")", ";", "std", "::", "string", "ReflectArg", "=", "cast", "<", "ConstantDataSequential", ">", "(", "SymStr", "->", "getOperand", "(", "0", ")", ")", "->", "getAsString", "(", ")", ";", "ReflectArg", "=", "ReflectArg", ".", "substr", "(", "0", ",", "ReflectArg", ".", "size", "(", ")", "-", "1", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Arg of _reflect : \"", "<<", "ReflectArg", "<<", "\"\\n\"", ")", ";", "int", "ReflectVal", "=", "0", ";", "if", "(", "VarMap", ".", "find", "(", "ReflectArg", ")", "!=", "VarMap", ".", "end", "(", ")", ")", "{", "ReflectVal", "=", "VarMap", "[", "ReflectArg", "]", ";", "}", "Reflect", "->", "replaceAllUsesWith", "(", "ConstantInt", "::", "get", "(", "Reflect", "->", "getType", "(", ")", ",", "ReflectVal", ")", ")", ";", "ToRemove", ".", "push_back", "(", "Reflect", ")", ";", "}", "if", "(", "ToRemove", ".", "size", "(", ")", "==", "0", ")", "return", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ToRemove", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "ToRemove", "[", "i", "]", "->", "eraseFromParent", "(", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "NVPTX", "0", "\"_reflect function should not have a body\"", "\"_reflect's return type should be integer\"", "\"Only a call instruction can use _reflect\"", "2", "\"Only one operand expect for _reflect function\"", "0", "\"Expected a const-to-gen conversion\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "\"Format of _reflect function not recognized\"", "0", "0", "1", "\"Arg of _reflect : \"", "\"\\n\"", "0", "0", "0" ]

[]

[ "<s>", "TargetIRAnalysis", "NVPTXTargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "NVPTXTTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "alpha_split_lock_test_and_set", "(", "rtx", "retval", ",", "rtx", "mem", ",", "rtx", "val", ",", "rtx", "scratch", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "rtx", "label", ",", "x", ",", "cond", "=", "gen_lowpart", "(", "DImode", ",", "scratch", ")", ";", "emit_insn", "(", "gen_memory_barrier", "(", ")", ")", ";", "label", "=", "gen_rtx_LABEL_REF", "(", "DImode", ",", "gen_label_rtx", "(", ")", ")", ";", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "emit_load_locked", "(", "mode", ",", "retval", ",", "mem", ")", ";", "emit_move_insn", "(", "scratch", ",", "val", ")", ";", "emit_store_conditional", "(", "mode", ",", "cond", ",", "mem", ",", "scratch", ")", ";", "x", "=", "gen_rtx_EQ", "(", "DImode", ",", "cond", ",", "const0_rtx", ")", ";", "emit_unlikely_jump", "(", "x", ",", "label", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "exchange", "operation", "." ]

[ "alpha", "0" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "SIC" ]

[]