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 | ||

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

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

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

320 | EntryPoint must never return. | |

321 | ||

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

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

324 | function. | |

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

326 | function. | |

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

328 | function. | |

329 | ||

330 | **/ | |

331 | VOID | |

332 | EFIAPI | |

333 | InternalSwitchStack ( | |

334 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

335 | IN VOID *Context1, | |

336 | IN VOID *Context2, | |

337 | IN VOID *NewStack | |

338 | ); | |

339 | ||

340 | // | |

341 | // Ia32 and x64 specific functions | |

342 | // | |

343 | ||

344 | /** | |

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

346 | ||

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

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

349 | ||

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

351 | ||

352 | **/ | |

353 | VOID | |

354 | EFIAPI | |

355 | InternalX86ReadGdtr ( | |

356 | OUT IA32_DESCRIPTOR *Gdtr | |

357 | ); | |

358 | ||

359 | /** | |

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

361 | ||

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

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

364 | ||

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

366 | ||

367 | **/ | |

368 | VOID | |

369 | EFIAPI | |

370 | InternalX86WriteGdtr ( | |

371 | IN CONST IA32_DESCRIPTOR *Gdtr | |

372 | ); | |

373 | ||

374 | /** | |

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

376 | ||

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

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

379 | ||

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

381 | ||

382 | **/ | |

383 | VOID | |

384 | EFIAPI | |

385 | InternalX86ReadIdtr ( | |

386 | OUT IA32_DESCRIPTOR *Idtr | |

387 | ); | |

388 | ||

389 | /** | |

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

391 | ||

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

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

394 | ||

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

396 | ||

397 | **/ | |

398 | VOID | |

399 | EFIAPI | |

400 | InternalX86WriteIdtr ( | |

401 | IN CONST IA32_DESCRIPTOR *Idtr | |

402 | ); | |

403 | ||

404 | /** | |

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

406 | ||

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

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

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

410 | ||

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

412 | ||

413 | **/ | |

414 | VOID | |

415 | EFIAPI | |

416 | InternalX86FxSave ( | |

417 | OUT IA32_FX_BUFFER *Buffer | |

418 | ); | |

419 | ||

420 | /** | |

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

422 | ||

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

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

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

426 | ||

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

428 | ||

429 | **/ | |

430 | VOID | |

431 | EFIAPI | |

432 | InternalX86FxRestore ( | |

433 | IN CONST IA32_FX_BUFFER *Buffer | |

434 | ); | |

435 | ||

436 | /** | |

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

438 | ||

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

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

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

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

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

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

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

446 | EntryPoint must never return. | |

447 | ||

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

449 | function: | |

450 | 1) Interrupts must be disabled. | |

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

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

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

454 | descriptors. | |

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

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

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

458 | ||

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

460 | paging is enabled. | |

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

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

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

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

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

466 | function after paging is enabled. | |

467 | ||

468 | **/ | |

469 | VOID | |

470 | EFIAPI | |

471 | InternalX86EnablePaging32 ( | |

472 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

473 | IN VOID *Context1, OPTIONAL | |

474 | IN VOID *Context2, OPTIONAL | |

475 | IN VOID *NewStack | |

476 | ); | |

477 | ||

478 | /** | |

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

480 | ||

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

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

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

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

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

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

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

488 | ||

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

490 | function: | |

491 | 1) Interrupts must be disabled. | |

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

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

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

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

496 | ||

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

498 | paging is disabled. | |

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

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

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

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

503 | disabled. | |

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

505 | function after paging is disabled. | |

506 | ||

507 | **/ | |

508 | VOID | |

509 | EFIAPI | |

510 | InternalX86DisablePaging32 ( | |

511 | IN SWITCH_STACK_ENTRY_POINT EntryPoint, | |

512 | IN VOID *Context1, OPTIONAL | |

513 | IN VOID *Context2, OPTIONAL | |

514 | IN VOID *NewStack | |

515 | ); | |

516 | ||

517 | /** | |

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

519 | ||

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

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

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

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

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

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

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

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

528 | ||

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

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

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

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

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

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

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

536 | paging is enabled. | |

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

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

539 | paging is enabled. | |

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

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

542 | ||

543 | **/ | |

544 | VOID | |

545 | EFIAPI | |

546 | InternalX86EnablePaging64 ( | |

547 | IN UINT16 Cs, | |

548 | IN UINT64 EntryPoint, | |

549 | IN UINT64 Context1, OPTIONAL | |

550 | IN UINT64 Context2, OPTIONAL | |

551 | IN UINT64 NewStack | |

552 | ); | |

553 | ||

554 | /** | |

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

556 | ||

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

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

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

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

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

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

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

564 | ||

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

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

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

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

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

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

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

572 | paging is disabled. | |

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

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

575 | paging is disabled. | |

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

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

578 | ||

579 | **/ | |

580 | VOID | |

581 | EFIAPI | |

582 | InternalX86DisablePaging64 ( | |

583 | IN UINT16 Cs, | |

584 | IN UINT32 EntryPoint, | |

585 | IN UINT32 Context1, OPTIONAL | |

586 | IN UINT32 Context2, OPTIONAL | |

587 | IN UINT32 NewStack | |

588 | ); | |

589 | ||

590 | /** | |

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

592 | ||

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

594 | verifies the validity of this list. | |

595 | ||

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

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

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

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

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

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

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

603 | ||

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

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

606 | ||

607 | @retval TRUE Node is in List | |

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

609 | ||

610 | **/ | |

611 | BOOLEAN | |

612 | IsNodeInList ( | |

613 | IN CONST LIST_ENTRY *List, | |

614 | IN CONST LIST_ENTRY *Node | |

615 | ); | |

616 | ||

617 | /** | |

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

619 | ||

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

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

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

623 | guaranteed to be MP safe. | |

624 | ||

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

626 | ||

627 | @return The incremented value. | |

628 | ||

629 | **/ | |

630 | UINT32 | |

631 | EFIAPI | |

632 | InternalSyncIncrement ( | |

633 | IN volatile UINT32 *Value | |

634 | ); | |

635 | ||

636 | /** | |

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

638 | ||

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

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

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

642 | guaranteed to be MP safe. | |

643 | ||

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

645 | ||

646 | @return The decrement value. | |

647 | ||

648 | **/ | |

649 | UINT32 | |

650 | EFIAPI | |

651 | InternalSyncDecrement ( | |

652 | IN volatile UINT32 *Value | |

653 | ); | |

654 | ||

655 | /** | |

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

657 | ||

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

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

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

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

662 | MP safe mechanisms. | |

663 | ||

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

665 | operation. | |

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

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

668 | ||

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

670 | ||

671 | **/ | |

672 | UINT32 | |

673 | EFIAPI | |

674 | InternalSyncCompareExchange32 ( | |

675 | IN volatile UINT32 *Value, | |

676 | IN UINT32 CompareValue, | |

677 | IN UINT32 ExchangeValue | |

678 | ); | |

679 | ||

680 | /** | |

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

682 | ||

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

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

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

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

687 | ||

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

689 | operation. | |

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

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

692 | ||

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

694 | ||

695 | **/ | |

696 | UINT64 | |

697 | EFIAPI | |

698 | InternalSyncCompareExchange64 ( | |

699 | IN volatile UINT64 *Value, | |

700 | IN UINT64 CompareValue, | |

701 | IN UINT64 ExchangeValue | |

702 | ); | |

703 | ||

704 | /** | |

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

706 | ||

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

708 | ||

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

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

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

712 | ||

713 | @return The bit field read. | |

714 | ||

715 | **/ | |

716 | unsigned int | |

717 | BitFieldReadUint ( | |

718 | IN unsigned int Operand, | |

719 | IN UINTN StartBit, | |

720 | IN UINTN EndBit | |

721 | ); | |

722 | ||

723 | /** | |

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

725 | and returns the result. | |

726 | ||

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

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

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

730 | ||

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

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

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

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

735 | ||

736 | @return The new value. | |

737 | ||

738 | **/ | |

739 | unsigned int | |

740 | BitFieldOrUint ( | |

741 | IN unsigned int Operand, | |

742 | IN UINTN StartBit, | |

743 | IN UINTN EndBit, | |

744 | IN unsigned int OrData | |

745 | ); | |

746 | ||

747 | /** | |

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

749 | and returns the result. | |

750 | ||

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

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

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

754 | ||

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

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

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

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

759 | ||

760 | @return The new value. | |

761 | ||

762 | **/ | |

763 | unsigned int | |

764 | BitFieldAndUint ( | |

765 | IN unsigned int Operand, | |

766 | IN UINTN StartBit, | |

767 | IN UINTN EndBit, | |

768 | IN unsigned int AndData | |

769 | ); | |

770 | ||

771 | /** | |

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

773 | ||

774 | Checks ASSERT condition for JumpBuffer. | |

775 | ||

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

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

778 | ||

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

780 | ||

781 | **/ | |

782 | VOID | |

783 | InternalAssertJumpBuffer ( | |

784 | IN BASE_LIBRARY_JUMP_BUFFER *JumpBuffer | |

785 | ); | |

786 | ||

787 | /** | |

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

789 | ||

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

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

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

793 | ||

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

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

796 | ||

797 | **/ | |

798 | VOID | |

799 | EFIAPI | |

800 | InternalLongJump ( | |

801 | IN BASE_LIBRARY_JUMP_BUFFER *JumpBuffer, | |

802 | IN UINTN Value | |

803 | ); | |

804 | ||

805 | #endif |