Commit | Line | Data |
---|---|---|

d958721a | 1 | /** @file |

2 | Declaration of internal functions in BaseLib. | |

3 | ||

4 | Copyright (c) 2006 - 2007, Intel Corporation<BR> | |

5 | All rights reserved. This program and the accompanying materials | |

6 | are licensed and made available under the terms and conditions of the BSD License | |

7 | which accompanies this distribution. The full text of the license may be found at | |

8 | http://opensource.org/licenses/bsd-license.php | |

9 | ||

10 | THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, | |

11 | WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. | |

12 | ||

13 | Module Name: BaseLibInternals.h | |

14 | ||

15 | **/ | |

16 | ||

17 | #ifndef __BASE_LIB_INTERNALS__ | |

18 | #define __BASE_LIB_INTERNALS__ | |

19 | ||

20 | #define QUIENT_MAX_UINTN_DIVIDED_BY_10 ((UINTN) -1 / 10) | |

21 | #define REMINDER_MAX_UINTN_DIVIDED_BY_10 ((UINTN) -1 % 10) | |

22 | ||

23 | #define QUIENT_MAX_UINTN_DIVIDED_BY_16 ((UINTN) -1 / 16) | |

24 | #define REMINDER_MAX_UINTN_DIVIDED_BY_16 ((UINTN) -1 % 16) | |

25 | ||

26 | #define QUIENT_MAX_UINT64_DIVIDED_BY_10 ((UINT64) -1 / 10) | |

27 | #define REMINDER_MAX_UINT64_DIVIDED_BY_10 ((UINT64) -1 % 10) | |

28 | ||

29 | #define QUIENT_MAX_UINT64_DIVIDED_BY_16 ((UINT64) -1 / 16) | |

30 | #define REMINDER_MAX_UINT64_DIVIDED_BY_16 ((UINT64) -1 % 16) | |

31 | ||

32 | // | |

33 | // Math functions | |

34 | // | |

35 | ||

36 | /** | |

37 | Shifts a 64-bit integer left between 0 and 63 bits. The low bits | |

38 | are filled with zeros. The shifted value is returned. | |

39 | ||

40 | This function shifts the 64-bit value Operand to the left by Count bits. The | |

41 | low Count bits are set to zero. The shifted value is returned. | |

42 | ||

43 | @param Operand The 64-bit operand to shift left. | |

44 | @param Count The number of bits to shift left. | |

45 | ||

46 | @return Operand << Count | |

47 | ||

48 | **/ | |

49 | UINT64 | |

50 | EFIAPI | |

51 | InternalMathLShiftU64 ( | |

52 | IN UINT64 Operand, | |

53 | IN UINTN Count | |

54 | ); | |

55 | ||

56 | /** | |

57 | Shifts a 64-bit integer right between 0 and 63 bits. This high bits | |

58 | are filled with zeros. The shifted value is returned. | |

59 | ||

60 | This function shifts the 64-bit value Operand to the right by Count bits. The | |

61 | high Count bits are set to zero. The shifted value is returned. | |

62 | ||

63 | @param Operand The 64-bit operand to shift right. | |

64 | @param Count The number of bits to shift right. | |

65 | ||

66 | @return Operand >> Count | |

67 | ||

68 | **/ | |

69 | UINT64 | |

70 | EFIAPI | |

71 | InternalMathRShiftU64 ( | |

72 | IN UINT64 Operand, | |

73 | IN UINTN Count | |

74 | ); | |

75 | ||

76 | /** | |

77 | Shifts a 64-bit integer right between 0 and 63 bits. The high bits | |

78 | are filled with original integer's bit 63. The shifted value is returned. | |

79 | ||

80 | This function shifts the 64-bit value Operand to the right by Count bits. The | |

81 | high Count bits are set to bit 63 of Operand. The shifted value is returned. | |

82 | ||

83 | @param Operand The 64-bit operand to shift right. | |

84 | @param Count The number of bits to shift right. | |

85 | ||

86 | @return Operand arithmetically shifted right by Count | |

87 | ||

88 | **/ | |

89 | UINT64 | |

90 | EFIAPI | |

91 | InternalMathARShiftU64 ( | |

92 | IN UINT64 Operand, | |

93 | IN UINTN Count | |

94 | ); | |

95 | ||

96 | /** | |

97 | Rotates a 64-bit integer left between 0 and 63 bits, filling | |

98 | the low bits with the high bits that were rotated. | |

99 | ||

100 | This function rotates the 64-bit value Operand to the left by Count bits. The | |

101 | low Count bits are fill with the high Count bits of Operand. The rotated | |

102 | value is returned. | |

103 | ||

104 | @param Operand The 64-bit operand to rotate left. | |

105 | @param Count The number of bits to rotate left. | |

106 | ||

107 | @return Operand <<< Count | |

108 | ||

109 | **/ | |

110 | UINT64 | |

111 | EFIAPI | |

112 | InternalMathLRotU64 ( | |

113 | IN UINT64 Operand, | |

114 | IN UINTN Count | |

115 | ); | |

116 | ||

117 | /** | |

118 | Rotates a 64-bit integer right between 0 and 63 bits, filling | |

119 | the high bits with the high low bits that were rotated. | |

120 | ||

121 | This function rotates the 64-bit value Operand to the right by Count bits. | |

122 | The high Count bits are fill with the low Count bits of Operand. The rotated | |

123 | value is returned. | |

124 | ||

125 | @param Operand The 64-bit operand to rotate right. | |

126 | @param Count The number of bits to rotate right. | |

127 | ||

128 | @return Operand >>> Count | |

129 | ||

130 | **/ | |

131 | UINT64 | |

132 | EFIAPI | |

133 | InternalMathRRotU64 ( | |

134 | IN UINT64 Operand, | |

135 | IN UINTN Count | |

136 | ); | |

137 | ||

138 | /** | |

139 | Switches the endianess of a 64-bit integer. | |

140 | ||

141 | This function swaps the bytes in a 64-bit unsigned value to switch the value | |

142 | from little endian to big endian or vice versa. The byte swapped value is | |

143 | returned. | |

144 | ||

145 | @param Operand A 64-bit unsigned value. | |

146 | ||

147 | @return The byte swaped Operand. | |

148 | ||

149 | **/ | |

150 | UINT64 | |

151 | EFIAPI | |

152 | InternalMathSwapBytes64 ( | |

153 | IN UINT64 Operand | |

154 | ); | |

155 | ||

156 | /** | |

157 | Multiples a 64-bit unsigned integer by a 32-bit unsigned integer | |

158 | and generates a 64-bit unsigned result. | |

159 | ||

160 | This function multiples the 64-bit unsigned value Multiplicand by the 32-bit | |

161 | unsigned value Multiplier and generates a 64-bit unsigned result. This 64- | |

162 | bit unsigned result is returned. | |

163 | ||

164 | @param Multiplicand A 64-bit unsigned value. | |

165 | @param Multiplier A 32-bit unsigned value. | |

166 | ||

167 | @return Multiplicand * Multiplier | |

168 | ||

169 | **/ | |

170 | UINT64 | |

171 | EFIAPI | |

172 | InternalMathMultU64x32 ( | |

173 | IN UINT64 Multiplicand, | |

174 | IN UINT32 Multiplier | |

175 | ); | |

176 | ||

177 | /** | |

178 | Multiples a 64-bit unsigned integer by a 64-bit unsigned integer | |

179 | and generates a 64-bit unsigned result. | |

180 | ||

181 | This function multiples the 64-bit unsigned value Multiplicand by the 64-bit | |

182 | unsigned value Multiplier and generates a 64-bit unsigned result. This 64- | |

183 | bit unsigned result is returned. | |

184 | ||

185 | @param Multiplicand A 64-bit unsigned value. | |

186 | @param Multiplier A 64-bit unsigned value. | |

187 | ||

188 | @return Multiplicand * Multiplier | |

189 | ||

190 | **/ | |

191 | UINT64 | |

192 | EFIAPI | |

193 | InternalMathMultU64x64 ( | |

194 | IN UINT64 Multiplicand, | |

195 | IN UINT64 Multiplier | |

196 | ); | |

197 | ||

198 | /** | |

199 | Divides a 64-bit unsigned integer by a 32-bit unsigned integer and | |

200 | generates a 64-bit unsigned result. | |

201 | ||

202 | This function divides the 64-bit unsigned value Dividend by the 32-bit | |

203 | unsigned value Divisor and generates a 64-bit unsigned quotient. This | |

204 | function returns the 64-bit unsigned quotient. | |

205 | ||

206 | @param Dividend A 64-bit unsigned value. | |

207 | @param Divisor A 32-bit unsigned value. | |

208 | ||

209 | @return Dividend / Divisor | |

210 | ||

211 | **/ | |

212 | UINT64 | |

213 | EFIAPI | |

214 | InternalMathDivU64x32 ( | |

215 | IN UINT64 Dividend, | |

216 | IN UINT32 Divisor | |

217 | ); | |

218 | ||

219 | /** | |

220 | Divides a 64-bit unsigned integer by a 32-bit unsigned integer and | |

221 | generates a 32-bit unsigned remainder. | |

222 | ||

223 | This function divides the 64-bit unsigned value Dividend by the 32-bit | |

224 | unsigned value Divisor and generates a 32-bit remainder. This function | |

225 | returns the 32-bit unsigned remainder. | |

226 | ||

227 | @param Dividend A 64-bit unsigned value. | |

228 | @param Divisor A 32-bit unsigned value. | |

229 | ||

230 | @return Dividend % Divisor | |

231 | ||

232 | **/ | |

233 | UINT32 | |

234 | EFIAPI | |

235 | InternalMathModU64x32 ( | |

236 | IN UINT64 Dividend, | |

237 | IN UINT32 Divisor | |

238 | ); | |

239 | ||

240 | /** | |

241 | Divides a 64-bit unsigned integer by a 32-bit unsigned integer and | |

242 | generates a 64-bit unsigned result and an optional 32-bit unsigned remainder. | |

243 | ||

244 | This function divides the 64-bit unsigned value Dividend by the 32-bit | |

245 | unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder | |

246 | is not NULL, then the 32-bit unsigned remainder is returned in Remainder. | |

247 | This function returns the 64-bit unsigned quotient. | |

248 | ||

249 | @param Dividend A 64-bit unsigned value. | |

250 | @param Divisor A 32-bit unsigned value. | |

251 | @param Remainder A pointer to a 32-bit unsigned value. This parameter is | |

252 | optional and may be NULL. | |

253 | ||

254 | @return Dividend / Divisor | |

255 | ||

256 | **/ | |

257 | UINT64 | |

258 | EFIAPI | |

259 | InternalMathDivRemU64x32 ( | |

260 | IN UINT64 Dividend, | |

261 | IN UINT32 Divisor, | |

262 | OUT UINT32 *Remainder | |

263 | ); | |

264 | ||

265 | /** | |

266 | Divides a 64-bit unsigned integer by a 64-bit unsigned integer and | |

267 | generates a 64-bit unsigned result and an optional 64-bit unsigned remainder. | |

268 | ||

269 | This function divides the 64-bit unsigned value Dividend by the 64-bit | |

270 | unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder | |

271 | is not NULL, then the 64-bit unsigned remainder is returned in Remainder. | |

272 | This function returns the 64-bit unsigned quotient. | |

273 | ||

274 | @param Dividend A 64-bit unsigned value. | |

275 | @param Divisor A 64-bit unsigned value. | |

276 | @param Remainder A pointer to a 64-bit unsigned value. This parameter is | |

277 | optional and may be NULL. | |

278 | ||

279 | @return Dividend / Divisor | |

280 | ||

281 | **/ | |

282 | UINT64 | |

283 | EFIAPI | |

284 | InternalMathDivRemU64x64 ( | |

285 | IN UINT64 Dividend, | |

286 | IN UINT64 Divisor, | |

287 | OUT UINT64 *Remainder | |

288 | ); | |

289 | ||

290 | /** | |

291 | Divides a 64-bit signed integer by a 64-bit signed integer and | |

292 | generates a 64-bit signed result and a optional 64-bit signed remainder. | |

293 | ||

294 | This function divides the 64-bit unsigned value Dividend by the 64-bit | |

295 | unsigned value Divisor and generates a 64-bit unsigned quotient. If Remainder | |

296 | is not NULL, then the 64-bit unsigned remainder is returned in Remainder. | |

297 | This function returns the 64-bit unsigned quotient. | |

298 | ||

299 | @param Dividend A 64-bit signed value. | |

300 | @param Divisor A 64-bit signed value. | |

301 | @param Remainder A pointer to a 64-bit signed value. This parameter is | |

302 | optional and may be NULL. | |

303 | ||

304 | @return Dividend / Divisor | |

305 | ||

306 | **/ | |

307 | INT64 | |

308 | InternalMathDivRemS64x64 ( | |

309 | IN INT64 Dividend, | |

310 | IN INT64 Divisor, | |

311 | OUT INT64 *Remainder OPTIONAL | |

312 | ); | |

313 | ||

314 | /** | |

315 | Transfers control to a function starting with a new stack. | |

316 | ||

cb41bea7 | 317 | Transfers control to the function specified by EntryPoint using the |

318 | new stack specified by NewStack and passing in the parameters specified | |

319 | by Context1 and Context2. Context1 and Context2 are optional and may | |

320 | be NULL. The function EntryPoint must never return. | |

321 | Marker will be ignored on IA-32, x64, and EBC. | |

322 | IPF CPUs expect one additional parameter of type VOID * that specifies | |

323 | the new backing store pointer. | |

324 | ||

325 | If EntryPoint is NULL, then ASSERT(). | |

326 | If NewStack is NULL, then ASSERT(). | |

d958721a | 327 | |

328 | @param EntryPoint A pointer to function to call with the new stack. | |

329 | @param Context1 A pointer to the context to pass into the EntryPoint | |

330 | function. | |

331 | @param Context2 A pointer to the context to pass into the EntryPoint | |

332 | function. | |

333 | @param NewStack A pointer to the new stack to use for the EntryPoint | |

334 | function. | |

cb41bea7 | 335 | @param Marker VA_LIST marker for the variable argument list. |

d958721a | 336 | |

337 | **/ | |

338 | VOID | |

339 | EFIAPI | |

340 | InternalSwitchStack ( | |

341 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

cb41bea7 | 342 | IN VOID *Context1, OPTIONAL |

343 | IN VOID *Context2, OPTIONAL | |

344 | IN VOID *NewStack, | |

345 | IN VA_LIST Marker | |

d958721a | 346 | ); |

347 | ||

ff756e60 | 348 | |

349 | /** | |

350 | Worker function that locates the Node in the List | |

351 | ||

352 | By searching the List, finds the location of the Node in List. At the same time, | |

353 | verifies the validity of this list. | |

354 | ||

355 | If List is NULL, then ASSERT(). | |

356 | If List->ForwardLink is NULL, then ASSERT(). | |

357 | If List->backLink is NULL, then ASSERT(). | |

358 | If Node is NULL, then ASSERT(); | |

359 | If PcdMaximumLinkedListLenth is not zero, and prior to insertion the number | |

360 | of nodes in ListHead, including the ListHead node, is greater than or | |

361 | equal to PcdMaximumLinkedListLength, then ASSERT(). | |

362 | ||

363 | @param List A pointer to a node in a linked list. | |

364 | @param Node A pointer to one nod. | |

365 | ||

366 | @retval TRUE Node is in List | |

367 | @retval FALSE Node isn't in List, or List is invalid | |

368 | ||

369 | **/ | |

370 | BOOLEAN | |

371 | IsNodeInList ( | |

372 | IN CONST LIST_ENTRY *List, | |

373 | IN CONST LIST_ENTRY *Node | |

374 | ); | |

375 | ||

376 | ||

377 | /** | |

378 | Performs an atomic increment of an 32-bit unsigned integer. | |

379 | ||

380 | Performs an atomic increment of the 32-bit unsigned integer specified by | |

381 | Value and returns the incremented value. The increment operation must be | |

382 | performed using MP safe mechanisms. The state of the return value is not | |

383 | guaranteed to be MP safe. | |

384 | ||

385 | @param Value A pointer to the 32-bit value to increment. | |

386 | ||

387 | @return The incremented value. | |

388 | ||

389 | **/ | |

390 | UINT32 | |

391 | EFIAPI | |

392 | InternalSyncIncrement ( | |

393 | IN volatile UINT32 *Value | |

394 | ); | |

395 | ||

396 | ||

397 | /** | |

398 | Performs an atomic decrement of an 32-bit unsigned integer. | |

399 | ||

400 | Performs an atomic decrement of the 32-bit unsigned integer specified by | |

401 | Value and returns the decrement value. The decrement operation must be | |

402 | performed using MP safe mechanisms. The state of the return value is not | |

403 | guaranteed to be MP safe. | |

404 | ||

405 | @param Value A pointer to the 32-bit value to decrement. | |

406 | ||

407 | @return The decrement value. | |

408 | ||

409 | **/ | |

410 | UINT32 | |

411 | EFIAPI | |

412 | InternalSyncDecrement ( | |

413 | IN volatile UINT32 *Value | |

414 | ); | |

415 | ||

416 | ||

417 | /** | |

418 | Performs an atomic compare exchange operation on a 32-bit unsigned integer. | |

419 | ||

420 | Performs an atomic compare exchange operation on the 32-bit unsigned integer | |

421 | specified by Value. If Value is equal to CompareValue, then Value is set to | |

422 | ExchangeValue and CompareValue is returned. If Value is not equal to CompareValue, | |

423 | then Value is returned. The compare exchange operation must be performed using | |

424 | MP safe mechanisms. | |

425 | ||

426 | @param Value A pointer to the 32-bit value for the compare exchange | |

427 | operation. | |

428 | @param CompareValue 32-bit value used in compare operation. | |

429 | @param ExchangeValue 32-bit value used in exchange operation. | |

430 | ||

431 | @return The original *Value before exchange. | |

432 | ||

433 | **/ | |

434 | UINT32 | |

435 | EFIAPI | |

436 | InternalSyncCompareExchange32 ( | |

437 | IN volatile UINT32 *Value, | |

438 | IN UINT32 CompareValue, | |

439 | IN UINT32 ExchangeValue | |

440 | ); | |

441 | ||

442 | ||

443 | /** | |

444 | Performs an atomic compare exchange operation on a 64-bit unsigned integer. | |

445 | ||

446 | Performs an atomic compare exchange operation on the 64-bit unsigned integer specified | |

447 | by Value. If Value is equal to CompareValue, then Value is set to ExchangeValue and | |

448 | CompareValue is returned. If Value is not equal to CompareValue, then Value is returned. | |

449 | The compare exchange operation must be performed using MP safe mechanisms. | |

450 | ||

451 | @param Value A pointer to the 64-bit value for the compare exchange | |

452 | operation. | |

453 | @param CompareValue 64-bit value used in compare operation. | |

454 | @param ExchangeValue 64-bit value used in exchange operation. | |

455 | ||

456 | @return The original *Value before exchange. | |

457 | ||

458 | **/ | |

459 | UINT64 | |

460 | EFIAPI | |

461 | InternalSyncCompareExchange64 ( | |

462 | IN volatile UINT64 *Value, | |

463 | IN UINT64 CompareValue, | |

464 | IN UINT64 ExchangeValue | |

465 | ); | |

466 | ||

467 | ||

468 | /** | |

469 | Worker function that returns a bit field from Operand | |

470 | ||

471 | Returns the bitfield specified by the StartBit and the EndBit from Operand. | |

472 | ||

473 | @param Operand Operand on which to perform the bitfield operation. | |

474 | @param StartBit The ordinal of the least significant bit in the bit field. | |

475 | @param EndBit The ordinal of the most significant bit in the bit field. | |

476 | ||

477 | @return The bit field read. | |

478 | ||

479 | **/ | |

480 | unsigned int | |

481 | BitFieldReadUint ( | |

482 | IN unsigned int Operand, | |

483 | IN UINTN StartBit, | |

484 | IN UINTN EndBit | |

485 | ); | |

486 | ||

487 | ||

488 | /** | |

489 | Worker function that reads a bit field from Operand, performs a bitwise OR, | |

490 | and returns the result. | |

491 | ||

492 | Performs a bitwise OR between the bit field specified by StartBit and EndBit | |

493 | in Operand and the value specified by AndData. All other bits in Operand are | |

494 | preserved. The new value is returned. | |

495 | ||

496 | @param Operand Operand on which to perform the bitfield operation. | |

497 | @param StartBit The ordinal of the least significant bit in the bit field. | |

498 | @param EndBit The ordinal of the most significant bit in the bit field. | |

499 | @param OrData The value to OR with the read value from the value | |

500 | ||

501 | @return The new value. | |

502 | ||

503 | **/ | |

504 | unsigned int | |

505 | BitFieldOrUint ( | |

506 | IN unsigned int Operand, | |

507 | IN UINTN StartBit, | |

508 | IN UINTN EndBit, | |

509 | IN unsigned int OrData | |

510 | ); | |

511 | ||

512 | ||

513 | /** | |

514 | Worker function that reads a bit field from Operand, performs a bitwise AND, | |

515 | and returns the result. | |

516 | ||

517 | Performs a bitwise AND between the bit field specified by StartBit and EndBit | |

518 | in Operand and the value specified by AndData. All other bits in Operand are | |

519 | preserved. The new value is returned. | |

520 | ||

521 | @param Operand Operand on which to perform the bitfield operation. | |

522 | @param StartBit The ordinal of the least significant bit in the bit field. | |

523 | @param EndBit The ordinal of the most significant bit in the bit field. | |

524 | @param AndData The value to And with the read value from the value | |

525 | ||

526 | @return The new value. | |

527 | ||

528 | **/ | |

529 | unsigned int | |

530 | BitFieldAndUint ( | |

531 | IN unsigned int Operand, | |

532 | IN UINTN StartBit, | |

533 | IN UINTN EndBit, | |

534 | IN unsigned int AndData | |

535 | ); | |

536 | ||

537 | ||

538 | /** | |

539 | Worker function that checks ASSERT condition for JumpBuffer | |

540 | ||

541 | Checks ASSERT condition for JumpBuffer. | |

542 | ||

543 | If JumpBuffer is NULL, then ASSERT(). | |

544 | For IPF CPUs, if JumpBuffer is not aligned on a 16-byte boundary, then ASSERT(). | |

545 | ||

546 | @param JumpBuffer A pointer to CPU context buffer. | |

547 | ||

548 | **/ | |

549 | VOID | |

550 | InternalAssertJumpBuffer ( | |

551 | IN BASE_LIBRARY_JUMP_BUFFER *JumpBuffer | |

552 | ); | |

553 | ||

554 | ||

555 | /** | |

556 | Restores the CPU context that was saved with SetJump(). | |

557 | ||

558 | Restores the CPU context from the buffer specified by JumpBuffer. | |

559 | This function never returns to the caller. | |

560 | Instead is resumes execution based on the state of JumpBuffer. | |

561 | ||

562 | @param JumpBuffer A pointer to CPU context buffer. | |

563 | @param Value The value to return when the SetJump() context is restored. | |

564 | ||

565 | **/ | |

566 | VOID | |

567 | EFIAPI | |

568 | InternalLongJump ( | |

569 | IN BASE_LIBRARY_JUMP_BUFFER *JumpBuffer, | |

570 | IN UINTN Value | |

571 | ); | |

572 | ||

573 | ||

d958721a | 574 | // |

575 | // Ia32 and x64 specific functions | |

576 | // | |

ff756e60 | 577 | #if defined (MDE_CPU_IA32) || defined (MDE_CPU_X64) |

d958721a | 578 | |

579 | /** | |

580 | Reads the current Global Descriptor Table Register(GDTR) descriptor. | |

581 | ||

582 | Reads and returns the current GDTR descriptor and returns it in Gdtr. This | |

583 | function is only available on IA-32 and X64. | |

584 | ||

585 | @param Gdtr Pointer to a GDTR descriptor. | |

586 | ||

587 | **/ | |

588 | VOID | |

589 | EFIAPI | |

590 | InternalX86ReadGdtr ( | |

591 | OUT IA32_DESCRIPTOR *Gdtr | |

592 | ); | |

593 | ||

594 | /** | |

595 | Writes the current Global Descriptor Table Register (GDTR) descriptor. | |

596 | ||

597 | Writes and the current GDTR descriptor specified by Gdtr. This function is | |

598 | only available on IA-32 and X64. | |

599 | ||

600 | @param Gdtr Pointer to a GDTR descriptor. | |

601 | ||

602 | **/ | |

603 | VOID | |

604 | EFIAPI | |

605 | InternalX86WriteGdtr ( | |

606 | IN CONST IA32_DESCRIPTOR *Gdtr | |

607 | ); | |

608 | ||

609 | /** | |

610 | Reads the current Interrupt Descriptor Table Register(GDTR) descriptor. | |

611 | ||

612 | Reads and returns the current IDTR descriptor and returns it in Idtr. This | |

613 | function is only available on IA-32 and X64. | |

614 | ||

615 | @param Idtr Pointer to a IDTR descriptor. | |

616 | ||

617 | **/ | |

618 | VOID | |

619 | EFIAPI | |

620 | InternalX86ReadIdtr ( | |

621 | OUT IA32_DESCRIPTOR *Idtr | |

622 | ); | |

623 | ||

624 | /** | |

625 | Writes the current Interrupt Descriptor Table Register(GDTR) descriptor. | |

626 | ||

627 | Writes the current IDTR descriptor and returns it in Idtr. This function is | |

628 | only available on IA-32 and X64. | |

629 | ||

630 | @param Idtr Pointer to a IDTR descriptor. | |

631 | ||

632 | **/ | |

633 | VOID | |

634 | EFIAPI | |

635 | InternalX86WriteIdtr ( | |

636 | IN CONST IA32_DESCRIPTOR *Idtr | |

637 | ); | |

638 | ||

639 | /** | |

640 | Save the current floating point/SSE/SSE2 context to a buffer. | |

641 | ||

642 | Saves the current floating point/SSE/SSE2 state to the buffer specified by | |

643 | Buffer. Buffer must be aligned on a 16-byte boundary. This function is only | |

644 | available on IA-32 and X64. | |

645 | ||

646 | @param Buffer Pointer to a buffer to save the floating point/SSE/SSE2 context. | |

647 | ||

648 | **/ | |

649 | VOID | |

650 | EFIAPI | |

651 | InternalX86FxSave ( | |

652 | OUT IA32_FX_BUFFER *Buffer | |

653 | ); | |

654 | ||

655 | /** | |

656 | Restores the current floating point/SSE/SSE2 context from a buffer. | |

657 | ||

658 | Restores the current floating point/SSE/SSE2 state from the buffer specified | |

659 | by Buffer. Buffer must be aligned on a 16-byte boundary. This function is | |

660 | only available on IA-32 and X64. | |

661 | ||

662 | @param Buffer Pointer to a buffer to save the floating point/SSE/SSE2 context. | |

663 | ||

664 | **/ | |

665 | VOID | |

666 | EFIAPI | |

667 | InternalX86FxRestore ( | |

668 | IN CONST IA32_FX_BUFFER *Buffer | |

669 | ); | |

670 | ||

671 | /** | |

672 | Enables the 32-bit paging mode on the CPU. | |

673 | ||

674 | Enables the 32-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables | |

675 | must be properly initialized prior to calling this service. This function | |

676 | assumes the current execution mode is 32-bit protected mode. This function is | |

677 | only available on IA-32. After the 32-bit paging mode is enabled, control is | |

678 | transferred to the function specified by EntryPoint using the new stack | |

679 | specified by NewStack and passing in the parameters specified by Context1 and | |

680 | Context2. Context1 and Context2 are optional and may be NULL. The function | |

681 | EntryPoint must never return. | |

682 | ||

683 | There are a number of constraints that must be followed before calling this | |

684 | function: | |

685 | 1) Interrupts must be disabled. | |

686 | 2) The caller must be in 32-bit protected mode with flat descriptors. This | |

687 | means all descriptors must have a base of 0 and a limit of 4GB. | |

688 | 3) CR0 and CR4 must be compatible with 32-bit protected mode with flat | |

689 | descriptors. | |

690 | 4) CR3 must point to valid page tables that will be used once the transition | |

691 | is complete, and those page tables must guarantee that the pages for this | |

692 | function and the stack are identity mapped. | |

693 | ||

694 | @param EntryPoint A pointer to function to call with the new stack after | |

695 | paging is enabled. | |

696 | @param Context1 A pointer to the context to pass into the EntryPoint | |

697 | function as the first parameter after paging is enabled. | |

698 | @param Context2 A pointer to the context to pass into the EntryPoint | |

699 | function as the second parameter after paging is enabled. | |

700 | @param NewStack A pointer to the new stack to use for the EntryPoint | |

701 | function after paging is enabled. | |

702 | ||

703 | **/ | |

704 | VOID | |

705 | EFIAPI | |

706 | InternalX86EnablePaging32 ( | |

707 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

708 | IN VOID *Context1, OPTIONAL | |

709 | IN VOID *Context2, OPTIONAL | |

710 | IN VOID *NewStack | |

711 | ); | |

712 | ||

713 | /** | |

714 | Disables the 32-bit paging mode on the CPU. | |

715 | ||

716 | Disables the 32-bit paging mode on the CPU and returns to 32-bit protected | |

717 | mode. This function assumes the current execution mode is 32-paged protected | |

718 | mode. This function is only available on IA-32. After the 32-bit paging mode | |

719 | is disabled, control is transferred to the function specified by EntryPoint | |

720 | using the new stack specified by NewStack and passing in the parameters | |

721 | specified by Context1 and Context2. Context1 and Context2 are optional and | |

722 | may be NULL. The function EntryPoint must never return. | |

723 | ||

724 | There are a number of constraints that must be followed before calling this | |

725 | function: | |

726 | 1) Interrupts must be disabled. | |

727 | 2) The caller must be in 32-bit paged mode. | |

728 | 3) CR0, CR3, and CR4 must be compatible with 32-bit paged mode. | |

729 | 4) CR3 must point to valid page tables that guarantee that the pages for | |

730 | this function and the stack are identity mapped. | |

731 | ||

732 | @param EntryPoint A pointer to function to call with the new stack after | |

733 | paging is disabled. | |

734 | @param Context1 A pointer to the context to pass into the EntryPoint | |

735 | function as the first parameter after paging is disabled. | |

736 | @param Context2 A pointer to the context to pass into the EntryPoint | |

737 | function as the second parameter after paging is | |

738 | disabled. | |

739 | @param NewStack A pointer to the new stack to use for the EntryPoint | |

740 | function after paging is disabled. | |

741 | ||

742 | **/ | |

743 | VOID | |

744 | EFIAPI | |

745 | InternalX86DisablePaging32 ( | |

746 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

747 | IN VOID *Context1, OPTIONAL | |

748 | IN VOID *Context2, OPTIONAL | |

749 | IN VOID *NewStack | |

750 | ); | |

751 | ||

752 | /** | |

753 | Enables the 64-bit paging mode on the CPU. | |

754 | ||

755 | Enables the 64-bit paging mode on the CPU. CR0, CR3, CR4, and the page tables | |

756 | must be properly initialized prior to calling this service. This function | |

757 | assumes the current execution mode is 32-bit protected mode with flat | |

758 | descriptors. This function is only available on IA-32. After the 64-bit | |

759 | paging mode is enabled, control is transferred to the function specified by | |

760 | EntryPoint using the new stack specified by NewStack and passing in the | |

761 | parameters specified by Context1 and Context2. Context1 and Context2 are | |

762 | optional and may be 0. The function EntryPoint must never return. | |

763 | ||

764 | @param Cs The 16-bit selector to load in the CS before EntryPoint | |

765 | is called. The descriptor in the GDT that this selector | |

766 | references must be setup for long mode. | |

767 | @param EntryPoint The 64-bit virtual address of the function to call with | |

768 | the new stack after paging is enabled. | |

769 | @param Context1 The 64-bit virtual address of the context to pass into | |

770 | the EntryPoint function as the first parameter after | |

771 | paging is enabled. | |

772 | @param Context2 The 64-bit virtual address of the context to pass into | |

773 | the EntryPoint function as the second parameter after | |

774 | paging is enabled. | |

775 | @param NewStack The 64-bit virtual address of the new stack to use for | |

776 | the EntryPoint function after paging is enabled. | |

777 | ||

778 | **/ | |

779 | VOID | |

780 | EFIAPI | |

781 | InternalX86EnablePaging64 ( | |

782 | IN UINT16 Cs, | |

783 | IN UINT64 EntryPoint, | |

784 | IN UINT64 Context1, OPTIONAL | |

785 | IN UINT64 Context2, OPTIONAL | |

786 | IN UINT64 NewStack | |

787 | ); | |

788 | ||

789 | /** | |

790 | Disables the 64-bit paging mode on the CPU. | |

791 | ||

792 | Disables the 64-bit paging mode on the CPU and returns to 32-bit protected | |

793 | mode. This function assumes the current execution mode is 64-paging mode. | |

794 | This function is only available on X64. After the 64-bit paging mode is | |

795 | disabled, control is transferred to the function specified by EntryPoint | |

796 | using the new stack specified by NewStack and passing in the parameters | |

797 | specified by Context1 and Context2. Context1 and Context2 are optional and | |

798 | may be 0. The function EntryPoint must never return. | |

799 | ||

800 | @param Cs The 16-bit selector to load in the CS before EntryPoint | |

801 | is called. The descriptor in the GDT that this selector | |

802 | references must be setup for 32-bit protected mode. | |

803 | @param EntryPoint The 64-bit virtual address of the function to call with | |

804 | the new stack after paging is disabled. | |

805 | @param Context1 The 64-bit virtual address of the context to pass into | |

806 | the EntryPoint function as the first parameter after | |

807 | paging is disabled. | |

808 | @param Context2 The 64-bit virtual address of the context to pass into | |

809 | the EntryPoint function as the second parameter after | |

810 | paging is disabled. | |

811 | @param NewStack The 64-bit virtual address of the new stack to use for | |

812 | the EntryPoint function after paging is disabled. | |

813 | ||

814 | **/ | |

815 | VOID | |

816 | EFIAPI | |

817 | InternalX86DisablePaging64 ( | |

818 | IN UINT16 Cs, | |

819 | IN UINT32 EntryPoint, | |

820 | IN UINT32 Context1, OPTIONAL | |

821 | IN UINT32 Context2, OPTIONAL | |

822 | IN UINT32 NewStack | |

823 | ); | |

824 | ||

cb41bea7 | 825 | |

ff756e60 | 826 | #elif defined (MDE_CPU_IPF) |

827 | // | |

cb41bea7 | 828 | // |

829 | // IPF specific functions | |

830 | // | |

831 | ||

832 | /** | |

833 | Transfers control to a function starting with a new stack. | |

834 | ||

835 | Transfers control to the function specified by EntryPoint using the new stack | |

836 | specified by NewStack and passing in the parameters specified by Context1 and | |

837 | Context2. Context1 and Context2 are optional and may be NULL. The function | |

838 | EntryPoint must never return. | |

839 | ||

840 | If EntryPoint is NULL, then ASSERT(). | |

841 | If NewStack is NULL, then ASSERT(). | |

842 | ||

843 | @param EntryPoint A pointer to function to call with the new stack. | |

844 | @param Context1 A pointer to the context to pass into the EntryPoint | |

845 | function. | |

846 | @param Context2 A pointer to the context to pass into the EntryPoint | |

847 | function. | |

848 | @param NewStack A pointer to the new stack to use for the EntryPoint | |

849 | function. | |

850 | @param NewBsp A pointer to the new memory location for RSE backing | |

851 | store. | |

852 | ||

853 | **/ | |

854 | VOID | |

855 | EFIAPI | |

856 | AsmSwitchStackAndBackingStore ( | |

857 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

858 | IN VOID *Context1, OPTIONAL | |

859 | IN VOID *Context2, OPTIONAL | |

860 | IN VOID *NewStack, | |

861 | IN VOID *NewBsp | |

862 | ); | |

ff756e60 | 863 | #else |

864 | ||

865 | #endif | |

cb41bea7 | 866 | |

d958721a | 867 | #endif |