src/arch/mips/isa/formats/branch.isa - public/gem5 - Git at Google

 // -*- mode:c++ -*-

 // Copyright (c) 2007 MIPS Technologies, Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met: redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer;
 // redistributions in binary form must reproduce the above copyright
 // notice, this list of conditions and the following disclaimer in the
 // documentation and/or other materials provided with the distribution;
 // neither the name of the copyright holders nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 ////////////////////////////////////////////////////////////////////
 //
 // Control transfer instructions
 //

 output header {{

 #include <iostream>

     /**
      * Base class for instructions whose disassembly is not purely a
      * function of the machine instruction (i.e., it depends on the
      * PC).  This class overrides the disassemble() method to check
      * the PC and symbol table values before re-using a cached
      * disassembly string.  This is necessary for branches and jumps,
      * where the disassembly string includes the target address (which
      * may depend on the PC and/or symbol table).
      */
     class PCDependentDisassembly : public MipsStaticInst
     {
       protected:
         /// Cached program counter from last disassembly
         mutable Addr cachedPC;

         /// Cached symbol table pointer from last disassembly
         mutable const loader::SymbolTable *cachedSymtab;

         /// Constructor
         PCDependentDisassembly(const char *mnem, MachInst _machInst,
                                OpClass __opClass)
             : MipsStaticInst(mnem, _machInst, __opClass),
               cachedPC(0), cachedSymtab(0)
         {
         }

         const std::string &
         disassemble(Addr pc, const loader::SymbolTable *symtab) const;
     };

     /**
      * Base class for branches (PC-relative control transfers),
      * conditional or unconditional.
      */
     class Branch : public PCDependentDisassembly
     {
       protected:
         /// target address (signed) Displacement .
         int32_t disp;

         /// Constructor.
         Branch(const char *mnem, MachInst _machInst, OpClass __opClass)
             : PCDependentDisassembly(mnem, _machInst, __opClass),
               disp(OFFSET << 2)
         {
             //If Bit 17 is 1 then Sign Extend
             if ( (disp & 0x00020000) > 0  ) {
                 disp |= 0xFFFE0000;
             }
         }

         std::unique_ptr<PCStateBase> branchTarget(
                 const PCStateBase &branch_pc) const override;

         /// Explicitly import the otherwise hidden branchTarget
         using StaticInst::branchTarget;

         std::string generateDisassembly(
                 Addr pc, const loader::SymbolTable *symtab) const override;
     };

     /**
      * Base class for jumps (register-indirect control transfers).  In
      * the Mips ISA, these are always unconditional.
      */
     class Jump : public PCDependentDisassembly
     {
       protected:

         /// Displacement to target address (signed).
         int32_t disp;

         uint32_t target;

       public:
         /// Constructor
         Jump(const char *mnem, MachInst _machInst, OpClass __opClass)
             : PCDependentDisassembly(mnem, _machInst, __opClass),
               disp(JMPTARG << 2)
         {
         }

         std::unique_ptr<PCStateBase> branchTarget(
                 ThreadContext *tc) const override;

         /// Explicitly import the otherwise hidden branchTarget
         using StaticInst::branchTarget;

         std::string generateDisassembly(
                 Addr pc, const loader::SymbolTable *symtab) const override;
     };
 }};

 output decoder {{
     std::unique_ptr<PCStateBase>
     Branch::branchTarget(const PCStateBase &branch_pc) const
     {
         PCStateBase *target_ptr = branch_pc.clone();
         auto &target = target_ptr->as<MipsISA::PCState>();
         target.advance();
         target.npc(branch_pc.instAddr() + sizeof(MachInst) + disp);
         target.nnpc(target.npc() + sizeof(MachInst));
         return std::unique_ptr<PCStateBase>{target_ptr};
     }

     std::unique_ptr<PCStateBase>
     Jump::branchTarget(ThreadContext *tc) const
     {
         PCStateBase *target_ptr = tc->pcState().clone();
         auto &target = target_ptr->as<MipsISA::PCState>();
         Addr pc = target.pc();
         target.advance();
         target.npc((pc & 0xF0000000) | disp);
         target.nnpc(target.npc() + sizeof(MachInst));
         return std::unique_ptr<PCStateBase>{target_ptr};
     }

     const std::string &
     PCDependentDisassembly::disassemble(
             Addr pc, const loader::SymbolTable *symtab) const
     {
         if (!cachedDisassembly || pc != cachedPC || symtab != cachedSymtab) {
             if (!cachedDisassembly)
                 cachedDisassembly.reset(new std::string);

             *cachedDisassembly = generateDisassembly(pc, symtab);
             cachedPC = pc;
             cachedSymtab = symtab;
         }

         return *cachedDisassembly;
     }

     std::string
     Branch::generateDisassembly(
             Addr pc, const loader::SymbolTable *symtab) const
     {
         std::stringstream ss;

         ccprintf(ss, "%-10s ", mnemonic);

         // There's only one register arg (RA), but it could be
         // either a source (the condition for conditional
         // branches) or a destination (the link reg for
         // unconditional branches)
         if (_numSrcRegs == 1) {
             printReg(ss, srcRegIdx(0));
             ss << ", ";
         } else if(_numSrcRegs == 2) {
             printReg(ss, srcRegIdx(0));
             ss << ", ";
             printReg(ss, srcRegIdx(1));
             ss << ", ";
         }

         Addr target = pc + 4 + disp;

         loader::SymbolTable::const_iterator it;
         if (symtab && (it = symtab->find(target)) != symtab->end())
             ss << it->name;
         else
             ccprintf(ss, "%#x", target);

         return ss.str();
     }

     std::string
     Jump::generateDisassembly(Addr pc, const loader::SymbolTable *symtab) const
     {
         std::stringstream ss;

         ccprintf(ss, "%-10s ", mnemonic);

         if ( strcmp(mnemonic,"jal") == 0 ) {
             Addr npc = pc + 4;
             ccprintf(ss,"0x%x",(npc & 0xF0000000) | disp);
         } else if (_numSrcRegs == 0) {
             loader::SymbolTable::const_iterator it;
             if (symtab && (it = symtab->find(disp)) != symtab->end())
                 ss << it->name;
             else
                 ccprintf(ss, "0x%x", disp);
         } else if (_numSrcRegs == 1) {
              printReg(ss, srcRegIdx(0));
         } else if(_numSrcRegs == 2) {
             printReg(ss, srcRegIdx(0));
             ss << ", ";
             printReg(ss, srcRegIdx(1));
         }

         return ss.str();
     }
 }};

 def format Branch(code, *opt_flags) {{
     not_taken_code = 'NNPC = NNPC; NPC = NPC;'

     #Build Instruction Flags
     #Use Link & Likely Flags to Add Link/Condition Code
     inst_flags = ('IsDirectControl', )
     for x in opt_flags:
         if x == 'Link':
             code += 'R31 = NNPC;\n'
         elif x == 'Likely':
             not_taken_code = 'NNPC = NPC; NPC = PC;'
         else:
             inst_flags += (x, )

     #Take into account uncond. branch instruction
     if 'cond = 1' in code:
          inst_flags += ('IsUncondControl', )
     else:
          inst_flags += ('IsCondControl', )

     #Condition code
     code = '''
     bool cond;
     %(code)s
     if (cond) {
         NNPC = NPC + disp;
     } else {
         %(not_taken_code)s
     }
     ''' % { "code" : code, "not_taken_code" : not_taken_code }

     iop = InstObjParams(name, Name, 'Branch', code, inst_flags)
     header_output = BasicDeclare.subst(iop)
     decoder_output = BasicConstructor.subst(iop)
     decode_block = BasicDecode.subst(iop)
     exec_output = BasicExecute.subst(iop)
 }};

 def format DspBranch(code, *opt_flags) {{
     not_taken_code = 'NNPC = NNPC; NPC = NPC;'

     #Build Instruction Flags
     #Use Link & Likely Flags to Add Link/Condition Code
     inst_flags = ('IsDirectControl', )
     for x in opt_flags:
         if x == 'Link':
             code += 'R32 = NNPC;'
         elif x == 'Likely':
             not_taken_code = 'NNPC = NPC, NPC = PC;'
         else:
             inst_flags += (x, )

     #Take into account uncond. branch instruction
     if 'cond = 1' in code:
          inst_flags += ('IsUncondControl', )
     else:
          inst_flags += ('IsCondControl', )

     #Condition code
     code = '''
     bool cond;
     uint32_t dspctl = DSPControl;
     %(code)s
     if (cond) {
         NNPC = NPC + disp;
     } else {
         %(not_taken_code)s
     }
     ''' % { "code" : code, "not_taken_code" : not_taken_code }

     iop = InstObjParams(name, Name, 'Branch', code, inst_flags)
     header_output = BasicDeclare.subst(iop)
     decoder_output = BasicConstructor.subst(iop)
     decode_block = BasicDecode.subst(iop)
     exec_output = BasicExecute.subst(iop)
 }};

 def format Jump(code, *opt_flags) {{
     #Build Instruction Flags
     #Use Link Flag to Add Link Code
     inst_flags = ('IsIndirectControl', 'IsUncondControl')
     for x in opt_flags:
         if x == 'Link':
             code = '''
             R31 = NNPC;
             ''' + code
         elif x == 'ClearHazards':
             code += '/* Code Needed to Clear Execute & Inst Hazards */\n'
         else:
             inst_flags += (x, )

     iop = InstObjParams(name, Name, 'Jump', code, inst_flags)
     header_output = BasicDeclare.subst(iop)
     decoder_output = BasicConstructor.subst(iop)
     decode_block = BasicDecode.subst(iop)
     exec_output = BasicExecute.subst(iop)
 }};
	// -- mode:c++ --

	// Copyright (c) 2007 MIPS Technologies, Inc.
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without
	// modification, are permitted provided that the following conditions are
	// met: redistributions of source code must retain the above copyright
	// notice, this list of conditions and the following disclaimer;
	// redistributions in binary form must reproduce the above copyright
	// notice, this list of conditions and the following disclaimer in the
	// documentation and/or other materials provided with the distribution;
	// neither the name of the copyright holders nor the names of its
	// contributors may be used to endorse or promote products derived from
	// this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	////////////////////////////////////////////////////////////////////
	//
	// Control transfer instructions
	//

	output header {{

	#include <iostream>

	/**
	* Base class for instructions whose disassembly is not purely a
	* function of the machine instruction (i.e., it depends on the
	* PC). This class overrides the disassemble() method to check
	* the PC and symbol table values before re-using a cached
	* disassembly string. This is necessary for branches and jumps,
	* where the disassembly string includes the target address (which
	* may depend on the PC and/or symbol table).
	*/
	class PCDependentDisassembly : public MipsStaticInst
	{
	protected:
	/// Cached program counter from last disassembly
	mutable Addr cachedPC;

	/// Cached symbol table pointer from last disassembly
	mutable const loader::SymbolTable *cachedSymtab;

	/// Constructor
	PCDependentDisassembly(const char *mnem, MachInst _machInst,
	OpClass __opClass)
	: MipsStaticInst(mnem, _machInst, __opClass),
	cachedPC(0), cachedSymtab(0)
	{
	}

	const std::string &
	disassemble(Addr pc, const loader::SymbolTable *symtab) const;
	};

	/**
	* Base class for branches (PC-relative control transfers),
	* conditional or unconditional.
	*/
	class Branch : public PCDependentDisassembly
	{
	protected:
	/// target address (signed) Displacement .
	int32_t disp;

	/// Constructor.
	Branch(const char *mnem, MachInst _machInst, OpClass __opClass)
	: PCDependentDisassembly(mnem, _machInst, __opClass),
	disp(OFFSET << 2)
	{
	//If Bit 17 is 1 then Sign Extend
	if ( (disp & 0x00020000) > 0 ) {
	disp \|= 0xFFFE0000;
	}
	}

	std::unique_ptr<PCStateBase> branchTarget(
	const PCStateBase &branch_pc) const override;

	/// Explicitly import the otherwise hidden branchTarget
	using StaticInst::branchTarget;

	std::string generateDisassembly(
	Addr pc, const loader::SymbolTable *symtab) const override;
	};

	/**
	* Base class for jumps (register-indirect control transfers). In
	* the Mips ISA, these are always unconditional.
	*/
	class Jump : public PCDependentDisassembly
	{
	protected:

	/// Displacement to target address (signed).
	int32_t disp;

	uint32_t target;

	public:
	/// Constructor
	Jump(const char *mnem, MachInst _machInst, OpClass __opClass)
	: PCDependentDisassembly(mnem, _machInst, __opClass),
	disp(JMPTARG << 2)
	{
	}

	std::unique_ptr<PCStateBase> branchTarget(
	ThreadContext *tc) const override;

	/// Explicitly import the otherwise hidden branchTarget
	using StaticInst::branchTarget;

	std::string generateDisassembly(
	Addr pc, const loader::SymbolTable *symtab) const override;
	};
	}};

	output decoder {{
	std::unique_ptr<PCStateBase>
	Branch::branchTarget(const PCStateBase &branch_pc) const
	{
	PCStateBase *target_ptr = branch_pc.clone();
	auto &target = target_ptr->as<MipsISA::PCState>();
	target.advance();
	target.npc(branch_pc.instAddr() + sizeof(MachInst) + disp);
	target.nnpc(target.npc() + sizeof(MachInst));
	return std::unique_ptr<PCStateBase>{target_ptr};
	}

	std::unique_ptr<PCStateBase>
	Jump::branchTarget(ThreadContext *tc) const
	{
	PCStateBase *target_ptr = tc->pcState().clone();
	auto &target = target_ptr->as<MipsISA::PCState>();
	Addr pc = target.pc();
	target.advance();
	target.npc((pc & 0xF0000000) \| disp);
	target.nnpc(target.npc() + sizeof(MachInst));
	return std::unique_ptr<PCStateBase>{target_ptr};
	}

	const std::string &
	PCDependentDisassembly::disassemble(
	Addr pc, const loader::SymbolTable *symtab) const
	{
	if (!cachedDisassembly \|\| pc != cachedPC \|\| symtab != cachedSymtab) {
	if (!cachedDisassembly)
	cachedDisassembly.reset(new std::string);

	*cachedDisassembly = generateDisassembly(pc, symtab);
	cachedPC = pc;
	cachedSymtab = symtab;
	}

	return *cachedDisassembly;
	}

	std::string
	Branch::generateDisassembly(
	Addr pc, const loader::SymbolTable *symtab) const
	{
	std::stringstream ss;

	ccprintf(ss, "%-10s ", mnemonic);

	// There's only one register arg (RA), but it could be
	// either a source (the condition for conditional
	// branches) or a destination (the link reg for
	// unconditional branches)
	if (_numSrcRegs == 1) {
	printReg(ss, srcRegIdx(0));
	ss << ", ";
	} else if(_numSrcRegs == 2) {
	printReg(ss, srcRegIdx(0));
	ss << ", ";
	printReg(ss, srcRegIdx(1));
	ss << ", ";
	}

	Addr target = pc + 4 + disp;

	loader::SymbolTable::const_iterator it;
	if (symtab && (it = symtab->find(target)) != symtab->end())
	ss << it->name;
	else
	ccprintf(ss, "%#x", target);

	return ss.str();
	}

	std::string
	Jump::generateDisassembly(Addr pc, const loader::SymbolTable *symtab) const
	{
	std::stringstream ss;

	ccprintf(ss, "%-10s ", mnemonic);

	if ( strcmp(mnemonic,"jal") == 0 ) {
	Addr npc = pc + 4;
	ccprintf(ss,"0x%x",(npc & 0xF0000000) \| disp);
	} else if (_numSrcRegs == 0) {
	loader::SymbolTable::const_iterator it;
	if (symtab && (it = symtab->find(disp)) != symtab->end())
	ss << it->name;
	else
	ccprintf(ss, "0x%x", disp);
	} else if (_numSrcRegs == 1) {
	printReg(ss, srcRegIdx(0));
	} else if(_numSrcRegs == 2) {
	printReg(ss, srcRegIdx(0));
	ss << ", ";
	printReg(ss, srcRegIdx(1));
	}

	return ss.str();
	}
	}};

	def format Branch(code, *opt_flags) {{
	not_taken_code = 'NNPC = NNPC; NPC = NPC;'

	#Build Instruction Flags
	#Use Link & Likely Flags to Add Link/Condition Code
	inst_flags = ('IsDirectControl', )
	for x in opt_flags:
	if x == 'Link':
	code += 'R31 = NNPC;\n'
	elif x == 'Likely':
	not_taken_code = 'NNPC = NPC; NPC = PC;'
	else:
	inst_flags += (x, )

	#Take into account uncond. branch instruction
	if 'cond = 1' in code:
	inst_flags += ('IsUncondControl', )
	else:
	inst_flags += ('IsCondControl', )

	#Condition code
	code = '''
	bool cond;
	%(code)s
	if (cond) {
	NNPC = NPC + disp;
	} else {
	%(not_taken_code)s
	}
	''' % { "code" : code, "not_taken_code" : not_taken_code }

	iop = InstObjParams(name, Name, 'Branch', code, inst_flags)
	header_output = BasicDeclare.subst(iop)
	decoder_output = BasicConstructor.subst(iop)
	decode_block = BasicDecode.subst(iop)
	exec_output = BasicExecute.subst(iop)
	}};

	def format DspBranch(code, *opt_flags) {{
	not_taken_code = 'NNPC = NNPC; NPC = NPC;'

	#Build Instruction Flags
	#Use Link & Likely Flags to Add Link/Condition Code
	inst_flags = ('IsDirectControl', )
	for x in opt_flags:
	if x == 'Link':
	code += 'R32 = NNPC;'
	elif x == 'Likely':
	not_taken_code = 'NNPC = NPC, NPC = PC;'
	else:
	inst_flags += (x, )

	#Take into account uncond. branch instruction
	if 'cond = 1' in code:
	inst_flags += ('IsUncondControl', )
	else:
	inst_flags += ('IsCondControl', )

	#Condition code
	code = '''
	bool cond;
	uint32_t dspctl = DSPControl;
	%(code)s
	if (cond) {
	NNPC = NPC + disp;
	} else {
	%(not_taken_code)s
	}
	''' % { "code" : code, "not_taken_code" : not_taken_code }

	iop = InstObjParams(name, Name, 'Branch', code, inst_flags)
	header_output = BasicDeclare.subst(iop)
	decoder_output = BasicConstructor.subst(iop)
	decode_block = BasicDecode.subst(iop)
	exec_output = BasicExecute.subst(iop)
	}};

	def format Jump(code, *opt_flags) {{
	#Build Instruction Flags
	#Use Link Flag to Add Link Code
	inst_flags = ('IsIndirectControl', 'IsUncondControl')
	for x in opt_flags:
	if x == 'Link':
	code = '''
	R31 = NNPC;
	''' + code
	elif x == 'ClearHazards':
	code += '/* Code Needed to Clear Execute & Inst Hazards */\n'
	else:
	inst_flags += (x, )

	iop = InstObjParams(name, Name, 'Jump', code, inst_flags)
	header_output = BasicDeclare.subst(iop)
	decoder_output = BasicConstructor.subst(iop)
	decode_block = BasicDecode.subst(iop)
	exec_output = BasicExecute.subst(iop)
	}};