C# (CSharp) X86Register8 Examples

Example #1

File: X86Writer.ShiftRight.cs Project: YHVHvx/managed-x86

		public void Shr8(X86Register8 reg, byte count) {
			if (count == 1) {
				writer.Write(new byte[] { 0xD0 });
				reg_emit8((X86Register8)5, reg);
			} else {
				writer.Write(new byte[] { 0xC0 });
				reg_emit8((X86Register8)5, reg);
				imm_emit8(count);
			}
		}

Example #2

 public void Shl8(X86Register8 reg, byte count)
 {
     if (count == 1)
     {
         writer.Write(new byte[] { 0xD0 });
         reg_emit8((X86Register8)4, reg);
     }
     else
     {
         writer.Write(new byte[] { 0xC0 });
         reg_emit8((X86Register8)4, reg);
         imm_emit8(count);
     }
 }

Example #3

File: X86Writer.CompareExchange.cs Project: labradore/managed-x86

 public void CmpXChg8(X86Address dest, X86Register8 src)
 {
     writer.Write(new byte[] { 0x0F, 0xB0 });
     dest.Emit(writer, src);
 }

Example #4

 public void AddC8(X86Register8 dest, X86Register8 src)
 {
     writer.Write(new byte[] { 0x10 });
     reg_emit8(dest, src);
 }

Example #5

 public void Shl8(X86Register8 reg)
 {
     writer.Write(new byte[] { 0xD2 });
     reg_emit8((X86Register8)4, reg);
 }

Example #6

 public void IMul8(X86Register8 dest, X86Register8 src)
 {
     writer.Write(new byte[] { 0x0F, 0xAE });
     reg_emit8(dest, src);
 }

Example #7

File: X86Writer.CompareExchange.cs Project: YHVHvx/managed-x86

		public void CmpXChg8(X86Address dest, X86Register8 src) {
			writer.Write(new byte[] { 0x0F, 0xB0 });
			dest.Emit(writer, src);
		}

Example #8

 public void Negate8(X86Register8 dest)
 {
     writer.Write(new byte[] { 0xF6 });
     reg_emit8((X86Register8)3, dest);
 }

Example #9

File: X86Writer.Negate.cs Project: YHVHvx/managed-x86

		public void Negate8(X86Register8 dest) {
			writer.Write(new byte[] { 0xF6 });
			reg_emit8((X86Register8)3, dest);
		}

Example #10

File: X86Writer.Subtract.cs Project: YHVHvx/managed-x86

		public void Sub8(X86Register8 dest, X86Register8 src) {
			writer.Write(new byte[] { 0x2A });
			reg_emit8(dest, src);
		}

Example #11

File: X86Writer.Compare.cs Project: YHVHvx/managed-x86

		public void Cmp8(X86Register8 dest, Byte src) {
			writer.Write(new byte[] { 0x80 });
			reg_emit8((X86Register8)7, dest);
			imm_emit8(src);
		}

Example #12

File: X86Writer.Compare.cs Project: YHVHvx/managed-x86

		public void Cmp8(X86Register8 dest, X86Register8 src) {
			writer.Write(new byte[] { 0x38 });
			reg_emit8(dest, src);
		}

Example #13

File: X86Writer.Multiply.cs Project: YHVHvx/managed-x86

		public void IMul8 (X86Register8 dest, X86Register8 src) {
			writer.Write(new byte[] { 0x0F, 0xAE });
			reg_emit8(dest, src);
		}

Example #14

File: X86Writer.Multiply.cs Project: YHVHvx/managed-x86

		public void Mul8(X86Register8 src) {
			writer.Write(new byte[] { 0xF6 });
			reg_emit8((X86Register8)4, src);
		}

Example #15

File: X86Address.cs Project: YHVHvx/managed-x86

		internal void Emit(BinaryWriter writer, X86Register8 otherReg) {
			this.Emit(writer, (byte)otherReg);
		}

Example #16

File: X86Writer.Or.cs Project: RaphaelK12/DSFBX

 public void Or8(X86Register8 dest, X86Register8 src)
 {
     writer.Write(new byte[] { 0x08 });
     reg_emit8(dest, src);
 }

Example #17

File: X86Writer.Or.cs Project: RaphaelK12/DSFBX

 public void Or8(X86Register8 dest, X86Address src)
 {
     writer.Write(new byte[] { 0x0A });
     src.Emit(writer, dest);
 }

Example #18

 public void Mov8(X86Register8 dest, Byte value)
 {
     this.writer.Write(new byte[] { 0xc6 });
     reg_emit8(0, dest);
     writer.Write(value);
 }

Example #19

File: X86Writer.cs Project: biaouch/DaS-BRush

 private void reg_emit8(X86Register8 dest, X86Register8 src)
 {
     address_byte(3, (byte)(dest), (byte)(src));
 }

Example #20

 public void Mov8(X86Address dest, X86Register8 src)
 {
     this.writer.Write(new byte[] { 0x88 });
     dest.Emit(writer, src);
 }

Example #21

File: X86Writer.Increment.cs Project: YHVHvx/managed-x86

		public void Inc8(X86Register8 reg) {
			writer.Write(new byte[] { 0xFE });
			reg_emit8((X86Register8)0, reg);
		}

Example #22

 public void Mov8(X86Register8 dest, X86Address src)
 {
     this.writer.Write(new byte[] { 0x8a });
     src.Emit(writer, dest);
 }

Example #23

File: X86Writer.ShiftRight.cs Project: YHVHvx/managed-x86

		public void Shr8(X86Register8 reg) {
			writer.Write(new byte[] { 0xD2 });
			reg_emit8((X86Register8)5, reg);
		}

Example #24

File: X86Writer.Move.cs Project: YHVHvx/managed-x86

		public void Mov8(X86Register8 dest, Byte value) {
			this.writer.Write(new byte[] { 0xc6 });
			reg_emit8(0, dest);
			writer.Write(value);
		}

Example #25

File: X86Writer.Division.cs Project: RaphaelK12/DSFBX

 public void IDiv8(X86Register8 src)
 {
     writer.Write(new byte[] { 0xF6 });
     reg_emit8((X86Register8)7, src);
 }

Example #26

File: X86Writer.Move.cs Project: YHVHvx/managed-x86

		public void Mov8(X86Address dest, X86Register8 src) {
			this.writer.Write(new byte[] { 0x88 });
			dest.Emit(writer, src);
		}

Example #27

File: X86Writer.Move.cs Project: YHVHvx/managed-x86

		public void Mov8(X86Register8 dest, X86Address src) {
			this.writer.Write(new byte[] { 0x8a });
			src.Emit(writer, dest);
		}

Example #28

File: X86Writer.Move.cs Project: YHVHvx/managed-x86

		public void Mov8(X86Register8 dest, X86Register8 src) {
			writer.Write(new byte[] { 0x8a });
			reg_emit8(dest, src);
		}

Example #29

File: X86Writer.CompareExchange.cs Project: labradore/managed-x86

 public void CmpXChg8(X86Register8 dest, X86Register8 src)
 {
     writer.Write(new byte[] { 0x0F, 0xB0 });
     reg_emit8(src, dest);
 }

Example #30

File: X86Writer.AddWithCarry.cs Project: YHVHvx/managed-x86

		public void AddC8(X86Register8 dest, X86Register8 src) {
			writer.Write(new byte[] { 0x10 });
			reg_emit8(dest, src);
		}

Example #31

File: X86Writer.Compare.cs Project: inrg/X86.Interop

 public void Cmp8(X86Register8 dest, Byte src)
 {
     writer.Write(new byte[] { 0x80 });
     reg_emit8((X86Register8)7, dest);
     imm_emit8(src);
 }

Example #32

File: X86Writer.AddWithCarry.cs Project: YHVHvx/managed-x86

		public void AddC8(X86Address dest, X86Register8 src) {
			writer.Write(new byte[] { 0x10 });
			dest.Emit(writer, src);
		}

Example #33

File: X86Writer.Or.cs Project: RaphaelK12/DSFBX

 public void Or8(X86Address dest, X86Register8 src)
 {
     writer.Write(new byte[] { 0x08 });
     dest.Emit(writer, src);
 }

Example #34

File: X86Writer.AddWithCarry.cs Project: YHVHvx/managed-x86

		public void AddC8(X86Register8 dest, X86Address src) {
			writer.Write(new byte[] { 0x12 });
			src.Emit(writer, dest);
		}

Example #35

File: X86Writer.Or.cs Project: RaphaelK12/DSFBX

 public void Or8(X86Register8 dest, Byte value)
 {
     this.writer.Write(new byte[] { 0x80 });
     reg_emit8((X86Register8)1, dest);
     writer.Write(value);
 }

Example #36

File: X86Writer.AddWithCarry.cs Project: YHVHvx/managed-x86

		public void AddC8(X86Register8 dest, Byte value) {
			this.writer.Write(new byte[] { 0x80 });
			reg_emit8((X86Register8)0x2, dest);
			writer.Write(value);
		}

Example #37

File: X86Writer.cs Project: YHVHvx/managed-x86

		private void reg_emit8(X86Register8 dest, X86Register8 src) {
			address_byte(3, (byte)(dest), (byte)(src));
		}

Example #38

 internal void Emit(BinaryWriter writer, X86Register8 otherReg)
 {
     this.Emit(writer, (byte)otherReg);
 }

Example #39

File: X86Writer.Increment.cs Project: inrg/X86.Interop

 public void Inc8(X86Register8 reg)
 {
     writer.Write(new byte[] { 0xFE });
     reg_emit8((X86Register8)0, reg);
 }

Example #40

File: X86Writer.CompareExchange.cs Project: YHVHvx/managed-x86

		public void CmpXChg8(X86Register8 dest, X86Register8 src) {
			writer.Write(new byte[] { 0x0F, 0xB0 });
			reg_emit8(src, dest);
		}