Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "tree", "def_builtin_const", "(", "const", "char", "*", "name", ",", "enum", "insn_code", "icode", ",", "enum", "sparc_builtins", "code", ",", "tree", "type", ")", "{", "tree", "t", "=", "def_builtin", "(", "name", ",", "icode", ",", "code", ",", "type", ")", ";", "if", "(", "t", ")", "TREE_READONLY", "(", "t", ")", "=", "1", ";", "return", "t", ";", "}", "</s>" ]

[ "Likewise", ",", "but", "also", "marks", "the", "function", "as", "``", "const", "''", "." ]

[ "sparc", "1" ]

[]

[ "<s>", "bool", "PPCDarwinAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "bool", "isPPC64", "=", "TM", ".", "getTargetData", "(", ")", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "const", "TargetLoweringObjectFileMachO", "&", "TLOFMacho", "=", "static_cast", "<", "const", "TargetLoweringObjectFileMachO", "&", ">", "(", "getObjFileLowering", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MMIMacho", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ";", "MachineModuleInfoMachO", "::", "SymbolListTy", "Stubs", "=", "MMIMacho", ".", "GetFnStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "EmitFunctionStubs", "(", "Stubs", ")", ";", "if", "(", "MAI", "->", "doesSupportExceptionHandling", "(", ")", "&&", "MMI", ")", "{", "const", "std", "::", "vector", "<", "const", "Function", "*", ">", "&", "Personalities", "=", "MMI", "->", "getPersonalities", "(", ")", ";", "for", "(", "std", "::", "vector", "<", "const", "Function", "*", ">", "::", "const_iterator", "I", "=", "Personalities", ".", "begin", "(", ")", ",", "E", "=", "Personalities", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "*", "I", ")", "{", "MCSymbol", "*", "NLPSym", "=", "GetSymbolWithGlobalValueBase", "(", "*", "I", ",", "\"$non_lazy_ptr\"", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMIMacho", ".", "getGVStubEntry", "(", "NLPSym", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Mang", "->", "getSymbol", "(", "*", "I", ")", ",", "true", ")", ";", "}", "}", "}", "Stubs", "=", "MMIMacho", ".", "GetGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "TLOFMacho", ".", "getNonLazySymbolPointerSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "MCSym", "=", "Stubs", "[", "i", "]", ".", "second", ";", "OutStreamer", ".", "EmitSymbolAttribute", "(", "MCSym", ".", "getPointer", "(", ")", ",", "MCSA_IndirectSymbol", ")", ";", "if", "(", "MCSym", ".", "getInt", "(", ")", ")", "OutStreamer", ".", "EmitIntValue", "(", "0", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "else", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "MCSym", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "Stubs", "=", "MMIMacho", ".", "GetHiddenGVStubList", "(", ")", ";", "if", "(", "!", "Stubs", ".", "empty", "(", ")", ")", "{", "OutStreamer", ".", "SwitchSection", "(", "getObjFileLowering", "(", ")", ".", "getDataSection", "(", ")", ")", ";", "EmitAlignment", "(", "isPPC64", "?", "3", ":", "2", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Stubs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "Stubs", "[", "i", "]", ".", "first", ")", ";", "OutStreamer", ".", "EmitValue", "(", "MCSymbolRefExpr", "::", "Create", "(", "Stubs", "[", "i", "]", ".", "second", ".", "getPointer", "(", ")", ",", "OutContext", ")", ",", "isPPC64", "?", "8", ":", "4", ",", "0", ")", ";", "}", "Stubs", ".", "clear", "(", ")", ";", "OutStreamer", ".", "AddBlankLine", "(", ")", ";", "}", "OutStreamer", ".", "EmitAssemblerFlag", "(", "MCAF_SubsectionsViaSymbols", ")", ";", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "64", "\"$non_lazy_ptr\"", "PPC", "3", "2", "0", "0", "PPC", "8", "4", "0", "PPC", "8", "4", "0", "PPC", "3", "2", "0", "PPC", "8", "4", "0" ]

[]

[ "<s>", "void", "RISCVMCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "unsigned", "Size", "=", "Desc", ".", "getSize", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoCALL", "||", "MI", ".", "getOpcode", "(", ")", "==", "RISCV", "::", "PseudoTAIL", ")", "{", "expandFunctionCall", "(", "MI", ",", "OS", ",", "Fixups", ",", "STI", ")", ";", "MCNumEmitted", "+=", "2", ";", "return", ";", "}", "switch", "(", "Size", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unhandled encodeInstruction length!\"", ")", ";", "case", "2", ":", "{", "uint16_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "<", "uint16_t", ">", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "case", "4", ":", "{", "uint32_t", "Bits", "=", "getBinaryCodeForInstr", "(", "MI", ",", "Fixups", ",", "STI", ")", ";", "support", "::", "endian", "::", "write", "(", "OS", ",", "Bits", ",", "support", "::", "little", ")", ";", "break", ";", "}", "}", "++", "MCNumEmitted", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "RISCV", "RISCV", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "2", "\"Unhandled encodeInstruction length!\"", "2", "support::endian", "support::little", "4", "support::endian", "support::little" ]

[]

[ "<s>", "void", "DCPU16RegisterInfo", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "uint64_t", "Amount", "=", "Old", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "!=", "0", ")", "{", "Amount", "=", "(", "Amount", "+", "StackAlign", "-", "1", ")", "/", "StackAlign", "*", "StackAlign", ";", "MachineInstr", "*", "New", "=", "0", ";", "if", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameSetupOpcode", "(", ")", ")", "{", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "DCPU16", "::", "SUB16ri", ")", ",", "DCPU16", "::", "SP", ")", ".", "addReg", "(", "DCPU16", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "else", "{", "assert", "(", "Old", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", ";", "uint64_t", "CalleeAmt", "=", "Old", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "Amount", "-=", "CalleeAmt", ";", "if", "(", "Amount", ")", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "DCPU16", "::", "ADD16ri", ")", ",", "DCPU16", "::", "SP", ")", ".", "addReg", "(", "DCPU16", "::", "SP", ")", ".", "addImm", "(", "Amount", ")", ";", "}", "if", "(", "New", ")", "{", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "}", "else", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TII", ".", "getCallFrameDestroyOpcode", "(", ")", ")", "{", "if", "(", "uint64_t", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "MachineInstr", "*", "Old", "=", "I", ";", "MachineInstr", "*", "New", "=", "BuildMI", "(", "MF", ",", "Old", "->", "getDebugLoc", "(", ")", ",", "TII", ".", "get", "(", "DCPU16", "::", "SUB16ri", ")", ",", "DCPU16", "::", "SP", ")", ".", "addReg", "(", "DCPU16", "::", "SP", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "New", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "MBB", ".", "insert", "(", "I", ",", "New", ")", ";", "}", "}", "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", ")", "." ]

[ "Dcpu16", "DCPU16", "0", "0", "1", "0", "DCPU16::SUB16ri", "DCPU16::SP", "DCPU16::SP", "1", "DCPU16::ADD16ri", "DCPU16::SP", "DCPU16::SP", "3", "1", "DCPU16::SUB16ri", "DCPU16::SP", "DCPU16::SP", "3" ]

[]

[ "<s>", "unsigned", "HSAILInstrInfo", "::", "isStoreToStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "!", "MCID", ".", "mayStore", "(", ")", "||", "!", "MI", "->", "hasOneMemOperand", "(", ")", ")", "return", "0", ";", "const", "MachineOperand", "*", "Segment", "=", "getNamedOperand", "(", "*", "MI", ",", "HSAIL", "::", "OpName", "::", "segment", ")", ";", "if", "(", "!", "Segment", "||", "Segment", "->", "getImm", "(", ")", "!=", "HSAILAS", "::", "SPILL_ADDRESS", ")", "return", "HSAIL", "::", "NoRegister", ";", "int", "AddressIdx", "=", "HSAIL", "::", "getNamedOperandIdx", "(", "MI", "->", "getOpcode", "(", ")", ",", "HSAIL", "::", "OpName", "::", "address", ")", ";", "const", "MachineOperand", "&", "Base", "=", "MI", "->", "getOperand", "(", "AddressIdx", "+", "HSAILADDRESS", "::", "BASE", ")", ";", "if", "(", "Base", ".", "isFI", "(", ")", ")", "{", "FrameIndex", "=", "Base", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "return", "HSAIL", "::", "NoRegister", ";", "}", "</s>" ]

[ "isStoreToStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "store", "to", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "source", "reg", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "HSAIL", "HSAIL", "0", "HSAIL::OpName", "HSAILAS::SPILL_ADDRESS", "HSAIL::NoRegister", "HSAIL::getNamedOperandIdx", "HSAIL::OpName", "HSAILADDRESS::BASE", "0", "HSAIL::NoRegister" ]

[]

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

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

[ "R600", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "int", "sparc_check_64", "(", "rtx", "x", ",", "rtx", "insn", ")", "{", "int", "set_once", "=", "0", ";", "rtx", "y", "=", "x", ";", "gcc_assert", "(", "GET_CODE", "(", "x", ")", "==", "REG", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "DImode", ")", "y", "=", "gen_rtx_REG", "(", "SImode", ",", "REGNO", "(", "x", ")", "+", "WORDS_BIG_ENDIAN", ")", ";", "if", "(", "flag_expensive_optimizations", "&&", "REG_N_SETS", "(", "REGNO", "(", "y", ")", ")", "==", "1", ")", "set_once", "=", "1", ";", "if", "(", "insn", "==", "0", ")", "{", "if", "(", "set_once", ")", "insn", "=", "get_last_insn_anywhere", "(", ")", ";", "else", "return", "0", ";", "}", "while", "(", "(", "insn", "=", "PREV_INSN", "(", "insn", ")", ")", ")", "{", "switch", "(", "GET_CODE", "(", "insn", ")", ")", "{", "case", "JUMP_INSN", ":", "case", "NOTE", ":", "break", ";", "case", "CODE_LABEL", ":", "case", "CALL_INSN", ":", "default", ":", "if", "(", "!", "set_once", ")", "return", "0", ";", "break", ";", "case", "INSN", ":", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "0", ";", "if", "(", "rtx_equal_p", "(", "x", ",", "SET_DEST", "(", "pat", ")", ")", ")", "return", "set_extends", "(", "insn", ")", ";", "if", "(", "y", "&&", "rtx_equal_p", "(", "y", ",", "SET_DEST", "(", "pat", ")", ")", ")", "return", "set_extends", "(", "insn", ")", ";", "if", "(", "reg_overlap_mentioned_p", "(", "SET_DEST", "(", "pat", ")", ",", "y", ")", ")", "return", "0", ";", "}", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "0", "if", "the", "high", "32", "bits", "of", "X", "(", "the", "low", "word", "of", "X", ",", "if", "DImode", ")", "are", "unknown", ".", "Return", "1", "if", "the", "high", "bits", "are", "zero", ",", "-1", "if", "the", "register", "is", "sign", "extended", "." ]

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

[]

[ "<s>", "const", "uint32_t", "*", "VERegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "Fast", ":", "default", ":", "return", "CSR_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "return", "CSR_preserve_all_RegMask", ";", "}", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "VE", "VE" ]

[]

[ "<s>", "bool", "HexagonFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "auto", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "bool", "HasFixed", "=", "MFI", ".", "getNumFixedObjects", "(", ")", ";", "bool", "HasPrealloc", "=", "const_cast", "<", "MachineFrameInfo", "&", ">", "(", "MFI", ")", ".", "getLocalFrameObjectCount", "(", ")", ";", "bool", "HasExtraAlign", "=", "HRI", ".", "needsStackRealignment", "(", "MF", ")", ";", "bool", "HasAlloca", "=", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "true", ";", "if", "(", "(", "HasFixed", "||", "HasPrealloc", ")", "&&", "(", "HasAlloca", "||", "HasExtraAlign", ")", ")", "return", "true", ";", "if", "(", "MFI", ".", "getStackSize", "(", ")", ">", "0", ")", "{", "if", "(", "UseAllocframe", ")", "return", "true", ";", "}", "if", "(", "MFI", ".", "hasCalls", "(", ")", "||", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasClobberLR", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "LoongArchAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "emitPseudoExpansionLowering", "(", "*", "OutStreamer", ",", "MI", ")", ")", "return", ";", "MCInst", "TmpInst", ";", "if", "(", "!", "lowerLoongArchMachineInstrToMCInst", "(", "MI", ",", "TmpInst", ",", "*", "this", ")", ")", "EmitToStreamer", "(", "*", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

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

[ "LoongArch", "LoongArch", "LoongArch" ]

[]

[ "<s>", "unsigned", "J2InstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "assert", "(", "!", "FBB", "&&", "\"Unconditional branch with multiple successors!\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "J2", "::", "BRA", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "llvm_unreachable", "(", "\"Unexpected conditional branch\"", ")", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "J2", "J2", "\"code size not handled\"", "\"Unconditional branch with multiple successors!\"", "J2::BRA", "1", "\"Unexpected conditional branch\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AMDGPURegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "if", "(", "TRI", "->", "isSGPRClass", "(", "&", "RC", ")", ")", "return", "getRegBank", "(", "AMDGPU", "::", "SGPRRegBankID", ")", ";", "return", "getRegBank", "(", "AMDGPU", "::", "VGPRRegBankID", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "AMDGPU::SGPRRegBankID", "AMDGPU::VGPRRegBankID" ]

[]

[ "<s>", "bool", "arc_profile_call", "(", "rtx", "callee", ")", "{", "rtx", "from", "=", "XEXP", "(", "DECL_RTL", "(", "current_function_decl", ")", ",", "0", ")", ";", "if", "(", "TARGET_UCB_MCOUNT", ")", "return", "false", ";", "if", "(", "CONSTANT_P", "(", "callee", ")", ")", "{", "rtx", "count_ptr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "from", ",", "callee", ",", "CONST0_RTX", "(", "Pmode", ")", ")", ",", "UNSPEC_PROF", ")", ")", ";", "rtx", "counter", "=", "gen_rtx_MEM", "(", "SImode", ",", "count_ptr", ")", ";", "emit_move_insn", "(", "counter", ",", "force_reg", "(", "SImode", ",", "plus_constant", "(", "SImode", ",", "counter", ",", "1", ")", ")", ")", ";", "return", "false", ";", "}", "else", "{", "rtx", "count_list_ptr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "from", ",", "CONST0_RTX", "(", "Pmode", ")", ",", "CONST0_RTX", "(", "Pmode", ")", ")", ",", "UNSPEC_PROF", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "8", ")", ",", "count_list_ptr", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "9", ")", ",", "callee", ")", ";", "return", "true", ";", "}", "}", "</s>" ]

[ "Emit", "profiling", "code", "for", "calling", "CALLEE", ".", "Return", "true", "if", "a", "special", "call", "pattern", "needs", "to", "be", "generated", "." ]

[ "arc", "0", "3", "1", "3", "8", "9" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"NVPTX DAG->DAG Pattern Instruction Selection\"", ";", "}", "</s>" ]

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

[ "NVPTX", "\"NVPTX DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "int", "arm_eliminable_register", "(", "rtx", "x", ")", "{", "return", "REG_P", "(", "x", ")", "&&", "(", "REGNO", "(", "x", ")", "==", "FRAME_POINTER_REGNUM", "||", "REGNO", "(", "x", ")", "==", "ARG_POINTER_REGNUM", "||", "(", "REGNO", "(", "x", ")", ">=", "FIRST_VIRTUAL_REGISTER", "&&", "REGNO", "(", "x", ")", "<=", "LAST_VIRTUAL_REGISTER", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "register", "that", "will", "be", "eliminated", "later", "on", "." ]

[ "arm" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "isReg", "(", ")", "&&", "\"Wrong CountValue accessor\"", ")", ";", "return", "Contents", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "Hexagon", "\"Wrong CountValue accessor\"" ]

[]

[ "<s>", "bool", "ARMAsmBackend", "::", "mayNeedRelaxation", "(", "const", "MCInst", "&", "Inst", ")", "const", "{", "if", "(", "getRelaxedOpcode", "(", "Inst", ".", "getOpcode", "(", ")", ")", "!=", "Inst", ".", "getOpcode", "(", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "whether", "the", "given", "instruction", "may", "need", "relaxation", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "iq2000_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "TARGET_DEBUG_D_MODE", ")", "{", "fprintf", "(", "stderr", ",", "\"function_adv({gp reg found = %d, arg # = %2d, words = %2d}, %4s, \"", ",", "cum", "->", "gp_reg_found", ",", "cum", "->", "arg_number", ",", "cum", "->", "arg_words", ",", "GET_MODE_NAME", "(", "mode", ")", ")", ";", "fprintf", "(", "stderr", ",", "\"%p\"", ",", "(", "const", "void", "*", ")", "type", ")", ";", "fprintf", "(", "stderr", ",", "\", %d )\\n\\n\"", ",", "named", ")", ";", "}", "cum", "->", "arg_number", "++", ";", "switch", "(", "mode", ")", "{", "case", "E_VOIDmode", ":", "break", ";", "default", ":", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_INT", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", ";", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "E_BLKmode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "(", "(", "int_size_in_bytes", "(", "type", ")", "+", "UNITS_PER_WORD", "-", "1", ")", "/", "UNITS_PER_WORD", ")", ";", "break", ";", "case", "E_SFmode", ":", "cum", "->", "arg_words", "++", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "1", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "E_DFmode", ":", "cum", "->", "arg_words", "+=", "2", ";", "if", "(", "!", "cum", "->", "gp_reg_found", "&&", "cum", "->", "arg_number", "<=", "2", ")", "cum", "->", "fp_code", "+=", "2", "<<", "(", "(", "cum", "->", "arg_number", "-", "1", ")", "*", "2", ")", ";", "break", ";", "case", "E_DImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "2", ";", "break", ";", "case", "E_TImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "+=", "4", ";", "break", ";", "case", "E_QImode", ":", "case", "E_HImode", ":", "case", "E_SImode", ":", "cum", "->", "gp_reg_found", "=", "1", ";", "cum", "->", "arg_words", "++", ";", "break", ";", "}", "}", "</s>" ]

[ "Advance", "the", "argument", "of", "type", "TYPE", "and", "mode", "MODE", "to", "the", "next", "argument", "position", "in", "CUM", "." ]

[ "iq2000", "\"function_adv({gp reg found = %d, arg # = %2d, words = %2d}, %4s, \"", "\"%p\"", "\", %d )\\n\\n\"", "1", "1", "1", "1", "2", "1", "1", "2", "2", "2", "2", "1", "2", "1", "2", "1", "4", "1" ]

[]

[ "<s>", "void", "AMDGPUPassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAMDGPUAlwaysInlinePass", "(", ")", ")", ";", "addPass", "(", "createAlwaysInlinerPass", "(", ")", ")", ";", "addPass", "(", "createBarrierNoopPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "altivec_expand_vec_perm_le", "(", "rtx", "operands", "[", "4", "]", ")", "{", "rtx", "notx", ",", "iorx", ",", "unspec", ";", "rtx", "target", "=", "operands", "[", "0", "]", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "sel", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", "=", "target", ";", "rtx", "norreg", "=", "gen_reg_rtx", "(", "V16QImode", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "if", "(", "!", "REG_P", "(", "op0", ")", ")", "op0", "=", "force_reg", "(", "mode", ",", "op0", ")", ";", "if", "(", "!", "REG_P", "(", "op1", ")", ")", "op1", "=", "force_reg", "(", "mode", ",", "op1", ")", ";", "if", "(", "!", "REG_P", "(", "sel", ")", ")", "sel", "=", "force_reg", "(", "V16QImode", ",", "sel", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "notx", "=", "gen_rtx_NOT", "(", "V16QImode", ",", "sel", ")", ";", "iorx", "=", "(", "TARGET_P8_VECTOR", "?", "gen_rtx_IOR", "(", "V16QImode", ",", "notx", ",", "notx", ")", ":", "gen_rtx_AND", "(", "V16QImode", ",", "notx", ",", "notx", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "norreg", ",", "iorx", ")", ")", ";", "unspec", "=", "gen_rtx_UNSPEC", "(", "mode", ",", "gen_rtvec", "(", "3", ",", "op1", ",", "op0", ",", "norreg", ")", ",", "UNSPEC_VPERM", ")", ";", "if", "(", "!", "REG_P", "(", "target", ")", ")", "{", "emit_move_insn", "(", "tmp", ",", "unspec", ")", ";", "unspec", "=", "tmp", ";", "}", "emit_move_insn", "(", "target", ",", "unspec", ")", ";", "}", "</s>" ]

[ "Similarly", "to", "altivec_expand_vec_perm_const_le", ",", "we", "must", "adjust", "the", "permute", "control", "vector", ".", "But", "here", "it", "'s", "not", "a", "constant", ",", "so", "we", "must", "generate", "a", "vector", "NAND", "or", "NOR", "to", "do", "the", "adjustment", "." ]

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

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "void", "TPCRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "const", "TargetRegisterClass", "*", "RC", "=", "nullptr", ";", "bool", "IsSpill", "=", "false", ";", "bool", "IsFill", "=", "false", ";", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "TPC", "::", "SPILL_ARF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "ARFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_DRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "DRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_ZRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "ZRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_VRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "VRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_VPRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "VPRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_IRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "IRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_SRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "SRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_SPRF_RESTORE", ":", "RC", "=", "&", "TPC", "::", "SPRFRegClass", ";", "IsFill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_ARF_SAVE", ":", "RC", "=", "&", "TPC", "::", "ARFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_DRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "DRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_ZRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "ZRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_VRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "VRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_VPRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "VPRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_IRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "IRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_SRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "SRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "case", "TPC", "::", "SPILL_SPRF_SAVE", ":", "RC", "=", "&", "TPC", "::", "SPRFRegClass", ";", "IsSpill", "=", "true", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unexpected frame index\"", ")", ";", "}", "if", "(", "IsSpill", "||", "IsFill", ")", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "TPCFrameLowering", "&", "FL", "=", "*", "const_cast", "<", "TPCFrameLowering", "*", ">", "(", "MF", ".", "getSubtarget", "<", "TPCSubtarget", ">", "(", ")", ".", "getFrameLowering", "(", ")", ")", ";", "int", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "Offset", ";", "Offset", "=", "FL", ".", "getSpillObject", "(", "FI", ",", "RC", ",", "MF", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "}", "</s>" ]

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

[ "TPC", "TPC", "TPC::SPILL_ARF_RESTORE", "TPC::ARFRegClass", "TPC::SPILL_DRF_RESTORE", "TPC::DRFRegClass", "TPC::SPILL_ZRF_RESTORE", "TPC::ZRFRegClass", "TPC::SPILL_VRF_RESTORE", "TPC::VRFRegClass", "TPC::SPILL_VPRF_RESTORE", "TPC::VPRFRegClass", "TPC::SPILL_IRF_RESTORE", "TPC::IRFRegClass", "TPC::SPILL_SRF_RESTORE", "TPC::SRFRegClass", "TPC::SPILL_SPRF_RESTORE", "TPC::SPRFRegClass", "TPC::SPILL_ARF_SAVE", "TPC::ARFRegClass", "TPC::SPILL_DRF_SAVE", "TPC::DRFRegClass", "TPC::SPILL_ZRF_SAVE", "TPC::ZRFRegClass", "TPC::SPILL_VRF_SAVE", "TPC::VRFRegClass", "TPC::SPILL_VPRF_SAVE", "TPC::VPRFRegClass", "TPC::SPILL_IRF_SAVE", "TPC::IRFRegClass", "TPC::SPILL_SRF_SAVE", "TPC::SRFRegClass", "TPC::SPILL_SPRF_SAVE", "TPC::SPRFRegClass", "\"Unexpected frame index\"", "TPC", "TPC", "TPC" ]

[]

[ "<s>", "static", "void", "rs6000_emit_stack_tie", "(", ")", "{", "rtx", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "gen_rtx_REG", "(", "Pmode", ",", "STACK_POINTER_REGNUM", ")", ")", ";", "set_mem_alias_set", "(", "mem", ",", "rs6000_sr_alias_set", ")", ";", "emit_insn", "(", "gen_stack_tie", "(", "mem", ")", ")", ";", "}", "</s>" ]

[ "This", "ties", "together", "stack", "memory", "(", "MEM", "with", "an", "alias", "set", "of", "rs6000_sr_alias_set", ")", "and", "the", "change", "to", "the", "stack", "pointer", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ",", "MCContext", "&", "Ctx", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "4", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "3", "-", "i", ";", "Data", "[", "Offset", "+", "Idx", "]", "|=", "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", "." ]

[ "Sparc", "0", "4", "3", "8", "0xff" ]

[]

[ "<s>", "bool", "Z80AsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "llvm_unreachable", "(", "\"Unimplemented\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "Z80", "Z80", "\"Unimplemented\"" ]

[]

[ "<s>", "unsigned", "TVMInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "if", "(", "I", "==", "MBB", ".", "end", "(", ")", ")", "return", "0", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "TVM", "::", "JMPX", "&&", "I", "->", "getOpcode", "(", ")", "!=", "TVM", "::", "IFELSE", "&&", "I", "->", "getOpcode", "(", ")", "!=", "TVM", "::", "IFJMP", "&&", "I", "->", "getOpcode", "(", ")", "!=", "TVM", "::", "IFNOTJMP", ")", "return", "0", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TVM", "::", "JMPX", ")", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "8", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "1", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TVM", "::", "IFELSE", ")", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "8", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "1", ";", "}", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "TVM", "::", "IFJMP", "||", "I", "->", "getOpcode", "(", ")", "==", "TVM", "::", "IFNOTJMP", ")", "{", "if", "(", "BytesRemoved", ")", "*", "BytesRemoved", "=", "8", ";", "I", "->", "eraseFromParent", "(", ")", ";", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "TVM", "TVM", "0", "TVM::JMPX", "TVM::IFELSE", "TVM::IFJMP", "TVM::IFNOTJMP", "0", "TVM::JMPX", "8", "1", "TVM::IFELSE", "8", "1", "TVM::IFJMP", "TVM::IFNOTJMP", "8", "1", "0" ]

[]

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

[ "Provide", "a", "weight", "to", "bias", "towards", "choosing", "this", "strategy", "for", "a", "mutation", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "EdgeBundles", ">", "(", ")", ";", "AU", ".", "addPreservedID", "(", "MachineLoopInfoID", ")", ";", "AU", ".", "addPreservedID", "(", "MachineDominatorsID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "X86" ]

[]

[ "<s>", "void", "PatmosAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallVector", "<", "const", "MachineInstr", "*", ",", "2", ">", "BundleMIs", ";", "unsigned", "Size", "=", "1", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "{", "const", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "auto", "MII", "=", "MI", "->", "getIterator", "(", ")", ";", "++", "MII", ";", "while", "(", "MII", "!=", "MBB", "->", "end", "(", ")", "&&", "MII", "->", "isInsideBundle", "(", ")", ")", "{", "const", "MachineInstr", "*", "MInst", "=", "&", "(", "*", "MII", ")", ";", "assert", "(", "!", "MInst", "->", "isPseudo", "(", ")", "&&", "\"Pseudo instructions must not be bundled!\"", ")", ";", "BundleMIs", ".", "push_back", "(", "MInst", ")", ";", "++", "MII", ";", "}", "Size", "=", "BundleMIs", ".", "size", "(", ")", ";", "assert", "(", "Size", "==", "MI", "->", "getBundleSize", "(", ")", "&&", "\"Corrupt Bundle!\"", ")", ";", "}", "else", "{", "BundleMIs", ".", "push_back", "(", "MI", ")", ";", "}", "for", "(", "unsigned", "Index", "=", "0", ";", "Index", "<", "Size", ";", "Index", "++", ")", "{", "MCInst", "MCI", ";", "MCInstLowering", ".", "Lower", "(", "BundleMIs", "[", "Index", "]", ",", "MCI", ")", ";", "bool", "isBundled", "=", "(", "Index", "<", "Size", "-", "1", ")", ";", "MCI", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "isBundled", ")", ")", ";", "OutStreamer", "->", "emitInstruction", "(", "MCI", ",", "*", "TM", ".", "getMCSubtargetInfo", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "Patmos", "Patmos", "2", "1", "\"Pseudo instructions must not be bundled!\"", "\"Corrupt Bundle!\"", "0", "1" ]

[]

[ "<s>", "static", "int", "mips_multipass_dfa_lookahead", "(", "void", ")", "{", "if", "(", "TUNE_SB1", ")", "return", "4", ";", "if", "(", "TUNE_LOONGSON_2EF", "||", "TUNE_LOONGSON_3A", ")", "return", "4", ";", "if", "(", "TUNE_OCTEON", ")", "return", "2", ";", "if", "(", "TUNE_P5600", ")", "return", "4", ";", "return", "0", ";", "}", "</s>" ]

[ "Implements", "TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD", ".", "This", "should", "be", "as", "wide", "as", "the", "scheduling", "freedom", "in", "the", "DFA", "." ]

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

[]

[ "<s>", "static", "bool", "mcore_return_in_memory", "(", "tree", "type", ",", "tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "2", "*", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "mcore", "1", "2" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"ARM64 pseudo instruction expansion pass\"", ";", "}", "</s>" ]

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

[ "ARM64", "\"ARM64 pseudo instruction expansion pass\"" ]

[]

[ "<s>", "static", "rtx", "arm_find_shift_sub_rtx", "(", "rtx", "pattern", ")", "{", "return", "arm_find_sub_rtx_with_code", "(", "pattern", ",", "ASHIFT", ",", "true", ")", ";", "}", "</s>" ]

[ "Traverse", "PATTERN", "looking", "for", "any", "sub-rtx", "which", "looks", "like", "a", "shift", "." ]

[ "arm" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "static", "tree", "gen_regparm_prefix", "(", "tree", "decl", ",", "unsigned", "nregs", ")", "{", "unsigned", "total", "=", "0", ";", "const", "char", "*", "asmname", "=", "IDENTIFIER_POINTER", "(", "DECL_ASSEMBLER_NAME", "(", "decl", ")", ")", ";", "char", "*", "newsym", ";", "tree", "formal_type", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "formal_type", "!=", "NULL_TREE", ")", "{", "if", "(", "TREE_VALUE", "(", "tree_last", "(", "formal_type", ")", ")", "!=", "void_type_node", ")", "return", "NULL_TREE", ";", "while", "(", "TREE_VALUE", "(", "formal_type", ")", "!=", "void_type_node", "&&", "COMPLETE_TYPE_P", "(", "TREE_VALUE", "(", "formal_type", ")", ")", ")", "{", "unsigned", "parm_size", "=", "TREE_INT_CST_LOW", "(", "TYPE_SIZE", "(", "TREE_VALUE", "(", "formal_type", ")", ")", ")", ";", "parm_size", "=", "(", "(", "parm_size", "+", "PARM_BOUNDARY", "-", "1", ")", "/", "PARM_BOUNDARY", "*", "PARM_BOUNDARY", ")", ";", "total", "+=", "parm_size", ";", "formal_type", "=", "TREE_CHAIN", "(", "formal_type", ")", ";", "}", "}", "if", "(", "nregs", ">", "total", "/", "BITS_PER_WORD", ")", "nregs", "=", "total", "/", "BITS_PER_WORD", ";", "gcc_assert", "(", "nregs", "<=", "9", ")", ";", "newsym", "=", "alloca", "(", "3", "+", "strlen", "(", "asmname", ")", "+", "1", ")", ";", "return", "get_identifier_with_length", "(", "newsym", ",", "sprintf", "(", "newsym", ",", "\"_%u@%s\"", ",", "nregs", ",", "asmname", ")", ")", ";", "}", "</s>" ]

[ "Return", "string", "which", "is", "the", "former", "assembler", "name", "modified", "with", "an", "_n", "@", "prefix", "where", "n", "represents", "the", "number", "of", "arguments", "passed", "in", "registers" ]

[ "i386", "0", "1", "9", "3", "1", "\"_%u@%s\"" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "llvm_unreachable", "(", "\"Assembly inspects a register operand\"", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "WebAssembly", "\"Assembly inspects a register operand\"", "0" ]

[]

[ "<s>", "void", "reset", "(", ")", "{", "FnStartLocs", "=", "Locs", "(", ")", ";", "CantUnwindLocs", "=", "Locs", "(", ")", ";", "PersonalityLocs", "=", "Locs", "(", ")", ";", "HandlerDataLocs", "=", "Locs", "(", ")", ";", "PersonalityIndexLocs", "=", "Locs", "(", ")", ";", "FPReg", "=", "ARM", "::", "SP", ";", "}", "</s>" ]

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

[ "ARM", "ARM::SP" ]

[]

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

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

[ "Mandarin" ]

[]

[ "<s>", "SDValue", "DCPU16TargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "Ins", ",", "RetCC_DCPU16", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "Dcpu16", "DCPU16", "ISD::InputArg", "16", "DCPU16", "0", "1", "2", "0" ]

[]

[ "<s>", "static", "const", "char", "*", "get_content_name", "(", "unsigned", "char", "index", ",", "machine_mode", "mode", ")", "{", "static", "char", "buffer", "[", "128", "]", ";", "if", "(", "index", "==", "NOT_KNOWN", ")", "return", "\"Unknown\"", ";", "if", "(", "index", ">", "31", ")", "sprintf", "(", "buffer", ",", "\"stack slot %d\"", ",", "index", "-", "32", ")", ";", "else", "if", "(", "mode", "==", "HImode", ")", "sprintf", "(", "buffer", ",", "\"%s%s\"", ",", "reg_names", "[", "index", "+", "1", "]", ",", "reg_names", "[", "index", "]", ")", ";", "else", "return", "reg_names", "[", "index", "]", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Return", "a", "string", "describing", "content", "INDEX", "in", "mode", "MODE", ".", "WARNING", ":", "Can", "return", "a", "pointer", "to", "a", "static", "buffer", "." ]

[ "rl78", "128", "\"Unknown\"", "31", "\"stack slot %d\"", "32", "\"%s%s\"", "1" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "GCNHazardRecognizer", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "auto", "HazardType", "=", "IsHazardRecognizerMode", "?", "NoopHazard", ":", "Hazard", ";", "if", "(", "MI", "->", "isBundle", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", "&&", "checkSMRDHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "ST", ".", "hasNSAtoVMEMBug", "(", ")", "&&", "checkNSAtoVMEMHazard", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "checkFPAtomicToDenormModeHazard", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "ST", ".", "hasNoDataDepHazard", "(", ")", ")", "return", "NoHazard", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", ")", "&&", "checkVMEMHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "&&", "checkVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", "&&", "checkDPPHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isDivFMas", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkDivFMasHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isRWLane", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRWLaneHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "(", "SIInstrInfo", "::", "isVALU", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isDS", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isEXP", "(", "*", "MI", ")", ")", "&&", "checkMAIVALUHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isSGetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkGetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isSSetReg", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkSetRegHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "isRFE", "(", "MI", "->", "getOpcode", "(", ")", ")", "&&", "checkRFEHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "ST", ".", "hasReadM0MovRelInterpHazard", "(", ")", "&&", "(", "TII", ".", "isVINTRP", "(", "*", "MI", ")", "||", "isSMovRel", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "ST", ".", "hasReadM0SendMsgHazard", "(", ")", "&&", "isSendMsgTraceDataOrGDS", "(", "TII", ",", "*", "MI", ")", "&&", "checkReadM0Hazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "SIInstrInfo", "::", "isMAI", "(", "*", "MI", ")", "&&", "checkMAIHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isFLAT", "(", "*", "MI", ")", "||", "SIInstrInfo", "::", "isDS", "(", "*", "MI", ")", ")", "&&", "checkMAILdStHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "&&", "checkInlineAsmHazards", "(", "MI", ")", ">", "0", ")", "return", "HazardType", ";", "return", "NoHazard", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64AsmParser", "::", "parsePrimaryExpr", "(", "const", "MCExpr", "*", "&", "Res", ",", "SMLoc", "&", "EndLoc", ")", "{", "if", "(", "!", "parseAuthExpr", "(", "Res", ",", "EndLoc", ")", ")", "return", "false", ";", "return", "getParser", "(", ")", ".", "parsePrimaryExpr", "(", "Res", ",", "EndLoc", ",", "nullptr", ")", ";", "}", "</s>" ]

[ "Parse", "a", "primary", "expression", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MVEVPTBlock", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "ARMSubtarget", "&", "STI", "=", "Fn", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "if", "(", "!", "STI", ".", "isThumb2", "(", ")", "||", "!", "STI", ".", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "TII", "=", "static_cast", "<", "const", "Thumb2InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** ARM MVE VPT BLOCKS **********\\n\"", "<<", "\"********** Function: \"", "<<", "Fn", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "InsertVPTBlocks", "(", "MBB", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"**************************************\\n\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "\"********** ARM MVE VPT BLOCKS **********\\n\"", "\"********** Function: \"", "\"**************************************\\n\"" ]

[]

[ "<s>", "static", "unsigned", "int", "cr16_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", ">=", "CR16_FIRST_DWORD_REGISTER", ")", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "CR16_UNITS_PER_DWORD", ")", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

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

[ "cr16" ]

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "AArch64TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "if", "(", "Subtarget", "->", "hasLSE", "(", ")", "||", "Subtarget", "->", "outlineAtomics", "(", ")", ")", "return", "AtomicExpansionKind", "::", "None", ";", "if", "(", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "return", "AtomicExpansionKind", "::", "None", ";", "return", "AtomicExpansionKind", "::", "LLSC", ";", "}", "</s>" ]

[ "Returns", "how", "the", "given", "atomic", "cmpxchg", "should", "be", "expanded", "by", "the", "IR-level", "AtomicExpand", "pass", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "HexagonHardwareLoops", "::", "isDead", "(", "const", "MachineInstr", "*", "MI", ",", "SmallVectorImpl", "<", "MachineInstr", "*", ">", "&", "DeadPhis", ")", "const", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "MRI", "->", "use_nodbg_empty", "(", "Reg", ")", ")", "continue", ";", "using", "use_nodbg_iterator", "=", "MachineRegisterInfo", "::", "use_nodbg_iterator", ";", "use_nodbg_iterator", "I", "=", "MRI", "->", "use_nodbg_begin", "(", "Reg", ")", ";", "use_nodbg_iterator", "End", "=", "MRI", "->", "use_nodbg_end", "(", ")", ";", "if", "(", "std", "::", "next", "(", "I", ")", "!=", "End", "||", "!", "I", "->", "getParent", "(", ")", "->", "isPHI", "(", ")", ")", "return", "false", ";", "MachineInstr", "*", "OnePhi", "=", "I", "->", "getParent", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "f", "=", "OnePhi", "->", "getNumOperands", "(", ")", ";", "j", "!=", "f", ";", "++", "j", ")", "{", "const", "MachineOperand", "&", "OPO", "=", "OnePhi", "->", "getOperand", "(", "j", ")", ";", "if", "(", "!", "OPO", ".", "isReg", "(", ")", "||", "!", "OPO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "OPReg", "=", "OPO", ".", "getReg", "(", ")", ";", "use_nodbg_iterator", "nextJ", ";", "for", "(", "use_nodbg_iterator", "J", "=", "MRI", "->", "use_nodbg_begin", "(", "OPReg", ")", ";", "J", "!=", "End", ";", "J", "=", "nextJ", ")", "{", "nextJ", "=", "std", "::", "next", "(", "J", ")", ";", "MachineOperand", "&", "Use", "=", "*", "J", ";", "MachineInstr", "*", "UseMI", "=", "Use", ".", "getParent", "(", ")", ";", "if", "(", "MI", "!=", "UseMI", ")", "return", "false", ";", "}", "}", "DeadPhis", ".", "push_back", "(", "OnePhi", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isDead", "-", "Returns", "true", "if", "this", "is", "a", "dead", "def", "kill", "slot", "." ]

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

[]

[ "<s>", "void", "xtensa_split_operand_pair", "(", "rtx", "operands", "[", "4", "]", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "1", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "3", "]", "=", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", "+", "1", ")", ";", "operands", "[", "2", "]", "=", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "operands", "[", "1", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "3", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "operands", "[", "2", "]", "=", "adjust_address", "(", "operands", "[", "1", "]", ",", "mode", ",", "0", ")", ";", "break", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "split_double", "(", "operands", "[", "1", "]", ",", "&", "operands", "[", "2", "]", ",", "&", "operands", "[", "3", "]", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "REG", ":", "operands", "[", "1", "]", "=", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", "+", "1", ")", ";", "operands", "[", "0", "]", "=", "gen_rtx_REG", "(", "mode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "break", ";", "case", "MEM", ":", "operands", "[", "1", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "operands", "[", "0", "]", "=", "adjust_address", "(", "operands", "[", "0", "]", ",", "mode", ",", "0", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Split", "OP", "[", "1", "]", "into", "OP", "[", "2,3", "]", "and", "likewise", "for", "OP", "[", "0", "]", "into", "OP", "[", "0,1", "]", ".", "MODE", "is", "for", "the", "output", ",", "i.e.", ",", "the", "input", "operands", "are", "twice", "as", "big", "as", "MODE", "." ]

[ "xtensa", "4", "1", "3", "1", "1", "2", "1", "3", "1", "2", "1", "0", "1", "2", "3", "0", "1", "0", "1", "0", "0", "1", "0", "0", "0", "0" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "RISCVFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "RISCVInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "RISCVInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "RISCVSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ";", "if", "(", "!", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "RISCV", "::", "ADJCALLSTACKDOWN", ")", "Amount", "=", "-", "Amount", ";", "unsigned", "SP", "=", "STI", ".", "isRV64", "(", ")", "?", "RISCV", "::", "sp_64", ":", "RISCV", "::", "sp", ";", "TII", ".", "adjustStackPtr", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "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", ")", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "RISCV", "0", "RISCV::ADJCALLSTACKDOWN", "RISCV::sp_64", "RISCV::sp" ]

[]

[ "<s>", "static", "void", "frv_align_label", "(", "void", ")", "{", "unsigned", "int", "alignment", ",", "target", ",", "nop", ";", "rtx_insn", "*", "x", ",", "*", "last", ",", "*", "barrier", ",", "*", "label", ";", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "label", "=", "barrier", "=", "0", ";", "alignment", "=", "4", ";", "for", "(", "x", "=", "NEXT_INSN", "(", "last", ")", ";", "x", "!=", "0", "&&", "!", "INSN_P", "(", "x", ")", ";", "x", "=", "NEXT_INSN", "(", "x", ")", ")", "{", "if", "(", "LABEL_P", "(", "x", ")", ")", "{", "unsigned", "int", "subalign", "=", "1", "<<", "label_to_alignment", "(", "x", ")", ".", "levels", "[", "0", "]", ".", "log", ";", "alignment", "=", "MAX", "(", "alignment", ",", "subalign", ")", ";", "label", "=", "x", ";", "}", "if", "(", "BARRIER_P", "(", "x", ")", ")", "barrier", "=", "x", ";", "}", "if", "(", "TARGET_ALIGN_LABELS", "&&", "label", "!=", "0", "&&", "barrier", "==", "0", "&&", "frv_packet", ".", "num_insns", "<", "frv_packet", ".", "issue_rate", ")", "alignment", "=", "MAX", "(", "alignment", ",", "8", ")", ";", "frv_packet_address", "+=", "frv_packet", ".", "num_insns", "*", "4", ";", "target", "=", "(", "frv_packet_address", "+", "alignment", "-", "1", ")", "&", "-", "alignment", ";", "if", "(", "barrier", "==", "0", ")", "{", "for", "(", "nop", "=", "0", ";", "nop", "<", "frv_num_nops", ";", "nop", "++", ")", "while", "(", "frv_packet_address", "<", "target", "&&", "frv_pack_insn_p", "(", "frv_nops", "[", "nop", "]", ")", ")", "{", "frv_insert_nop_in_packet", "(", "frv_nops", "[", "nop", "]", ")", ";", "frv_packet_address", "+=", "4", ";", "}", "last", "=", "frv_packet", ".", "insns", "[", "frv_packet", ".", "num_insns", "-", "1", "]", ";", "nop", "=", "0", ";", "while", "(", "frv_packet_address", "<", "target", ")", "{", "last", "=", "emit_insn_after", "(", "PATTERN", "(", "frv_nops", "[", "nop", "]", ")", ",", "last", ")", ";", "frv_packet_address", "+=", "4", ";", "if", "(", "frv_num_nops", ">", "1", ")", "nop", "^=", "1", ";", "}", "}", "frv_packet_address", "=", "target", ";", "}", "</s>" ]

[ "If", "the", "current", "packet", "falls", "through", "to", "a", "label", ",", "try", "to", "pad", "the", "packet", "with", "nops", "in", "order", "to", "fit", "the", "label", "'s", "alignment", "requirements", "." ]

[ "frv", "1", "0", "4", "0", "1", "0", "0", "0", "8", "4", "1", "0", "0", "4", "1", "0", "4", "1", "1" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "uint64_t", "Val", ",", "unsigned", "Size", ",", "raw_ostream", "&", "OS", ")", "const", "{", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "Size", ";", "++", "i", ")", "{", "EmitByte", "(", "Val", "&", "255", ",", "OS", ")", ";", "Val", ">>=", "8", ";", "}", "}", "</s>" ]

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

[ "Mips", "0", "255", "8" ]

[]

[ "<s>", "static", "bool", "insn_terminates_group_p", "(", "rtx", "insn", ",", "enum", "group_termination", "which_group", ")", "{", "enum", "attr_type", "type", ";", "if", "(", "!", "insn", ")", "return", "false", ";", "type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "is_microcoded_insn", "(", "insn", ")", ")", "return", "true", ";", "if", "(", "which_group", "==", "current_group", ")", "{", "if", "(", "is_branch_slot_insn", "(", "insn", ")", ")", "return", "true", ";", "return", "false", ";", "}", "else", "if", "(", "which_group", "==", "previous_group", ")", "{", "if", "(", "is_dispatch_slot_restricted", "(", "insn", ")", ")", "return", "true", ";", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "the", "presence", "of", "INSN", "causes", "a", "dispatch", "group", "termination", "of", "group", "WHICH_GROUP", ".", "If", "WHICH_GROUP", "==", "current_group", ",", "this", "function", "will", "return", "true", "if", "INSN", "causes", "the", "termination", "of", "the", "current", "group", "(", "i.e", ",", "the", "dispatch", "group", "to", "which", "INSN", "belongs", ")", ".", "This", "means", "that", "INSN", "will", "be", "the", "last", "insn", "in", "the", "group", "it", "belongs", "to", ".", "If", "WHICH_GROUP", "==", "previous_group", ",", "this", "function", "will", "return", "true", "if", "INSN", "causes", "the", "termination", "of", "the", "previous", "group", "(", "i.e", ",", "the", "dispatch", "group", "that", "precedes", "the", "group", "to", "which", "INSN", "belongs", ")", ".", "This", "means", "that", "INSN", "will", "be", "the", "first", "insn", "in", "the", "group", "it", "belongs", "to", ")", "." ]

[ "rs6000" ]

[]

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

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

[ "Sparc", "Sparc", "0" ]

[]

[ "<s>", "static", "SDNode", "*", "getInt64", "(", "SelectionDAG", "*", "CurDAG", ",", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "int64_t", "Imm", "=", "cast", "<", "ConstantSDNode", ">", "(", "N", ")", "->", "getZExtValue", "(", ")", ";", "return", "getInt64", "(", "CurDAG", ",", "dl", ",", "Imm", ")", ";", "}", "</s>" ]

[ "Get", "a", "constant", "64-bit", "value", "." ]

[ "PowerPC" ]

[]

[ "<s>", "const", "SHUXIRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "SHUXI", "SHUXI" ]

[]

[ "<s>", "int", "pa_is_function_label_plus_const", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "function_label_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "VOIDmode", ")", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "}", "</s>" ]

[ "Returns", "1", "if", "OP", "is", "a", "function", "label", "involved", "in", "a", "simple", "addition", "with", "a", "constant", ".", "Used", "to", "keep", "certain", "patterns", "from", "matching", "during", "instruction", "combination", "." ]

[ "pa", "0", "0", "1" ]

[]

[ "<s>", "static", "rtx_code_label", "*", "ix86_expand_sse_compare_and_jump", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "bool", "swap_operands", ")", "{", "machine_mode", "fpcmp_mode", "=", "ix86_fp_compare_mode", "(", "code", ")", ";", "rtx_code_label", "*", "label", ";", "rtx", "tmp", ";", "if", "(", "swap_operands", ")", "std", "::", "swap", "(", "op0", ",", "op1", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "tmp", "=", "gen_rtx_REG", "(", "fpcmp_mode", ",", "FLAGS_REG", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_COMPARE", "(", "fpcmp_mode", ",", "op0", ",", "op1", ")", ")", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "tmp", ",", "const0_rtx", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "tmp", "=", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "tmp", ")", ")", ";", "JUMP_LABEL", "(", "tmp", ")", "=", "label", ";", "return", "label", ";", "}", "</s>" ]

[ "Expands", "a", "comparison", "of", "OP0", "with", "OP1", "using", "comparison", "code", "CODE", ",", "swapping", "the", "operands", "if", "SWAP_OPERANDS", "is", "true", ".", "The", "expanded", "code", "is", "a", "forward", "jump", "to", "a", "newly", "created", "label", "in", "case", "the", "comparison", "is", "true", ".", "The", "generated", "label", "rtx", "is", "returned", "." ]

[ "i386" ]

[]

[ "<s>", "bool", "M680x0AsmBackend", "::", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "{", "if", "(", "int64_t", "(", "Value", ")", "!=", "int64_t", "(", "int16_t", "(", "Value", ")", ")", ")", "{", "llvm_unreachable", "(", "\"Cannot relax the instruction, value does not fit\"", ")", ";", "}", "return", "Value", "==", "0", "||", "int64_t", "(", "Value", ")", "!=", "int64_t", "(", "int8_t", "(", "Value", ")", ")", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "M680x0", "M680x0", "\"Cannot relax the instruction, value does not fit\"", "0" ]

[]

[ "<s>", "static", "bool", "cris_handle_option", "(", "size_t", "code", ",", "const", "char", "*", "arg", "ATTRIBUTE_UNUSED", ",", "int", "value", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "code", ")", "{", "case", "OPT_metrax100", ":", "target_flags", "|=", "(", "MASK_SVINTO", "+", "MASK_ETRAX4_ADD", "+", "MASK_ALIGN_BY_32", ")", ";", "break", ";", "case", "OPT_mno_etrax100", ":", "target_flags", "&=", "~", "(", "MASK_SVINTO", "+", "MASK_ETRAX4_ADD", "+", "MASK_ALIGN_BY_32", ")", ";", "break", ";", "case", "OPT_m32_bit", ":", "case", "OPT_m32bit", ":", "target_flags", "|=", "(", "MASK_STACK_ALIGN", "+", "MASK_CONST_ALIGN", "+", "MASK_DATA_ALIGN", "+", "MASK_ALIGN_BY_32", ")", ";", "break", ";", "case", "OPT_m16_bit", ":", "case", "OPT_m16bit", ":", "target_flags", "|=", "(", "MASK_STACK_ALIGN", "+", "MASK_CONST_ALIGN", "+", "MASK_DATA_ALIGN", ")", ";", "break", ";", "case", "OPT_m8_bit", ":", "case", "OPT_m8bit", ":", "target_flags", "&=", "~", "(", "MASK_STACK_ALIGN", "+", "MASK_CONST_ALIGN", "+", "MASK_DATA_ALIGN", ")", ";", "break", ";", "default", ":", "break", ";", "}", "CRIS_SUBTARGET_HANDLE_OPTION", "(", "code", ",", "arg", ",", "value", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "TARGET_HANDLE_OPTION", "worker", ".", "We", "just", "store", "the", "values", "into", "local", "variables", "here", ".", "Checks", "for", "correct", "semantics", "are", "in", "cris_override_options", "." ]

[ "cris" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MII", ".", "get", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "uint64_t", "TSFlags", "=", "Desc", ".", "TSFlags", ";", "if", "(", "TSFlags", "&", "X86II", "::", "LOCK", ")", "OS", "<<", "\"\\tlock\\n\"", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "if", "(", "CommentStream", ")", "EmitAnyX86InstComments", "(", "MI", ",", "*", "CommentStream", ",", "getRegisterName", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86II::LOCK", "\"\\tlock\\n\"", "X86" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "pop", "(", "struct", "unw_state_record", "*", "sr", ")", "{", "struct", "unw_reg_state", "*", "rs", "=", "sr", "->", "curr", ".", "next", ";", "if", "(", "!", "rs", ")", "abort", "(", ")", ";", "memcpy", "(", "&", "sr", "->", "curr", ",", "rs", ",", "sizeof", "(", "*", "rs", ")", ")", ";", "free_reg_state", "(", "rs", ")", ";", "}", "</s>" ]

[ "Output", "RTL", "to", "pop", "register", "RN", "from", "the", "stack", "." ]

[ "ia64" ]

[]

[ "<s>", "int", "vspltis_shifted", "(", "rtx", "op", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "machine_mode", "inner", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "unsigned", "i", ",", "j", ";", "unsigned", "nunits", ";", "unsigned", "mask", ";", "HOST_WIDE_INT", "val", ";", "if", "(", "mode", "!=", "V16QImode", "&&", "mode", "!=", "V8HImode", "&&", "mode", "!=", "V4SImode", ")", "return", "false", ";", "if", "(", "!", "can_create_pseudo_p", "(", ")", ")", "return", "false", ";", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "mask", "=", "GET_MODE_MASK", "(", "inner", ")", ";", "val", "=", "const_vector_elt_as_int", "(", "op", ",", "BYTES_BIG_ENDIAN", "?", "0", ":", "nunits", "-", "1", ")", ";", "if", "(", "EASY_VECTOR_15", "(", "val", ")", ")", ";", "else", "if", "(", "EASY_VECTOR_MSB", "(", "val", ",", "inner", ")", ")", ";", "else", "return", "0", ";", "for", "(", "i", "=", "1", ";", "i", "<", "nunits", ";", "++", "i", ")", "{", "unsigned", "elt", "=", "BYTES_BIG_ENDIAN", "?", "i", ":", "nunits", "-", "1", "-", "i", ";", "HOST_WIDE_INT", "elt_val", "=", "const_vector_elt_as_int", "(", "op", ",", "elt", ")", ";", "if", "(", "val", "!=", "elt_val", ")", "{", "if", "(", "elt_val", "==", "0", ")", "{", "for", "(", "j", "=", "i", "+", "1", ";", "j", "<", "nunits", ";", "++", "j", ")", "{", "unsigned", "elt2", "=", "BYTES_BIG_ENDIAN", "?", "j", ":", "nunits", "-", "1", "-", "j", ";", "if", "(", "const_vector_elt_as_int", "(", "op", ",", "elt2", ")", "!=", "0", ")", "return", "0", ";", "}", "return", "(", "nunits", "-", "i", ")", "*", "GET_MODE_SIZE", "(", "inner", ")", ";", "}", "else", "if", "(", "(", "elt_val", "&", "mask", ")", "==", "mask", ")", "{", "for", "(", "j", "=", "i", "+", "1", ";", "j", "<", "nunits", ";", "++", "j", ")", "{", "unsigned", "elt2", "=", "BYTES_BIG_ENDIAN", "?", "j", ":", "nunits", "-", "1", "-", "j", ";", "if", "(", "(", "const_vector_elt_as_int", "(", "op", ",", "elt2", ")", "&", "mask", ")", "!=", "mask", ")", "return", "0", ";", "}", "return", "-", "(", "(", "nunits", "-", "i", ")", "*", "GET_MODE_SIZE", "(", "inner", ")", ")", ";", "}", "else", "return", "0", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Like", "vsplitis_constant", ",", "but", "allow", "the", "value", "to", "be", "shifted", "left", "with", "a", "VSLDOI", "instruction", ",", "filling", "in", "the", "bottom", "elements", "with", "0", "or", "-1", ".", "Return", "0", "if", "the", "constant", "can", "not", "be", "generated", "with", "VSLDOI", ".", "Return", "positive", "for", "the", "number", "of", "zeroes", "to", "shift", "in", ",", "or", "negative", "for", "the", "number", "of", "0xff", "bytes", "to", "shift", "in", ".", "OP", "is", "a", "CONST_VECTOR", "." ]

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

[]

[ "<s>", "bool", "X86AvoidSFBPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "DisableX86AvoidStoreForwardBlocks", "||", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", "||", "!", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Expected MIR to be in SSA form\"", ")", ";", "TII", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Start X86AvoidStoreForwardBlocks\\n\"", ";", ")", ";", "findPotentiallylBlockedCopies", "(", "MF", ")", ";", "for", "(", "auto", "LoadStoreInstPair", ":", "BlockedLoadsStoresPairs", ")", "{", "MachineInstr", "*", "LoadInst", "=", "LoadStoreInstPair", ".", "first", ";", "int64_t", "LdDispImm", "=", "getDispOperand", "(", "LoadInst", ")", ".", "getImm", "(", ")", ";", "DisplacementSizeMap", "BlockingStoresDispSizeMap", ";", "SmallVector", "<", "MachineInstr", "*", ",", "2", ">", "PotentialBlockers", "=", "findPotentialBlockers", "(", "LoadInst", ")", ";", "for", "(", "auto", "PBInst", ":", "PotentialBlockers", ")", "{", "if", "(", "!", "isPotentialBlockingStoreInst", "(", "PBInst", "->", "getOpcode", "(", ")", ",", "LoadInst", "->", "getOpcode", "(", ")", ")", "||", "!", "isRelevantAddressingMode", "(", "PBInst", ")", ")", "continue", ";", "int64_t", "PBstDispImm", "=", "getDispOperand", "(", "PBInst", ")", ".", "getImm", "(", ")", ";", "assert", "(", "PBInst", "->", "hasOneMemOperand", "(", ")", "&&", "\"Expected One Memory Operand\"", ")", ";", "unsigned", "PBstSize", "=", "(", "*", "PBInst", "->", "memoperands_begin", "(", ")", ")", "->", "getSize", "(", ")", ";", "if", "(", "hasSameBaseOpValue", "(", "LoadInst", ",", "PBInst", ")", "&&", "isBlockingStore", "(", "LdDispImm", ",", "getRegSizeInBytes", "(", "LoadInst", ")", ",", "PBstDispImm", ",", "PBstSize", ")", ")", "updateBlockingStoresDispSizeMap", "(", "BlockingStoresDispSizeMap", ",", "PBstDispImm", ",", "PBstSize", ")", ";", "}", "if", "(", "BlockingStoresDispSizeMap", ".", "empty", "(", ")", ")", "continue", ";", "MachineInstr", "*", "StoreInst", "=", "LoadStoreInstPair", ".", "second", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Blocked load and store instructions: \\n\"", ")", ";", "DEBUG", "(", "LoadInst", "->", "dump", "(", ")", ")", ";", "DEBUG", "(", "StoreInst", "->", "dump", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Replaced with:\\n\"", ")", ";", "removeRedundantBlockingStores", "(", "BlockingStoresDispSizeMap", ")", ";", "breakBlockedCopies", "(", "LoadInst", ",", "StoreInst", ",", "BlockingStoresDispSizeMap", ")", ";", "updateKillStatus", "(", "LoadInst", ",", "StoreInst", ")", ";", "ForRemoval", ".", "push_back", "(", "LoadInst", ")", ";", "ForRemoval", ".", "push_back", "(", "StoreInst", ")", ";", "}", "for", "(", "auto", "RemovedInst", ":", "ForRemoval", ")", "{", "RemovedInst", "->", "eraseFromParent", "(", ")", ";", "}", "ForRemoval", ".", "clear", "(", ")", ";", "BlockedLoadsStoresPairs", ".", "clear", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"End X86AvoidStoreForwardBlocks\\n\"", ";", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"Expected MIR to be in SSA form\"", "X86", "X86", "\"Start X86AvoidStoreForwardBlocks\\n\"", "2", "\"Expected One Memory Operand\"", "\"Blocked load and store instructions: \\n\"", "\"Replaced with:\\n\"", "\"End X86AvoidStoreForwardBlocks\\n\"" ]

[]

[ "<s>", "static", "bool", "mips_return_mode_in_fpr_p", "(", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "TARGET_PAIRED_SINGLE_FLOAT", "||", "mode", "!=", "V2SFmode", ")", ";", "return", "(", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_FLOAT", "||", "mode", "==", "V2SFmode", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_COMPLEX_FLOAT", ")", "&&", "GET_MODE_UNIT_SIZE", "(", "mode", ")", "<=", "UNITS_PER_HWFPVALUE", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "return", "value", "MODE", "will", "get", "returned", "in", "a", "floating-point", "register", "." ]

[ "mips" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "assert", "(", "!", "BytesRemoved", "&&", "\"code size not handled\"", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "unsigned", "Count", "=", "0", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "X86", "::", "JMP_1", "&&", "X86", "::", "getCondFromBranch", "(", "*", "I", ")", "==", "X86", "::", "COND_INVALID", ")", "break", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "++", "Count", ";", "}", "return", "Count", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "X86", "X86", "\"code size not handled\"", "0", "X86::JMP_1", "X86::getCondFromBranch", "X86::COND_INVALID" ]

[]

[ "<s>", "static", "unsigned", "size", "(", "const", "GraphType", "&", "G", ")", "{", "return", "G", ".", "Nodes", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "The", "number", "of", "name/type", "pairs", "is", "returned", "." ]

[ "Patmos" ]

[]

[ "<s>", "WebAssemblySubtarget", "::", "WebAssemblySubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "WebAssemblyGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "HasSIMD128", "(", "false", ")", ",", "HasAtomics", "(", "false", ")", ",", "CPUString", "(", "CPU", ")", ",", "TargetTriple", "(", "TT", ")", ",", "FrameLowering", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "FS", ")", ")", ",", "TSInfo", "(", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", "{", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

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

[]

[ "<s>", "SDValue", "BPFTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "BPF", "BPF", "ISD::BR_CC", "ISD::GlobalAddress", "ISD::SELECT_CC", "\"unimplemented operand\"" ]

[]

[ "<s>", "bool", "MipsAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ",", "MCFixupKind", "&", "MappedKind", ")", "const", "{", "if", "(", "Name", "==", "\"R_MIPS_NONE\"", ")", "{", "MappedKind", "=", "(", "MCFixupKind", ")", "Mips", "::", "fixup_Mips_NONE", ";", "return", "true", ";", "}", "if", "(", "Name", "==", "\"R_MIPS_32\"", ")", "{", "MappedKind", "=", "FK_Data_4", ";", "return", "true", ";", "}", "return", "MCAsmBackend", "::", "getFixupKind", "(", "Name", ",", "MappedKind", ")", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "Mips", "Mips", "\"R_MIPS_NONE\"", "Mips::fixup_Mips_NONE", "\"R_MIPS_32\"" ]

[]

[ "<s>", "inline", "hashval_t", "bundle_state_hasher", "::", "hash", "(", "const", "value_type", "*", "state", ")", "{", "unsigned", "result", ",", "i", ";", "for", "(", "result", "=", "i", "=", "0", ";", "i", "<", "dfa_state_size", ";", "i", "++", ")", "result", "+=", "(", "(", "(", "unsigned", "char", "*", ")", "state", "->", "dfa_state", ")", "[", "i", "]", "<<", "(", "(", "i", "%", "CHAR_BIT", ")", "*", "3", "+", "CHAR_BIT", ")", ")", ";", "return", "result", "+", "state", "->", "insn_num", ";", "}", "</s>" ]

[ "Hash", "function", "for", "builtin", "functions", "with", "up", "to", "3", "arguments", "and", "a", "return", "type", "." ]

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

[]

[ "<s>", "virtual", "MVT", "getScalarShiftAmountTy", "(", "EVT", "LHSTy", ")", "const", "{", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

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

[ "PowerPC", "MVT::i32" ]

[]

[ "<s>", "uint64_t", "flags", "(", ")", "const", "{", "return", "0x0", ";", "}", "</s>" ]

[ "Get", "the", "flags", "for", "this", "GlobalValue", "(", "see", "struct", "GVFlags", ")", "." ]

[ "X86", "0x0" ]

[]

[ "<s>", "static", "bool", "s390_use_by_pieces_infrastructure_p", "(", "unsigned", "HOST_WIDE_INT", "size", ",", "unsigned", "int", "align", "ATTRIBUTE_UNUSED", ",", "enum", "by_pieces_operation", "op", "ATTRIBUTE_UNUSED", ",", "bool", "speed_p", "ATTRIBUTE_UNUSED", ")", "{", "return", "(", "size", "==", "1", "||", "size", "==", "2", "||", "size", "==", "4", "||", "(", "TARGET_ZARCH", "&&", "size", "==", "8", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_USE_BY_PIECES_INFRASTRUCTURE_P", "." ]

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

[]

[ "<s>", "void", "ArgDescriptor", "::", "print", "(", "raw_ostream", "&", "OS", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "isSet", "(", ")", ")", "{", "OS", "<<", "\"<not set>\\n\"", ";", "return", ";", "}", "if", "(", "isRegister", "(", ")", ")", "OS", "<<", "\"Reg \"", "<<", "printReg", "(", "getRegister", "(", ")", ",", "TRI", ")", "<<", "'\\n'", ";", "else", "OS", "<<", "\"Stack offset \"", "<<", "getStackOffset", "(", ")", "<<", "'\\n'", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"<not set>\\n\"", "\"Reg \"", "\"Stack offset \"" ]

[]

[ "<s>", "bool", "SILowerI1Copies", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "TheMF", ")", "{", "if", "(", "TheMF", ".", "getProperties", "(", ")", ".", "hasProperty", "(", "MachineFunctionProperties", "::", "Property", "::", "Selected", ")", ")", "return", "false", ";", "MF", "=", "&", "TheMF", ";", "MRI", "=", "&", "MF", "->", "getRegInfo", "(", ")", ";", "DT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "PDT", "=", "&", "getAnalysis", "<", "MachinePostDominatorTree", ">", "(", ")", ";", "ST", "=", "&", "MF", "->", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "IsWave32", "=", "ST", "->", "isWave32", "(", ")", ";", "if", "(", "IsWave32", ")", "{", "ExecReg", "=", "AMDGPU", "::", "EXEC_LO", ";", "MovOp", "=", "AMDGPU", "::", "S_MOV_B32", ";", "AndOp", "=", "AMDGPU", "::", "S_AND_B32", ";", "OrOp", "=", "AMDGPU", "::", "S_OR_B32", ";", "XorOp", "=", "AMDGPU", "::", "S_XOR_B32", ";", "AndN2Op", "=", "AMDGPU", "::", "S_ANDN2_B32", ";", "OrN2Op", "=", "AMDGPU", "::", "S_ORN2_B32", ";", "}", "else", "{", "ExecReg", "=", "AMDGPU", "::", "EXEC", ";", "MovOp", "=", "AMDGPU", "::", "S_MOV_B64", ";", "AndOp", "=", "AMDGPU", "::", "S_AND_B64", ";", "OrOp", "=", "AMDGPU", "::", "S_OR_B64", ";", "XorOp", "=", "AMDGPU", "::", "S_XOR_B64", ";", "AndN2Op", "=", "AMDGPU", "::", "S_ANDN2_B64", ";", "OrN2Op", "=", "AMDGPU", "::", "S_ORN2_B64", ";", "}", "bool", "Changed", "=", "false", ";", "Changed", "|=", "lowerCopiesFromI1", "(", ")", ";", "Changed", "|=", "lowerPhis", "(", ")", ";", "Changed", "|=", "lowerCopiesToI1", "(", ")", ";", "assert", "(", "Changed", "||", "ConstrainRegs", ".", "empty", "(", ")", ")", ";", "for", "(", "unsigned", "Reg", ":", "ConstrainRegs", ")", "MRI", "->", "constrainRegClass", "(", "Reg", ",", "&", "AMDGPU", "::", "SReg_1_XEXECRegClass", ")", ";", "ConstrainRegs", ".", "clear", "(", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::EXEC_LO", "AMDGPU::S_MOV_B32", "AMDGPU::S_AND_B32", "AMDGPU::S_OR_B32", "AMDGPU::S_XOR_B32", "AMDGPU::S_ANDN2_B32", "AMDGPU::S_ORN2_B32", "AMDGPU::EXEC", "AMDGPU::S_MOV_B64", "AMDGPU::S_AND_B64", "AMDGPU::S_OR_B64", "AMDGPU::S_XOR_B64", "AMDGPU::S_ANDN2_B64", "AMDGPU::S_ORN2_B64", "AMDGPU::SReg_1_XEXECRegClass" ]

[]

[ "<s>", "void", "rs6000_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "!", "TARGET_POWER", ")", "fixed_regs", "[", "64", "]", "=", "1", ";", "if", "(", "TARGET_64BIT", ")", "fixed_regs", "[", "13", "]", "=", "call_used_regs", "[", "13", "]", "=", "call_really_used_regs", "[", "13", "]", "=", "1", ";", "if", "(", "TARGET_SOFT_FLOAT", "||", "!", "TARGET_FPRS", ")", "for", "(", "i", "=", "32", ";", "i", "<", "64", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", ")", "call_really_used_regs", "[", "2", "]", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", "&&", "flag_pic", "==", "2", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", "&&", "flag_pic", "==", "1", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "PIC_OFFSET_TABLE_REGNUM", "!=", "INVALID_REGNUM", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_ALTIVEC", ")", "global_regs", "[", "VSCR_REGNO", "]", "=", "1", ";", "if", "(", "TARGET_SPE", ")", "{", "global_regs", "[", "SPEFSCR_REGNO", "]", "=", "1", ";", "fixed_regs", "[", "FIXED_SCRATCH", "]", "=", "call_used_regs", "[", "FIXED_SCRATCH", "]", "=", "call_really_used_regs", "[", "FIXED_SCRATCH", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_ALTIVEC", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "VRSAVE_REGNO", "]", "=", "1", ";", "}", "if", "(", "TARGET_ALTIVEC_ABI", ")", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "++", "i", ")", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "</s>" ]

[ "Change", "register", "usage", "conditional", "on", "target", "flags", "." ]

[ "rs6000", "64", "1", "13", "13", "13", "1", "32", "64", "1", "2", "0", "2", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "20", "1" ]

[]

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

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

[ "MOS" ]

[]

[ "<s>", "bool", "isTarget64BitLP64", "(", ")", "const", "{", "return", "In64BitMode", "&&", "(", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "GNUX32", "&&", "TargetTriple", ".", "getOS", "(", ")", "!=", "Triple", "::", "NaCl", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "LP64", "programming", "model", "(", "standard", "AMD64", ",", "no", "x32", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "void", "HexagonInstPrinter", "::", "printRegName", "(", "raw_ostream", "&", "OS", ",", "unsigned", "RegNo", ")", "const", "{", "OS", "<<", "getRegisterName", "(", "RegNo", ")", ";", "}", "</s>" ]

[ "Print", "the", "assembler", "register", "name", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "scalar_chain", "::", "~", "scalar_chain", "(", ")", "{", "BITMAP_FREE", "(", "insns", ")", ";", "BITMAP_FREE", "(", "defs", ")", ";", "BITMAP_FREE", "(", "defs_conv", ")", ";", "bitmap_obstack_release", "(", "NULL", ")", ";", "}", "</s>" ]

[ "Free", "chain", "'s", "data", "." ]

[ "i386" ]

[]

[ "<s>", "MachinePointerInfo", "SICFunctionInfo", "::", "callPtrInfo", "(", "const", "GlobalValue", "*", "GV", ")", "{", "return", "MachinePointerInfo", "(", "MF", ".", "getPSVManager", "(", ")", ".", "getGlobalValueCallEntry", "(", "GV", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "MachinePointerInfo", "that", "has", "a", "GlobalValuePseudoSourceValue", "object", "representing", "a", "GOT", "entry", "for", "a", "global", "function", "." ]

[ "SIC", "SIC" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "if", "(", "!", "FastEstimation", ")", "AU", ".", "addRequired", "<", "MachineProfileAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "TMS320C64X" ]

[]

[ "<s>", "static", "void", "update_set_flags", "(", "rtx", "x", ",", "struct", "reg_flags", "*", "pflags", ")", "{", "rtx", "src", "=", "SET_SRC", "(", "x", ")", ";", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "case", "CALL", ":", "return", ";", "case", "IF_THEN_ELSE", ":", "return", ";", "default", ":", "if", "(", "COMPARISON_P", "(", "src", ")", "&&", "SCALAR_FLOAT_MODE_P", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", ")", "pflags", "->", "is_fp", "=", "1", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "AND", ")", "pflags", "->", "is_and", "=", "1", ";", "else", "if", "(", "GET_CODE", "(", "src", ")", "==", "IOR", ")", "pflags", "->", "is_or", "=", "1", ";", "break", ";", "}", "}", "</s>" ]

[ "Examine", "X", ",", "which", "is", "a", "SET", "rtx", ",", "and", "update", "the", "flags", ",", "the", "predicate", ",", "and", "the", "condition", ",", "stored", "in", "*", "PFLAGS", ",", "*", "PPRED", "and", "*", "PCOND", "." ]

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

[]

[ "<s>", "static", "void", "frv_io_check_address", "(", "rtx", "x", ",", "rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "rtx", "*", "other", "=", "data", ";", "if", "(", "REG_P", "(", "x", ")", "&&", "*", "other", "!=", "0", "&&", "reg_overlap_mentioned_p", "(", "x", ",", "*", "other", ")", ")", "*", "other", "=", "0", ";", "}", "</s>" ]

[ "A", "note_stores", "callback", "for", "which", "DATA", "points", "to", "an", "rtx", ".", "Nullify", "*", "DATA", "if", "X", "is", "a", "register", "and", "*", "DATA", "depends", "on", "X", "." ]

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

[]

[ "<s>", "bool", "X86FastTileConfig", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MFunc", ")", "{", "MF", "=", "&", "MFunc", ";", "MRI", "=", "&", "MFunc", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MFunc", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "TII", "=", "MFunc", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "return", "fastTileConfig", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "sh_cannot_copy_insn_p", "(", "rtx", "insn", ")", "{", "rtx", "pat", ";", "if", "(", "!", "reload_completed", "||", "!", "flag_pic", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "insn", ")", "!=", "INSN", ")", "return", "false", ";", "if", "(", "asm_noperands", "(", "insn", ")", ">=", "0", ")", "return", "false", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "return", "false", ";", "pat", "=", "SET_SRC", "(", "pat", ")", ";", "if", "(", "unspec_caller_rtx_p", "(", "pat", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Indicate", "that", "INSN", "can", "not", "be", "duplicated", ".", "This", "is", "true", "for", "insn", "that", "generates", "a", "unique", "label", "." ]

[ "sh", "0" ]

[]

[ "<s>", "bool", "WebAssemblyLateEHPrepare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "Wasm", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "Changed", "|=", "removeUnnecessaryUnreachables", "(", "MF", ")", ";", "Changed", "|=", "addRethrows", "(", "MF", ")", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "return", "Changed", ";", "Changed", "|=", "replaceFuncletReturns", "(", "MF", ")", ";", "Changed", "|=", "hoistCatches", "(", "MF", ")", ";", "Changed", "|=", "addCatchAlls", "(", "MF", ")", ";", "Changed", "|=", "ensureSingleBBTermPads", "(", "MF", ")", ";", "Changed", "|=", "mergeTerminatePads", "(", "MF", ")", ";", "Changed", "|=", "addCatchAllTerminatePads", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "SDValue", "Cpu0TargetLowering", "::", "LowerCall", "(", "TargetLowering", "::", "CallLoweringInfo", "&", "CLI", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "return", "CLI", ".", "Chain", ";", "}", "</s>" ]

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

[ "Cpu0", "Cpu0" ]

[]

[ "<s>", "unsigned", "RISCVInstrInfo", "::", "getInstSizeInBytes", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "{", "return", "get", "(", "Opcode", ")", ".", "getSize", "(", ")", ";", "}", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "DBG_VALUE", ":", "return", "0", ";", "case", "RISCV", "::", "PseudoCALL", ":", "case", "RISCV", "::", "PseudoTAIL", ":", "return", "8", ";", "case", "TargetOpcode", "::", "INLINEASM", ":", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "auto", "&", "TM", "=", "static_cast", "<", "const", "RISCVTargetMachine", "&", ">", "(", "MF", ".", "getTarget", "(", ")", ")", ";", "return", "getInlineAsmLength", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "*", "TM", ".", "getMCAsmInfo", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Returns", "the", "size", "in", "bytes", "of", "the", "specified", "MachineInstr", ",", "or", "~0U", "when", "this", "function", "is", "not", "implemented", "by", "a", "target", "." ]

[ "RISCV", "RISCV", "0", "RISCV::PseudoCALL", "RISCV::PseudoTAIL", "8", "RISCV", "0" ]

[]

[ "<s>", "opt_machine_mode", "arm_get_mask_mode", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_HAVE_MVE", ")", "return", "arm_mode_to_pred_mode", "(", "mode", ")", ";", "return", "default_get_mask_mode", "(", "mode", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_GET_MASK_MODE", "." ]

[ "arm" ]

[]

[ "<s>", "static", "int", "arm_address_register_rtx_p", "(", "rtx", "x", ",", "int", "strict_p", ")", "{", "int", "regno", ";", "if", "(", "!", "REG_P", "(", "x", ")", ")", "return", "0", ";", "regno", "=", "REGNO", "(", "x", ")", ";", "if", "(", "strict_p", ")", "return", "ARM_REGNO_OK_FOR_BASE_P", "(", "regno", ")", ";", "return", "(", "regno", "<=", "LAST_ARM_REGNUM", "||", "regno", ">=", "FIRST_PSEUDO_REGISTER", "||", "regno", "==", "FRAME_POINTER_REGNUM", "||", "regno", "==", "ARG_POINTER_REGNUM", ")", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "X", "is", "valid", "as", "an", "ARM", "state", "addressing", "register", "." ]

[ "arm", "0" ]

[]

[ "<s>", "static", "inline", "VConstraintType", "getConstraint", "(", "uint64_t", "TSFlags", ")", "{", "return", "static_cast", "<", "VConstraintType", ">", "(", "(", "TSFlags", "&", "ConstraintMask", ")", ">>", "ConstraintShift", ")", ";", "}", "</s>" ]

[ "Fetch", "condition", "in", "the", "form", "of", "PredicateConstraint", ",", "if", "possible", "." ]

[ "RISCV" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isLegalAddImmediate", "(", "int64_t", "Imm", ")", "const", "{", "return", "Imm", "==", "(", "int32_t", ")", "Imm", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "immediate", "is", "legal", "add", "immediate", ",", "that", "is", "the", "target", "has", "add", "instructions", "which", "can", "add", "a", "register", "and", "the", "immediate", "without", "having", "to", "materialize", "the", "immediate", "into", "a", "register", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "int", "iq2000_adjust_insn_length", "(", "rtx_insn", "*", "insn", ",", "int", "length", ")", "{", "if", "(", "simplejump_p", "(", "insn", ")", "||", "(", "(", "JUMP_P", "(", "insn", ")", "||", "CALL_P", "(", "insn", ")", ")", ")", ")", "length", "+=", "4", ";", "return", "length", ";", "}", "</s>" ]

[ "Return", "the", "length", "of", "INSN", ".", "LENGTH", "is", "the", "initial", "length", "computed", "by", "attributes", "in", "the", "machine-description", "file", "." ]

[ "iq2000", "4" ]

[]

[ "<s>", "const", "TargetRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "AArch64" ]

[]

[ "<s>", "static", "sbitmap", "aarch64_components_for_bb", "(", "basic_block", "bb", ")", "{", "bitmap", "in", "=", "DF_LIVE_IN", "(", "bb", ")", ";", "bitmap", "gen", "=", "&", "DF_LIVE_BB_INFO", "(", "bb", ")", "->", "gen", ";", "bitmap", "kill", "=", "&", "DF_LIVE_BB_INFO", "(", "bb", ")", "->", "kill", ";", "sbitmap", "components", "=", "sbitmap_alloc", "(", "LAST_SAVED_REGNUM", "+", "1", ")", ";", "bitmap_clear", "(", "components", ")", ";", "function_abi_aggregator", "callee_abis", ";", "rtx_insn", "*", "insn", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "if", "(", "CALL_P", "(", "insn", ")", ")", "callee_abis", ".", "note_callee_abi", "(", "insn_callee_abi", "(", "insn", ")", ")", ";", "HARD_REG_SET", "extra_caller_saves", "=", "callee_abis", ".", "caller_save_regs", "(", "*", "crtl", "->", "abi", ")", ";", "for", "(", "unsigned", "regno", "=", "0", ";", "regno", "<=", "LAST_SAVED_REGNUM", ";", "regno", "++", ")", "if", "(", "!", "fixed_regs", "[", "regno", "]", "&&", "!", "crtl", "->", "abi", "->", "clobbers_full_reg_p", "(", "regno", ")", "&&", "(", "TEST_HARD_REG_BIT", "(", "extra_caller_saves", ",", "regno", ")", "||", "bitmap_bit_p", "(", "in", ",", "regno", ")", "||", "bitmap_bit_p", "(", "gen", ",", "regno", ")", "||", "bitmap_bit_p", "(", "kill", ",", "regno", ")", ")", ")", "{", "bitmap_set_bit", "(", "components", ",", "regno", ")", ";", "poly_int64", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno", "]", ";", "unsigned", "regno2", "=", "multiple_p", "(", "offset", ",", "16", ")", "?", "regno", "+", "1", ":", "regno", "-", "1", ";", "if", "(", "regno2", "<=", "LAST_SAVED_REGNUM", ")", "{", "poly_int64", "offset2", "=", "cfun", "->", "machine", "->", "frame", ".", "reg_offset", "[", "regno2", "]", ";", "if", "(", "regno", "<", "regno2", "?", "known_eq", "(", "offset", "+", "8", ",", "offset2", ")", ":", "multiple_p", "(", "offset2", ",", "16", ")", "&&", "known_eq", "(", "offset2", "+", "8", ",", "offset", ")", ")", "bitmap_set_bit", "(", "components", ",", "regno2", ")", ";", "}", "}", "return", "components", ";", "}", "</s>" ]

[ "Implement", "TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB", "." ]

[ "aarch64", "1", "0", "16", "1", "1", "8", "16", "8" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "bool", "HasAVX", "=", "TM", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ".", "hasAVX", "(", ")", ";", "MachineInstrBuilder", "MIB", "(", "*", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ",", "MI", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "case", "X86", "::", "SETB_C8r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB8rr", ")", ")", ";", "case", "X86", "::", "SETB_C16r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB16rr", ")", ")", ";", "case", "X86", "::", "SETB_C32r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB32rr", ")", ")", ";", "case", "X86", "::", "SETB_C64r", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "SBB64rr", ")", ")", ";", "case", "X86", "::", "V_SET0", ":", "case", "X86", "::", "FsFLD0SS", ":", "case", "X86", "::", "FsFLD0SD", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VXORPSrr", ":", "X86", "::", "XORPSrr", ")", ")", ";", "case", "X86", "::", "AVX_SET0", ":", "assert", "(", "HasAVX", "&&", "\"AVX not supported\"", ")", ";", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VXORPSYrr", ")", ")", ";", "case", "X86", "::", "AVX512_512_SET0", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPXORDZrr", ")", ")", ";", "case", "X86", "::", "V_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "HasAVX", "?", "X86", "::", "VPCMPEQDrr", ":", "X86", "::", "PCMPEQDrr", ")", ")", ";", "case", "X86", "::", "AVX2_SETALLONES", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "VPCMPEQDYrr", ")", ")", ";", "case", "X86", "::", "TEST8ri_NOREX", ":", "MI", "->", "setDesc", "(", "get", "(", "X86", "::", "TEST8ri", ")", ")", ";", "return", "true", ";", "case", "X86", "::", "KSET0W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXORWrr", ")", ")", ";", "case", "X86", "::", "KSET1B", ":", "case", "X86", "::", "KSET1W", ":", "return", "Expand2AddrUndef", "(", "MIB", ",", "get", "(", "X86", "::", "KXNORWrr", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86::SETB_C8r", "X86::SBB8rr", "X86::SETB_C16r", "X86::SBB16rr", "X86::SETB_C32r", "X86::SBB32rr", "X86::SETB_C64r", "X86::SBB64rr", "X86::V_SET0", "X86::FsFLD0SS", "X86::FsFLD0SD", "X86::VXORPSrr", "X86::XORPSrr", "X86::AVX_SET0", "\"AVX not supported\"", "X86::VXORPSYrr", "X86::AVX512_512_SET0", "X86::VPXORDZrr", "X86::V_SETALLONES", "X86::VPCMPEQDrr", "X86::PCMPEQDrr", "X86::AVX2_SETALLONES", "X86::VPCMPEQDYrr", "X86::TEST8ri_NOREX", "X86::TEST8ri", "X86::KSET0W", "X86::KXORWrr", "X86::KSET1B", "X86::KSET1W", "X86::KXNORWrr" ]

[]

[ "<s>", "enum", "machine_mode", "arc_select_cc_mode", "(", "enum", "rtx_code", "op", ",", "rtx", "x", "ATTRIBUTE_UNUSED", ",", "rtx", "y", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "op", ")", "{", "case", "EQ", ":", "case", "NE", ":", "return", "CCZNmode", ";", "default", ":", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "SIGN_EXTEND", ":", "case", "ZERO_EXTEND", ":", "return", "CCZNmode", ";", "case", "ASHIFT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "return", "CCZNCmode", ";", "default", ":", "break", ";", "}", "}", "return", "CCmode", ";", "}", "</s>" ]

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

[ "arc" ]

[]

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

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

[ "TMS320C64X", "\"TMS320C64X Assembly Printer\"" ]

[]

[ "<s>", "machine_mode", "cris_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", ")", "{", "if", "(", "for_return", "==", "1", ")", "return", "mode", ";", "return", "CRIS_PROMOTED_MODE", "(", "mode", ",", "*", "punsignedp", ",", "type", ")", ";", "}", "</s>" ]

[ "A", "combination", "of", "defining", "TARGET_PROMOTE_FUNCTION_MODE", ",", "promoting", "arguments", "and", "*", "not", "*", "defining", "TARGET_PROMOTE_PROTOTYPES", "or", "PROMOTE_MODE", "gives", "the", "best", "code", "size", "and", "speed", "for", "gcc", ",", "ipps", "and", "products", "in", "gcc-2.7.2", "." ]

[ "cris", "1" ]

[]